From a6e3969e9d99719164e894b6f026677177bf5d16 Mon Sep 17 00:00:00 2001
From: Brandon Busacker <bbusacker@micron.com>
Date: Mon, 12 Jan 2026 17:18:25 -0700
Subject: [PATCH 01/83] Initial Windows cross-platform support for libnvme
 (#21)

* feat: Windows cross-platform support for libnvme

Added libnvme build support for Windows.

- Added platform-specific include files for Linux/Windows.
- Added BUILD.md with detailed build instructions for Linux and Windows
- Added ENVIRONMENT.md with environment setup guide for both platforms
- Fix format string warnings in nbft.c (use %u instead of %zd for MinGW compatibility)
- Add forward declarations in windows-stubs.c to fix struct warnings
- Skipping generate-accessors for now.  Needs to be ported for Windows.
- Note: leaving asprintf warning in generate-accessors.c since it is present in the master branch as well.

Co-authored-by: Broc Going <bgoing@micron.com>
Co-authored-by: bbusacker <bbusacker@localhost.localdomain>
Co-authored-by: Brandon Capener <bcapener@micron.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 .gitignore                                    |    2 +-
 BUILD.md                                      |  467 +++++++
 ENVIRONMENT.md                                |  309 +++++
 ccan/ccan/minmax/minmax.h                     |    4 +
 libnvme/examples/meson.build                  |    6 +
 libnvme/src/meson.build                       |   68 +-
 libnvme/src/nvme/cleanup.h                    |    6 +-
 libnvme/src/nvme/fabrics.c                    |    7 +-
 libnvme/src/nvme/ioctl.c                      |    5 -
 libnvme/src/nvme/ioctl.h                      |    3 +-
 libnvme/src/nvme/linux.c                      |    5 +-
 libnvme/src/nvme/log.c                        |    3 +-
 libnvme/src/nvme/log.h                        |    2 +-
 libnvme/src/nvme/meson.build                  |    5 +
 libnvme/src/nvme/mi-mctp.c                    |    7 +-
 libnvme/src/nvme/mi.h                         |    2 +-
 libnvme/src/nvme/nbft.c                       |   17 +-
 libnvme/src/nvme/platform/platform_includes.h |   30 +
 libnvme/src/nvme/platform/platform_linux.h    |   41 +
 libnvme/src/nvme/platform/platform_windows.h  |  254 ++++
 libnvme/src/nvme/private.h                    |    4 +-
 libnvme/src/nvme/tree.c                       |    7 +-
 libnvme/src/nvme/tree.h                       |    4 +-
 libnvme/src/nvme/types.h                      |    2 +-
 libnvme/src/nvme/util.c                       |    6 +-
 libnvme/src/nvme/util.h                       |    2 +-
 libnvme/src/nvme/windows-stubs.c              | 1075 +++++++++++++++++
 libnvme/test/ioctl/ana.c                      |    1 +
 libnvme/test/nbft/meson.build                 |    4 +
 meson.build                                   |  212 ++--
 30 files changed, 2400 insertions(+), 160 deletions(-)
 create mode 100644 BUILD.md
 create mode 100644 ENVIRONMENT.md
 create mode 100644 libnvme/src/nvme/platform/platform_includes.h
 create mode 100644 libnvme/src/nvme/platform/platform_linux.h
 create mode 100644 libnvme/src/nvme/platform/platform_windows.h
 create mode 100644 libnvme/src/nvme/windows-stubs.c

diff --git a/.gitignore b/.gitignore
index f1b504ee46..9f50b93cde 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,3 @@
-nvme
 *.xml
 a.out
 *.o
@@ -19,3 +18,4 @@ tests/*.pyc
 .build
 .build-ci
 .cache
+.vscode/
diff --git a/BUILD.md b/BUILD.md
new file mode 100644
index 0000000000..2a50d87aac
--- /dev/null
+++ b/BUILD.md
@@ -0,0 +1,467 @@
+# Build Guide for nvme-cli
+
+This document provides instructions for building nvme-cli and libnvme on both Linux and Windows platforms.
+
+> **Prerequisites:** Before building, ensure your environment is properly set up by following the instructions in [ENVIRONMENT.md](ENVIRONMENT.md).
+
+## Table of Contents
+
+- [Build Configuration Options](#build-configuration-options)
+- [Building libnvme](#building-libnvme)
+- [Building nvme-cli](#building-nvme-cli)
+- [Common Build Scenarios](#common-build-scenarios)
+- [Reconfiguring](#reconfiguring-an-existing-build)
+- [Troubleshooting](#troubleshooting)
+
+## Meson Options
+
+Key options available via `-D<option>=<value>`:
+
+| Option | Values | Default | Description |
+|--------|--------|---------|-------------|
+| `nvme` | enabled/disabled/auto | enabled | Build nvme executable |
+| `libnvme` | enabled/disabled/auto | enabled | Build libnvme library |
+| `default_library` | static/shared/both | shared | Library build type |
+| `tests` | true/false | true | Build tests |
+| `nvme-tests` | true/false | false | Run tests against real hardware |
+| `docs` | false/html/man/rst/all | false | Install documentation |
+| `docs-build` | true/false | false | Build documentation |
+| `examples` | true/false | true | Build examples |
+| `python` | enabled/disabled/auto | auto | Build Python bindings |
+| `json-c` | enabled/disabled/auto | auto | JSON support (Linux only) |
+| `openssl` | enabled/disabled/auto | auto | OpenSSL support |
+| `keyutils` | enabled/disabled/auto | auto | Keyutils support (Linux only) |
+| `libdbus` | enabled/disabled/auto | disabled | DBus support (Linux only) |
+| `liburing` | enabled/disabled/auto | disabled | io_uring support (Linux only) |
+| `version-tag` | string | (auto-detected) | Override version (required on Windows with MinGW to avoid bash dependency) |
+
+**Important for Windows:** When using MinGW on Windows, always specify `-Dversion-tag=<version>` (e.g., `-Dversion-tag=3.0-a.1`) to bypass a bash script that detects the git version. Without this option, the build will fail in PowerShell environments.
+
+### Common Configuration Patterns
+
+#### Minimal Build (libnvme only, no tests, no docs)
+
+**Linux:**
+```bash
+meson setup .build \
+    -Dnvme=disabled \
+    -Dlibnvme=enabled \
+    -Dtests=false \
+    -Ddocs=false \
+    -Ddocs-build=false \
+    -Dexamples=false
+```
+
+**Windows (PowerShell):**
+```powershell
+meson setup .build `
+    -Dnvme=disabled `
+    -Dlibnvme=enabled `
+    -Dtests=false `
+    -Ddocs=false `
+    -Ddocs-build=false `
+    -Dexamples=false `
+    -Dversion-tag=3.0-a.1
+```
+
+#### Full Featured Build
+```bash
+meson setup .build \
+    -Djson-c=enabled \
+    -Dopenssl=enabled \
+    -Dkeyutils=enabled \
+    -Dtests=true \
+    -Ddocs-build=true
+```
+
+#### Static Library Build
+```bash
+meson setup .build -Ddefault_library=static
+```
+
+#### Dynamic Library Build
+```bash
+meson setup .build -Ddefault_library=shared
+```
+
+## Building libnvme
+
+Starting with nvme-cli 3.x, libnvme is fully integrated into the nvme-cli source tree. There is no separate repository or external dependency.
+
+### Basic libnvme Build
+
+Build libnvme only (without nvme-cli, tests, or documentation):
+
+**Linux:**
+```bash
+# Configure
+meson setup .build \
+    -Dnvme=disabled \
+    -Dlibnvme=enabled \
+    -Dtests=false \
+    -Ddocs=false \
+    -Ddocs-build=false \
+    -Dexamples=false
+
+# Build
+meson compile -C .build
+
+# Install (optional)
+sudo meson install -C .build
+```
+
+**Windows (PowerShell with MinGW):**
+```powershell
+# Set PATH (adjust paths if needed)
+$env:PATH = "C:\Users\$env:USERNAME\AppData\Local\Microsoft\WinGet\Packages\BrechtSanders.WinLibs.POSIX.UCRT_Microsoft.Winget.Source_8wekyb3d8bbwe\mingw64\bin;C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312\Scripts;C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312;$env:PATH"
+
+# Configure
+meson setup .build `
+    -Dnvme=disabled `
+    -Dlibnvme=enabled `
+    -Dtests=false `
+    -Ddocs=false `
+    -Ddocs-build=false `
+    -Dexamples=false `
+    -Dversion-tag=3.0-a.1
+
+# Build
+meson compile -C .build
+
+# Install (optional, requires admin privileges)
+meson install -C .build
+```
+
+### Static Build
+
+To build libnvme as a static library:
+
+```bash
+meson setup .build \
+    -Ddefault_library=static \
+    -Dnvme=disabled \
+    -Dlibnvme=enabled \
+    -Dtests=false \
+    -Ddocs=false \
+    -Ddocs-build=false
+    
+meson compile -C .build
+```
+
+The static library will be located at: `.build/libnvme/src/libnvme.a` (Linux) or `.build/libnvme/src/libnvme.lib` (Windows)
+
+### Dynamic Build
+
+To build libnvme as a shared library:
+
+```bash
+meson setup .build \
+    -Ddefault_library=shared \
+    -Dnvme=disabled \
+    -Dlibnvme=enabled \
+    -Dtests=false \
+    -Ddocs=false \
+    -Ddocs-build=false
+    
+meson compile -C .build
+```
+
+The shared library will be located at: 
+- Linux: `.build/libnvme/src/libnvme.so.<version>`
+- Windows: `.build/libnvme/src/libnvme.dll`
+
+### Without Tests
+
+To skip building tests (recommended for production builds):
+
+```bash
+meson setup .build \
+    -Dtests=false \
+    -Dnvme-tests=false
+    
+meson compile -C .build
+```
+
+### Without Documentation
+
+To skip building documentation:
+
+```bash
+meson setup .build \
+    -Ddocs=false \
+    -Ddocs-build=false
+    
+meson compile -C .build
+```
+
+### With Specific Dependencies
+
+#### Linux with JSON and OpenSSL
+```bash
+meson setup .build \
+    -Djson-c=enabled \
+    -Dopenssl=enabled \
+    -Dkeyutils=enabled
+    
+meson compile -C .build
+```
+
+#### Windows with OpenSSL
+```bash
+meson setup .build -Dopenssl=enabled
+meson compile -C .build
+```
+
+## Building nvme-cli
+
+To build the complete nvme-cli tool (includes libnvme):
+
+### Linux
+
+```bash
+# Configure with all features
+meson setup .build
+
+# Or minimal configuration
+meson setup .build \
+    -Djson-c=disabled \
+    -Dopenssl=disabled \
+    -Dtests=false \
+    -Ddocs=false
+
+# Build
+meson compile -C .build
+
+# Install
+sudo meson install -C .build
+```
+
+### Windows
+
+```bash
+# Configure (in Visual Studio Developer Command Prompt)
+meson setup .build
+
+# Build
+meson compile -C .build
+
+# Install (requires admin privileges)
+meson install -C .build
+```
+
+## Common Build Scenarios
+
+### Scenario 1: Development Build (Linux)
+
+Quick build for development with all features:
+
+```bash
+meson setup .build -Dbuildtype=debug
+meson compile -C .build
+```
+
+### Scenario 2: Release Build (Linux)
+
+Optimized build for production:
+
+```bash
+meson setup .build \
+    -Dbuildtype=release \
+    -Ddefault_library=shared \
+    -Djson-c=enabled \
+    -Dopenssl=enabled
+    
+meson compile -C .build
+sudo meson install -C .build
+```
+
+### Scenario 3: Static Binary (Linux)
+
+Single static binary with no dependencies:
+
+```bash
+meson setup .build \
+    -Ddefault_library=static \
+    -Dbuildtype=release \
+    -Djson-c=disabled \
+    -Dopenssl=disabled
+    
+meson compile -C .build
+```
+
+Or use the Makefile wrapper:
+```bash
+make static
+```
+
+### Scenario 4: Cross-Compilation (Linux)
+
+For embedded systems or different architectures:
+
+```bash
+# Create a cross-file (e.g., arm64-cross.txt)
+# Then configure with cross-file
+meson setup .build --cross-file arm64-cross.txt
+
+meson compile -C .build
+```
+
+Example using the build script:
+```bash
+./scripts/build.sh -b release -c gcc -t aarch64 cross
+```
+
+### Scenario 5: Windows DLL Build
+
+Build shared library on Windows:
+
+```bash
+meson setup .build -Ddefault_library=shared
+meson compile -C .build
+```
+
+### Scenario 6: CI/Testing Build
+
+For continuous integration or testing:
+
+```bash
+meson setup .build \
+    -Dtests=true \
+    -Dexamples=true \
+    -Dwarn_level=3
+    
+meson compile -C .build
+meson test -C .build
+```
+
+## Reconfiguring an Existing Build
+
+To change configuration options without starting over:
+
+```bash
+# View current configuration
+meson configure .build
+
+# Change specific options
+meson configure .build -Dtests=false -Ddocs=false
+
+# Rebuild with new configuration
+meson compile -C .build
+```
+
+## Cleaning Build Directory
+
+```bash
+# Clean build artifacts (keeps configuration)
+ninja -C .build clean
+
+# Or completely remove build directory
+rm -rf .build
+```
+
+## Troubleshooting
+
+### Dependency Not Found
+
+If meson reports a missing dependency:
+
+1. Check if it's optional and can be disabled:
+   ```bash
+   meson setup .build -D<dependency>=disabled
+   ```
+
+2. Install the dependency using your package manager
+
+3. Set `PKG_CONFIG_PATH` if installed in non-standard location:
+   ```bash
+   export PKG_CONFIG_PATH=/path/to/pkgconfig:$PKG_CONFIG_PATH
+   ```
+
+### Windows-Specific Issues
+
+#### "bash command not found" or Script Execution Errors
+
+**Problem:** Meson tries to execute a bash script to detect the git version, failing with:
+```
+ERROR: Command `bash C:\Users\...\scripts/meson-vcs-tag.sh ...` failed
+```
+
+**Solution:** Always specify the `-Dversion-tag` option when configuring:
+```powershell
+meson setup .build -Dversion-tag=3.0-a.1 [other options...]
+```
+
+#### "meson: command not found"
+
+**Problem:** Meson is not in the PATH.
+
+**Solution:** Set the PATH to include Python and Scripts directories:
+```powershell
+$env:PATH = "C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312\Scripts;C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312;$env:PATH"
+```
+
+Or locate meson using:
+```powershell
+Get-ChildItem -Path "$env:LOCALAPPDATA\Programs\Python" -Recurse -Filter "meson.exe" | Select-Object -First 1 -ExpandProperty FullName
+```
+
+#### "gcc: command not found"
+
+**Problem:** MinGW GCC is not in the PATH.
+
+**Solution:** Add MinGW to PATH. First, locate the installation:
+```powershell
+Get-ChildItem -Path "$env:LOCALAPPDATA\Microsoft\WinGet\Packages" -Filter "*WinLibs*" -Directory
+```
+
+Then add to PATH:
+```powershell
+$env:PATH = "C:\Users\$env:USERNAME\AppData\Local\Microsoft\WinGet\Packages\BrechtSanders.WinLibs.POSIX.UCRT_Microsoft.Winget.Source_8wekyb3d8bbwe\mingw64\bin;$env:PATH"
+```
+
+#### Setting PATH Permanently on Windows
+
+To avoid setting PATH every time:
+
+1. Open System Properties:
+   - Press `Win + X` → System → Advanced system settings
+   - Or search for "Environment Variables" in Start Menu
+
+2. Click "Environment Variables"
+
+3. Under "User variables", select "Path" and click "Edit"
+
+4. Click "New" and add these paths (adjust as needed):
+   - `C:\Users\YourUsername\AppData\Local\Microsoft\WinGet\Packages\BrechtSanders.WinLibs.POSIX.UCRT_Microsoft.Winget.Source_8wekyb3d8bbwe\mingw64\bin`
+   - `C:\Users\YourUsername\AppData\Local\Programs\Python\Python312`
+   - `C:\Users\YourUsername\AppData\Local\Programs\Python\Python312\Scripts`
+
+5. Click OK on all dialogs and restart PowerShell
+
+### General Build Issues
+
+### Minimal Build Requirements
+
+If you have limited dependencies, use this minimal configuration:
+
+```bash
+meson setup .build \
+    -Dnvme=disabled \
+    -Dlibnvme=enabled \
+    -Dtests=false \
+    -Ddocs=false \
+    -Ddocs-build=false \
+    -Dexamples=false \
+    -Djson-c=disabled \
+    -Dopenssl=disabled \
+    -Dkeyutils=disabled \
+    -Dlibdbus=disabled \
+    -Dliburing=disabled
+```
+
+## Additional Resources
+
+- Main README: [README.md](README.md)
+- Meson documentation: https://mesonbuild.com/
+- libnvme documentation: `libnvme/doc/`
+- GitHub Actions CI examples: `.github/workflows/`
diff --git a/ENVIRONMENT.md b/ENVIRONMENT.md
new file mode 100644
index 0000000000..40cb116f04
--- /dev/null
+++ b/ENVIRONMENT.md
@@ -0,0 +1,309 @@
+# Environment Setup for nvme-cli
+
+This guide covers how to set up your development environment for building nvme-cli and libnvme on Linux and Windows platforms.
+
+## Dependencies Overview
+
+### Core Build Tools
+
+**Both Platforms:**
+- Meson >= 0.62.0 (build system)
+- Ninja (build backend) or Samurai (minimal alternative)
+- C compiler (GCC or Clang on Linux, MSVC or MinGW on Windows)
+
+### Platform-Specific Dependencies
+
+#### Linux Dependencies
+
+**Required:**
+- gcc or clang
+- meson
+- ninja-build or samurai
+
+**Optional (recommended):**
+- json-c >= 0.13 (for JSON output and plugins)
+- OpenSSL >= 3.0.0 (for security features)
+- libkeyutils (for key management)
+- liburing >= 2.2 (for io_uring support)
+- dbus-1 (for MCTP dbus scan support)
+
+**Documentation (optional):**
+- asciidoc or asciidoctor
+- xmlto
+
+**Testing (optional):**
+- Python 3 with pytest (for tests)
+- SWIG (for Python bindings)
+
+#### Windows Dependencies
+
+**Required:**
+- MSVC (Visual Studio 2019 or later) OR MinGW-w64 (installed via WinGet)
+- Meson
+- Ninja
+- Python 3.8+
+- Windows SDK (for Visual Studio builds)
+
+**System Libraries (automatically linked):**
+- ws2_32.lib (Windows Sockets 2)
+- wsock32.lib (Windows Sockets)
+- kernel32.lib (Windows Kernel)
+- iphlpapi.lib (IP Helper API)
+
+**Optional:**
+- OpenSSL >= 3.0.0 (for security features)
+- Perl (for documentation generation scripts)
+
+**Note:** On Windows, Linux-specific dependencies (json-c, liburing, keyutils, libdbus) are automatically disabled.
+
+## Linux Environment Setup
+
+### Ubuntu/Debian
+
+```bash
+# Install core build tools
+sudo apt update
+sudo apt install -y build-essential meson ninja-build pkg-config
+
+# Install optional dependencies
+sudo apt install -y \
+    libjson-c-dev \
+    libssl-dev \
+    libkeyutils-dev \
+    libdbus-1-dev
+
+# For io_uring support (optional)
+sudo apt install -y liburing-dev
+
+# For documentation generation (optional)
+sudo apt install -y asciidoc xmlto
+
+# For Python bindings (optional)
+sudo apt install -y python3-dev swig
+```
+
+### Fedora/RHEL/CentOS
+
+```bash
+# Install core build tools
+sudo dnf install -y gcc meson ninja-build pkgconfig
+
+# Install optional dependencies
+sudo dnf install -y \
+    json-c-devel \
+    openssl-devel \
+    keyutils-libs-devel \
+    dbus-devel
+
+# For io_uring support (optional)
+sudo dnf install -y liburing-devel
+
+# For documentation generation (optional)
+sudo dnf install -y asciidoc xmlto
+
+# For Python bindings (optional)
+sudo dnf install -y python3-devel swig
+```
+
+### Arch Linux
+
+```bash
+# Install core build tools
+sudo pacman -S base-devel meson ninja pkg-config
+
+# Install optional dependencies
+sudo pacman -S json-c openssl keyutils dbus
+
+# For io_uring support (optional)
+sudo pacman -S liburing
+
+# For documentation generation (optional)
+sudo pacman -S asciidoc xmlto
+
+# For Python bindings (optional)
+sudo pacman -S python swig
+```
+
+## Windows Environment Setup
+
+### Using WinGet (Windows 10/11)
+
+WinGet provides the easiest way to set up the build environment on Windows:
+
+#### Installation
+
+```powershell
+# Install MinGW-w64 (GCC compiler toolchain)
+winget install BrechtSanders.WinLibs.POSIX.UCRT
+
+# Install Python (required for meson)
+winget install Python.Python.3.12
+
+# Install Perl (required for documentation generation scripts)
+winget install StrawberryPerl.StrawberryPerl
+
+# Install Meson build system (after Python is installed)
+pip install meson
+
+# Install OpenSSL (optional, for security features)
+winget install ShiningLight.OpenSSL
+```
+
+#### Setting Up PATH
+
+After installation, you need to add the tools to your PATH:
+
+**Temporary PATH setup (for current PowerShell session):**
+
+```powershell
+# Set PATH to include MinGW, Python, and Meson
+$env:PATH = "C:\Users\$env:USERNAME\AppData\Local\Microsoft\WinGet\Packages\BrechtSanders.WinLibs.POSIX.UCRT_Microsoft.Winget.Source_8wekyb3d8bbwe\mingw64\bin;C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312\Scripts;C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312;$env:PATH"
+```
+
+**Note:** The exact path for MinGW may vary depending on your WinGet installation. Use this command to locate it:
+```powershell
+Get-ChildItem -Path "$env:LOCALAPPDATA\Microsoft\WinGet\Packages" -Filter "BrechtSanders.WinLibs*" -Directory
+```
+
+**Permanent PATH setup:**
+
+To avoid setting PATH every time:
+
+1. Open System Properties:
+   - Press `Win + X` → System → Advanced system settings
+   - Or search for "Environment Variables" in Start Menu
+
+2. Click "Environment Variables"
+
+3. Under "User variables", select "Path" and click "Edit"
+
+4. Click "New" and add these paths (adjust the username and exact paths as needed):
+   - `C:\Users\YourUsername\AppData\Local\Microsoft\WinGet\Packages\BrechtSanders.WinLibs.POSIX.UCRT_Microsoft.Winget.Source_8wekyb3d8bbwe\mingw64\bin`
+   - `C:\Users\YourUsername\AppData\Local\Programs\Python\Python312`
+   - `C:\Users\YourUsername\AppData\Local\Programs\Python\Python312\Scripts`
+
+5. Click OK on all dialogs
+
+6. Restart PowerShell or any open terminals
+
+#### Verification
+
+Verify the installation by checking versions:
+
+```powershell
+gcc --version
+python --version
+meson --version
+ninja --version
+```
+
+Expected output should show:
+- GCC 15.x or later
+- Python 3.12.x or later
+- Meson 1.x or later
+- Ninja 1.x or later
+
+## Troubleshooting Environment Setup
+
+### Windows: Finding Installation Paths
+
+If you need to locate where WinGet installed tools:
+
+**Find Python:**
+```powershell
+Get-ChildItem -Path "$env:LOCALAPPDATA\Programs\Python" -Recurse -Filter "python.exe" -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty FullName
+```
+
+**Find Meson:**
+```powershell
+Get-ChildItem -Path "$env:LOCALAPPDATA" -Recurse -Filter "meson.exe" -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty FullName
+```
+
+**Find GCC (MinGW):**
+```powershell
+Get-ChildItem -Path "$env:LOCALAPPDATA" -Recurse -Filter "gcc.exe" -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty FullName
+```
+
+### Windows: Command Not Found Errors
+
+**"meson: command not found"**
+
+Solution: Add Python Scripts directory to PATH:
+```powershell
+$env:PATH = "C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312\Scripts;$env:PATH"
+```
+
+**"gcc: command not found"**
+
+Solution: Add MinGW bin directory to PATH:
+```powershell
+$env:PATH = "C:\Users\$env:USERNAME\AppData\Local\Microsoft\WinGet\Packages\BrechtSanders.WinLibs.POSIX.UCRT_Microsoft.Winget.Source_8wekyb3d8bbwe\mingw64\bin;$env:PATH"
+```
+
+**"python: command not found"**
+
+Solution: Add Python to PATH:
+```powershell
+$env:PATH = "C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312;$env:PATH"
+```
+
+### Linux: Missing Dependencies
+
+**json-c not found:**
+```bash
+# Ubuntu/Debian
+sudo apt install libjson-c-dev
+
+# Fedora/RHEL
+sudo dnf install json-c-devel
+
+# Arch
+sudo pacman -S json-c
+```
+
+**OpenSSL not found:**
+```bash
+# Ubuntu/Debian
+sudo apt install libssl-dev
+
+# Fedora/RHEL
+sudo dnf install openssl-devel
+
+# Arch
+sudo pacman -S openssl
+```
+
+**Meson too old:**
+```bash
+# Install newer version via pip
+pip3 install --user meson
+
+# Add to PATH if needed
+export PATH="$HOME/.local/bin:$PATH"
+```
+
+### Verifying Your Environment
+
+After setup, verify all required tools are available:
+
+**Linux:**
+```bash
+gcc --version
+meson --version
+ninja --version
+pkg-config --version
+```
+
+**Windows:**
+```powershell
+gcc --version
+python --version
+meson --version
+ninja --version
+```
+
+If any command fails, review the PATH setup instructions above.
+
+## Next Steps
+
+Once your environment is set up, proceed to [BUILD.md](BUILD.md) for instructions on configuring and building nvme-cli and libnvme.
diff --git a/ccan/ccan/minmax/minmax.h b/ccan/ccan/minmax/minmax.h
index f6abd796f5..33c96eaffd 100644
--- a/ccan/ccan/minmax/minmax.h
+++ b/ccan/ccan/minmax/minmax.h
@@ -21,6 +21,10 @@
 	do { } while (0)
 #endif
 
+/* Undefine any existing min/max macros. */
+#undef min
+#undef max
+
 #define min(a, b) \
 	({ \
 		typeof(a) _a = (a); \
diff --git a/libnvme/examples/meson.build b/libnvme/examples/meson.build
index 5d3e5fb237..0d6ba683a1 100644
--- a/libnvme/examples/meson.build
+++ b/libnvme/examples/meson.build
@@ -5,6 +5,10 @@
 #
 # Authors: Martin Belanger <Martin.Belanger@dell.com>
 #
+
+# Skip examples on Windows for now due to missing err.h and other incompatibilities
+if not is_windows
+
 executable(
     'telemetry-listen',
     ['telemetry-listen.c'],
@@ -88,3 +92,5 @@ if libdbus_dep.found()
         ],
     )
 endif
+
+endif # Windows exclusion
diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index 2ea2e62012..f098e19ca9 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -8,19 +8,31 @@
 sources = [
     'nvme/base64.c',
     'nvme/crc32.c',
-    'nvme/fabrics.c',
-    'nvme/filters.c',
     'nvme/ioctl.c',
-    'nvme/linux.c',
     'nvme/log.c',
-    'nvme/mi-mctp.c',
-    'nvme/mi.c',
     'nvme/nbft.c',
-    'nvme/sysfs.c',
-    'nvme/tree.c',
     'nvme/util.c',
 ]
 
+# Platform-specific sources
+if is_windows
+    # Windows-specific sources (exclude Linux networking, fabrics, and filesystem code)
+    sources += [
+        'nvme/windows-stubs.c',  # Stubs for excluded functions
+    ]
+else
+    # Linux-specific sources (include networking and fabrics support)
+    sources += [
+        'nvme/fabrics.c',
+        'nvme/filters.c',
+        'nvme/linux.c',
+        'nvme/mi-mctp.c',
+        'nvme/mi.c',
+        'nvme/tree.c',
+        'nvme/sysfs.c',
+    ]
+endif
+
 if json_c_dep.found()
     sources += 'nvme/json.c'
 else
@@ -38,19 +50,41 @@ deps = [
     libdbus_dep,
     liburing_dep,
     openssl_dep,
-    accessors_dep,
 ]
 
+# Skipping accessor generation for now on Windows. Needs to be ported.
+if not is_windows
+    deps += [
+        accessors_dep,
+    ]
+endif
+
+# Add Windows-specific networking libraries
+if is_windows
+    deps += [
+        cc.find_library('ws2_32'),
+        cc.find_library('wsock32'),
+        cc.find_library('iphlpapi'),
+    ]
+endif
+
 mapfile = 'libnvme.map'
 
+libnvme_link_args = [
+    '-Wl,--version-script=@0@'.format(meson.current_source_dir() / mapfile),
+]
+# Skipping accessor generation for now on Windows. Needs to be ported.
+if not is_windows
+    libnvme_link_args += [
+        '-Wl,--version-script=@0@'.format(accessors_ld_full_path),
+    ]
+endif
+
 libnvme = library(
     'nvme', # produces libnvme.so
     sources,
     version: libnvme_so_version,
-    link_args: [
-        '-Wl,--version-script=@0@'.format(meson.current_source_dir() / mapfile),
-        '-Wl,--version-script=@0@'.format(accessors_ld_full_path),
-    ],
+    link_args: libnvme_link_args,
     dependencies: deps,
     install: true,
 )
@@ -110,3 +144,13 @@ install_headers(
     subdir: 'nvme',
     install_mode: mode,
 )
+
+# Install platform abstraction headers
+install_headers([
+        'nvme/platform/platform_includes.h',
+        'nvme/platform/platform_linux.h',
+        'nvme/platform/platform_windows.h',
+    ],
+    subdir: 'nvme/platform',
+    install_mode: mode,
+)
diff --git a/libnvme/src/nvme/cleanup.h b/libnvme/src/nvme/cleanup.h
index 2a1e3db00e..0d3e6ab6f6 100644
--- a/libnvme/src/nvme/cleanup.h
+++ b/libnvme/src/nvme/cleanup.h
@@ -5,10 +5,8 @@
 #include <dirent.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
+
+#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
 
 #include "fabrics.h"
 
diff --git a/libnvme/src/nvme/fabrics.c b/libnvme/src/nvme/fabrics.c
index 89cdbed9bc..2ae3eaa040 100644
--- a/libnvme/src/nvme/fabrics.c
+++ b/libnvme/src/nvme/fabrics.c
@@ -21,12 +21,7 @@
 #include <dirent.h>
 #include <inttypes.h>
 
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <net/if.h>
+#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
 
 #include <ccan/endian/endian.h>
 #include <ccan/list/list.h>
diff --git a/libnvme/src/nvme/ioctl.c b/libnvme/src/nvme/ioctl.c
index ea21520f65..2242b07d05 100644
--- a/libnvme/src/nvme/ioctl.c
+++ b/libnvme/src/nvme/ioctl.c
@@ -15,13 +15,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 #include <inttypes.h>
 
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-
 #include <ccan/build_assert/build_assert.h>
 #include <ccan/minmax/minmax.h>
 #include <ccan/endian/endian.h>
diff --git a/libnvme/src/nvme/ioctl.h b/libnvme/src/nvme/ioctl.h
index 9f27307584..d47e58c2e2 100644
--- a/libnvme/src/nvme/ioctl.h
+++ b/libnvme/src/nvme/ioctl.h
@@ -11,11 +11,10 @@
 #define _LIBNVME_IOCTL_H
 
 #include <string.h>
-#include <endian.h>
+#include "platform/platform_includes.h"  /* Platform abstraction - includes endian.h and ioctl.h */
 #include <errno.h>
 #include <stddef.h>
 #include <string.h>
-#include <sys/ioctl.h>
 
 #include <nvme/types.h>
 
diff --git a/libnvme/src/nvme/linux.c b/libnvme/src/nvme/linux.c
index 4f56e16b48..ee43cc5f1e 100644
--- a/libnvme/src/nvme/linux.c
+++ b/libnvme/src/nvme/linux.c
@@ -12,10 +12,7 @@
 #include <string.h>
 #include <errno.h>
 
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
+#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
 
 #ifdef CONFIG_OPENSSL
 #include <openssl/evp.h>
diff --git a/libnvme/src/nvme/log.c b/libnvme/src/nvme/log.c
index 3cec7c2727..95d0e99aa3 100644
--- a/libnvme/src/nvme/log.c
+++ b/libnvme/src/nvme/log.c
@@ -13,8 +13,7 @@
 #include <stdlib.h>
 #include <stdarg.h>
 #include <stdbool.h>
-#include <syslog.h>
-#include <unistd.h>
+#include "platform/platform_includes.h"  /* Platform abstraction - includes syslog */
 #include <time.h>
 #include <string.h>
 #define LOG_FUNCNAME 1
diff --git a/libnvme/src/nvme/log.h b/libnvme/src/nvme/log.h
index 7f3b8c11fb..5bd4bad4ad 100644
--- a/libnvme/src/nvme/log.h
+++ b/libnvme/src/nvme/log.h
@@ -6,7 +6,7 @@
 #define _LOG_H
 
 #include <stdbool.h>
-#include <syslog.h>
+#include "platform/platform_includes.h"  /* Platform abstraction - includes syslog */
 
 /* for nvme_root_t */
 #include <nvme/tree.h>
diff --git a/libnvme/src/nvme/meson.build b/libnvme/src/nvme/meson.build
index bc511e1175..66922c3b54 100644
--- a/libnvme/src/nvme/meson.build
+++ b/libnvme/src/nvme/meson.build
@@ -7,6 +7,9 @@
 #
 # Run generate-accessors to generate the setter/getter functions.
 
+# Skip for now on Windows.  Accessor generation needs to be ported.
+if not is_windows
+
 generated_h = 'accessors.h'
 generated_c = 'accessors.c'
 generated_ld = 'accessors.ld'
@@ -70,3 +73,5 @@ if meson.version().version_compare('>=1.4.0')
 else
     accessors_ld_full_path = meson.current_build_dir() / generated_ld
 endif
+
+endif
\ No newline at end of file
diff --git a/libnvme/src/nvme/mi-mctp.c b/libnvme/src/nvme/mi-mctp.c
index 492b924cf9..c3c51cef5b 100644
--- a/libnvme/src/nvme/mi-mctp.c
+++ b/libnvme/src/nvme/mi-mctp.c
@@ -10,13 +10,8 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
-
-#include <poll.h>
+#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
 #include <fcntl.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/uio.h>
 
 #if HAVE_LINUX_MCTP_H
 #include <linux/mctp.h>
diff --git a/libnvme/src/nvme/mi.h b/libnvme/src/nvme/mi.h
index 732f471bed..919ef3fb64 100644
--- a/libnvme/src/nvme/mi.h
+++ b/libnvme/src/nvme/mi.h
@@ -84,7 +84,7 @@
 #ifndef _LIBNVME_MI_MI_H
 #define _LIBNVME_MI_MI_H
 
-#include <endian.h>
+#include "platform/platform_includes.h"  /* Platform abstraction */
 #include <stdint.h>
 
 #include <nvme/types.h>
diff --git a/libnvme/src/nvme/nbft.c b/libnvme/src/nvme/nbft.c
index fd94a450eb..b5de827b3c 100644
--- a/libnvme/src/nvme/nbft.c
+++ b/libnvme/src/nvme/nbft.c
@@ -11,16 +11,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include <arpa/inet.h>
+#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
 #include <ccan/endian/endian.h>
 
 #include "private.h"
 #include "nbft.h"
 #include "log.h"
 
-
-#define MIN(a, b) (((a) < (b)) ? (a) : (b))
-
 static __u8 csum(const __u8 *buffer, ssize_t length)
 {
 	int n;
@@ -38,7 +35,7 @@ static void format_ip_addr(char *buf, size_t buflen, __u8 *addr)
 	memcpy(&addr_ipv6, addr, sizeof(addr_ipv6));
 	if (IN6_IS_ADDR_V4MAPPED(&addr_ipv6))
 		/* ipv4 */
-		inet_ntop(AF_INET, &addr_ipv6.s6_addr32[3], buf, buflen);
+		inet_ntop(AF_INET, ipv4_from_in6_addr(addr_ipv6), buf, buflen);
 	else
 		/* ipv6 */
 		inet_ntop(AF_INET6, &addr_ipv6, buf, buflen);
@@ -100,13 +97,13 @@ static int __get_heap_obj(struct nbft_header *header, const char *filename,
 	*output = (char *)header + le32_to_cpu(obj.offset);
 
 	if (is_string) {
-		if (strnlen(*output, le16_to_cpu(obj.length) + 1) < le16_to_cpu(obj.length))
+		if (strnlen(*output, le16_to_cpu(obj.length) + 1) < le16_to_cpu(obj.length)) {
 			nvme_msg(NULL, LOG_DEBUG,
-				"file %s: string '%s' in descriptor '%s' is shorter (%zd) than specified length (%d)\n",
+				"file %s: string '%s' in descriptor '%s' is shorter (%u) than specified length (%u)\n",
 				filename, fieldname, descriptorname,
-				strnlen(*output, le16_to_cpu(obj.length) + 1),
-					le16_to_cpu(obj.length));
-		else if (strnlen(*output, le16_to_cpu(obj.length) + 1) >
+				(unsigned int)strnlen(*output, le16_to_cpu(obj.length) + 1),
+				le16_to_cpu(obj.length));
+		} else if (strnlen(*output, le16_to_cpu(obj.length) + 1) >
 			le16_to_cpu(obj.length)) {
 			nvme_msg(NULL, LOG_DEBUG,
 				 "file %s: string '%s' in descriptor '%s' is not zero terminated\n",
diff --git a/libnvme/src/nvme/platform/platform_includes.h b/libnvme/src/nvme/platform/platform_includes.h
new file mode 100644
index 0000000000..dbf1ac3288
--- /dev/null
+++ b/libnvme/src/nvme/platform/platform_includes.h
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2025 Micron Technology, Inc.
+ *
+ * Main platform abstraction entry point.
+ * Replaces the scattered #ifdef WIN32 conditionals throughout the codebase.
+ */
+
+#ifndef _LIBNVME_PLATFORM_INCLUDES_H
+#define _LIBNVME_PLATFORM_INCLUDES_H
+
+/* Standard includes needed everywhere */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+/* Platform-specific includes */
+#ifdef _WIN32
+    #include "platform_windows.h"
+#else
+    #include "platform_linux.h"
+#endif
+
+#endif /* _LIBNVME_PLATFORM_INCLUDES_H */
\ No newline at end of file
diff --git a/libnvme/src/nvme/platform/platform_linux.h b/libnvme/src/nvme/platform/platform_linux.h
new file mode 100644
index 0000000000..b96e58761b
--- /dev/null
+++ b/libnvme/src/nvme/platform/platform_linux.h
@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2025 Micron Technology, Inc.
+ *
+ * Linux platform-specific definitions and includes.
+ * Complete replacement for Linux portions of legacy platform.h
+ */
+
+#ifndef _LIBNVME_PLATFORM_LINUX_H
+#define _LIBNVME_PLATFORM_LINUX_H
+
+/* Linux standard includes */
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/uio.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <ifaddrs.h>
+#include <poll.h>
+#include <syslog.h>
+
+/* Linux-specific includes */
+#include <linux/types.h>
+#include <endian.h>
+#include <net/if.h>
+
+/* Linux cleanup attribute */
+#define __nvme_cleanup(fn) __attribute__((__cleanup__(fn)))
+
+/* Extract IPv4 from IPv6 mapped address */
+#define ipv4_from_in6_addr(addr) &(addr.s6_addr32[3])
+
+#endif /* _LIBNVME_PLATFORM_LINUX_H */
\ No newline at end of file
diff --git a/libnvme/src/nvme/platform/platform_windows.h b/libnvme/src/nvme/platform/platform_windows.h
new file mode 100644
index 0000000000..067899f466
--- /dev/null
+++ b/libnvme/src/nvme/platform/platform_windows.h
@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2025 Micron Technology, Inc.
+ *
+ * Windows platform-specific definitions and includes.
+ * Complete replacement for Windows portions of legacy platform.h
+ */
+
+#ifndef _LIBNVME_PLATFORM_WINDOWS_H
+#define _LIBNVME_PLATFORM_WINDOWS_H
+
+/* Windows-specific includes - winsock2 before windows.h to avoid warnings */
+#define WIN32_LEAN_AND_MEAN
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+#include <winioctl.h>
+#include <ntddstor.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <io.h>
+#include <direct.h>
+#include <process.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <time.h>
+
+/* Prevent conflicts with Windows min/max macros */
+#ifdef min
+#undef min
+#endif
+#ifdef max  
+#undef max
+#endif
+
+/* Windows type definitions to replace linux/types.h */
+typedef uint8_t  __u8;
+typedef uint16_t __u16;
+typedef uint32_t __u32;
+typedef uint64_t __u64;
+typedef int8_t   __s8;
+typedef int16_t  __s16;
+typedef int32_t  __s32;
+typedef int64_t  __s64;
+
+/* Little-endian types (Windows is little-endian) */
+typedef __u16    __le16;
+typedef __u32    __le32;
+typedef __u64    __le64;
+typedef __s16    __le16s;
+typedef __s32    __le32s;
+typedef __s64    __le64s;
+
+/* Big-endian types for completeness */
+typedef __u16    __be16;
+typedef __u32    __be32;
+typedef __u64    __be64;
+typedef __s16    __be16s;
+typedef __s32    __be32s;
+typedef __s64    __be64s;
+
+/* Windows cleanup - no-op since Windows doesn't have cleanup attribute */
+#define __nvme_cleanup(fn) /* No cleanup attribute on Windows */
+
+/* Windows endian conversion macros */
+#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    #define htole16(x) __builtin_bswap16(x)
+    #define htole32(x) __builtin_bswap32(x)
+    #define htole64(x) __builtin_bswap64(x)
+    #define le16toh(x) __builtin_bswap16(x)
+    #define le32toh(x) __builtin_bswap32(x)
+    #define le64toh(x) __builtin_bswap64(x)
+#else
+    /* Little-endian (most common case for Windows) */
+    #define htole16(x) (x)
+    #define htole32(x) (x)
+    #define htole64(x) (x)
+    #define le16toh(x) (x)
+    #define le32toh(x) (x)
+    #define le64toh(x) (x)
+#endif
+
+/* syslog.h stubs */
+#define LOG_EMERG   0
+#define LOG_ALERT   1  
+#define LOG_CRIT    2
+#define LOG_ERR     3
+#define LOG_WARNING 4
+#define LOG_NOTICE  5
+#define LOG_INFO    6
+#define LOG_DEBUG   7
+static inline void syslog(int priority, const char *format, ...) { (void)priority; (void)format; }
+static inline void openlog(const char *ident, int option, int facility) { (void)ident; (void)option; (void)facility; }
+static inline void closelog(void) { }
+
+/* poll.h stubs - winsock2.h provides struct pollfd */
+#ifndef POLLIN
+#define POLLIN  0x001
+#endif
+#ifndef POLLOUT
+#define POLLOUT 0x004
+#endif
+#ifndef POLLERR
+#define POLLERR 0x008
+#endif
+#ifndef POLLHUP
+#define POLLHUP 0x010
+#endif
+#ifndef POLLNVAL
+#define POLLNVAL 0x020
+#endif
+
+/* sys/ioctl.h stubs */
+#define IOCTL_STORAGE_QUERY_PROPERTY CTL_CODE(IOCTL_STORAGE_BASE, 0x0500, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+/* Windows ioctl stub functions */
+static inline int ioctl(int fd, unsigned long request, ...) {
+    (void)fd; (void)request;
+    errno = ENOSYS;
+    return -1;
+}
+
+/* Windows file descriptors */
+#ifndef STDERR_FILENO
+#define STDERR_FILENO 2
+#endif
+#ifndef STDOUT_FILENO  
+#define STDOUT_FILENO 1
+#endif
+#ifndef STDIN_FILENO
+#define STDIN_FILENO 0
+#endif
+
+/* Windows sys/param.h compatibility */
+#ifndef MAXPATHLEN
+#define MAXPATHLEN 260  /* Windows MAX_PATH */
+#endif
+
+/* Windows missing error codes */
+#ifndef EREMOTEIO
+#define EREMOTEIO 121
+#endif
+#ifndef EDQUOT
+#define EDQUOT 122
+#endif
+#ifndef ERESTART
+#define ERESTART 85
+#endif
+#ifndef ENOTBLK
+#define ENOTBLK 15
+#endif
+
+/* Windows missing socket types */
+typedef unsigned long nfds_t;
+
+/* Windows missing socket structures */
+struct msghdr {
+    void *msg_name;
+    socklen_t msg_namelen;
+    struct iovec *msg_iov;
+    size_t msg_iovlen;
+    void *msg_control;
+    size_t msg_controllen;
+    int msg_flags;
+};
+
+struct iovec {
+    void *iov_base;
+    size_t iov_len;
+};
+
+/* Windows missing network structures */
+struct ifaddrs {
+    struct ifaddrs *ifa_next;
+    char *ifa_name;
+    unsigned int ifa_flags;
+    struct sockaddr *ifa_addr;
+    struct sockaddr *ifa_netmask;
+    struct sockaddr *ifa_broadaddr;
+    void *ifa_data;
+};
+
+/* Extract IPv4 from IPv6 mapped address */
+#define ipv4_from_in6_addr(addr) &(addr.u.Byte[12])
+
+/* Windows missing POSIX functions */
+static inline int dprintf(int fd, const char *format, ...) {
+    va_list args;
+    char buffer[4096];
+    int result;
+    va_start(args, format);
+    result = vsnprintf(buffer, sizeof(buffer), format, args);
+    va_end(args);
+    if (fd == STDERR_FILENO) {
+        fputs(buffer, stderr);
+    } else if (fd == STDOUT_FILENO) {
+        fputs(buffer, stdout);
+    }
+    return result;
+}
+
+static inline int getpagesize(void) {
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    return si.dwPageSize;
+}
+
+static inline int posix_memalign(void **memptr, size_t alignment, size_t size) {
+    *memptr = _aligned_malloc(size, alignment);
+    return (*memptr == NULL) ? ENOMEM : 0;
+}
+
+static inline size_t malloc_usable_size(void *ptr) {
+    return _msize(ptr);
+}
+
+/* Windows ioctl macros - only define if not already defined by winsock */
+#ifndef _IOC_NONE
+#define _IOC_NONE  0U
+#define _IOC_WRITE 1U
+#define _IOC_READ  2U
+
+#define _IOC(dir,type,nr,size) \
+    (((dir)  << 30) | \
+     ((type) << 8) | \
+     ((nr)   << 0) | \
+     ((size) << 16))
+
+/* Only define if winsock2.h hasn't already defined them */
+#ifndef _IO
+#define _IO(type,nr)        _IOC(_IOC_NONE,(type),(nr),0)
+#endif
+#ifndef _IOR  
+#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),sizeof(size))
+#endif
+#ifndef _IOW
+#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
+#endif
+#ifndef _IOWR
+#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
+#endif
+#endif /* _IOC_NONE */
+
+/* MIN/min macros for Windows */
+#ifndef MIN
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+#endif
+#ifndef min
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+#endif /* _LIBNVME_PLATFORM_WINDOWS_H */
\ No newline at end of file
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index 6b2a864805..2897016a9b 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -10,9 +10,7 @@
 #define _LIBNVME_PRIVATE_H
 
 #include <ccan/list/list.h>
-#include <poll.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
+#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
 
 #include <nvme/fabrics.h>
 #include <nvme/mi.h>
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index 2fdde49ee2..b1345ad9e4 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -14,13 +14,8 @@
 #include <string.h>
 #include <fcntl.h>
 #include <libgen.h>
-#include <unistd.h>
-#include <ifaddrs.h>
 
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <arpa/inet.h>
-#include <netdb.h>
+#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
 
 #include <ccan/endian/endian.h>
 #include <ccan/list/list.h>
diff --git a/libnvme/src/nvme/tree.h b/libnvme/src/nvme/tree.h
index 541f1c5601..7b90b22d6d 100644
--- a/libnvme/src/nvme/tree.h
+++ b/libnvme/src/nvme/tree.h
@@ -13,11 +13,11 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-#include <sys/types.h>
-#include <netinet/in.h>
+#include "platform/platform_includes.h"  /* Platform abstraction */
 
 #include <nvme/ioctl.h>
 #include <nvme/util.h>
+#include <nvme/types.h>
 
 /**
  * DOC: tree.h
diff --git a/libnvme/src/nvme/types.h b/libnvme/src/nvme/types.h
index 311bf78b23..11bc07f796 100644
--- a/libnvme/src/nvme/types.h
+++ b/libnvme/src/nvme/types.h
@@ -14,7 +14,7 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include <linux/types.h>
+#include "platform/platform_includes.h"  /* Platform abstraction - includes type definitions */
 
 struct nvme_global_ctx;
 struct nvme_transport_handle;
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 3e67020431..6bb68d79d0 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -16,11 +16,7 @@
 
 #include <sys/stat.h>
 #include <fcntl.h>
-#include <sys/param.h>
-#include <sys/types.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <unistd.h>
+#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
 
 #include <ccan/minmax/minmax.h>
 #include <ccan/endian/endian.h>
diff --git a/libnvme/src/nvme/util.h b/libnvme/src/nvme/util.h
index d0f6033db9..93a48c17d1 100644
--- a/libnvme/src/nvme/util.h
+++ b/libnvme/src/nvme/util.h
@@ -9,7 +9,7 @@
 #ifndef _LIBNVME_UTIL_H
 #define _LIBNVME_UTIL_H
 
-#include <ifaddrs.h>
+#include "platform/platform_includes.h"  /* Platform abstraction */
 
 #include <nvme/types.h>
 
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
new file mode 100644
index 0000000000..e28825a836
--- /dev/null
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -0,0 +1,1075 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2025 Micron Technology, Inc.
+ *
+ * Windows stub implementations for Linux-specific functionality
+ * that is excluded from the Windows build (fabrics, MI, tree, filters, etc.)
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <nvme/types.h>
+
+/* Forward declarations for Linux-specific structures */
+struct nvme_host;
+struct nvme_subsystem;
+struct nvme_ctrl;
+struct nvme_path;
+struct nvme_ns;
+
+/* Logging control for stub calls */
+static int stub_log_enabled = 0;
+
+static void stub_log(const char *func)
+{
+	if (stub_log_enabled)
+		fprintf(stderr, "libnvme-stub: %s() called (not supported on Windows)\n", func);
+}
+
+void nvme_stubs_set_debug(int enable)
+{
+	stub_log_enabled = enable;
+}
+
+/*
+ * Stub implementations for fabrics functions (fabrics.c)
+ * These are not supported on Windows
+ */
+
+/* Fabrics configuration stubs - just return errors */
+void nvmf_default_config(void *cfg)
+{
+	stub_log(__func__);
+	(void)cfg;
+}
+
+void nvmf_update_config(void *c, const void *cfg)
+{
+	stub_log(__func__);
+	(void)c;
+	(void)cfg;
+}
+
+int nvmf_add_ctrl(void *h, void *c, const void *cfg)
+{
+	stub_log(__func__);
+	(void)h;
+	(void)c;
+	(void)cfg;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvmf_connect_ctrl(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvmf_get_discovery_log(void *c, void **logp, int max_retries)
+{
+	stub_log(__func__);
+	(void)c;
+	(void)logp;
+	(void)max_retries;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvmf_get_discovery_wargs(void *args, void **logp)
+{
+	stub_log(__func__);
+	(void)args;
+	(void)logp;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvmf_connect_disc_entry(void *h, void *e, const void *defcfg, int *discover, void **c)
+{
+	stub_log(__func__);
+	(void)h;
+	(void)e;
+	(void)defcfg;
+	(void)discover;
+	(void)c;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvmf_is_registration_supported(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return 0; /* Not supported */
+}
+
+int nvmf_register_ctrl(void *c, int tas, __u32 *result)
+{
+	stub_log(__func__);
+	(void)c;
+	(void)tas;
+	(void)result;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_parse_uri(const char *str, void **uri)
+{
+	stub_log(__func__);
+	(void)str;
+	(void)uri;
+	errno = ENOTSUP;
+	return -1;
+}
+
+void nvme_free_uri(void *uri)
+{
+	stub_log(__func__);
+	(void)uri;
+}
+
+/*
+ * Stub implementations for tree functions (tree.c)
+ * Minimal support - just return NULL/errors
+ */
+
+void nvme_release_fds(void *r)
+{
+	stub_log(__func__);
+	(void)r;
+}
+
+void *nvme_create_root(const char *config_file, int log_level)
+{
+	stub_log(__func__);
+	(void)config_file;
+	(void)log_level;
+	/* Return NULL - tree operations not supported on Windows */
+	return NULL;
+}
+
+void nvme_free_tree(void *r)
+{
+	stub_log(__func__);
+	(void)r;
+}
+
+void nvme_free_global_ctx(struct nvme_global_ctx *ctx)
+{
+	stub_log(__func__);
+	(void)ctx;
+}
+
+const char *nvme_root_get_application(void *r)
+{
+	stub_log(__func__);
+	(void)r;
+	return "";
+}
+
+void nvme_root_set_application(void *r, const char *a)
+{
+	stub_log(__func__);
+	(void)r;
+	(void)a;
+}
+
+void *nvme_scan(const char *config_file, int log_level)
+{
+	stub_log(__func__);
+	(void)config_file;
+	(void)log_level;
+	/* Scanning not supported on Windows */
+	return NULL;
+}
+
+struct nvme_global_ctx *nvme_create_global_ctx(FILE *fp, int log_level)
+{
+	stub_log(__func__);
+	(void)fp;
+	(void)log_level;
+	/* Return NULL - global context not supported on Windows */
+	return NULL;
+}
+
+void *nvme_scan_ctrl(void *ctx, const char *name)
+{
+	stub_log(__func__);
+	(void)ctx;
+	(void)name;
+	return NULL;
+}
+
+int nvme_scan_topology(void *r, void *f, void *f_args)
+{
+	stub_log(__func__);
+	(void)r;
+	(void)f;
+	(void)f_args;
+	errno = ENOTSUP;
+	return -1;
+}
+
+void *nvme_first_host(void *r)
+{
+	stub_log(__func__);
+	(void)r;
+	return NULL;
+}
+
+void *nvme_next_host(void *r, void *h)
+{
+	stub_log(__func__);
+	(void)r;
+	(void)h;
+	return NULL;
+}
+
+void *nvme_lookup_host(void *r, const char *hostnqn, const char *hostid)
+{
+	stub_log(__func__);
+	(void)r;
+	(void)hostnqn;
+	(void)hostid;
+	return NULL;
+}
+
+void *nvme_default_host(void *r)
+{
+	stub_log(__func__);
+	(void)r;
+	return NULL;
+}
+
+void *nvme_first_subsystem(void *h)
+{
+	stub_log(__func__);
+	(void)h;
+	return NULL;
+}
+
+void *nvme_next_subsystem(void *h, void *s)
+{
+	stub_log(__func__);
+	(void)h;
+	(void)s;
+	return NULL;
+}
+
+void *nvme_lookup_subsystem(struct nvme_host *h, const char *name, const char *subsysnqn)
+{
+	stub_log(__func__);
+	(void)h;
+	(void)name;
+	(void)subsysnqn;
+	return NULL;
+}
+
+void *nvme_first_ctrl(void *s)
+{
+	stub_log(__func__);
+	(void)s;
+	return NULL;
+}
+
+void *nvme_next_ctrl(void *s, void *c)
+{
+	stub_log(__func__);
+	(void)s;
+	(void)c;
+	return NULL;
+}
+
+void *nvme_lookup_ctrl(void *s, const char *transport, const char *traddr,
+		       const char *trsvcid, const char *subsysnqn,
+		       const char *host_traddr, const char *host_iface)
+{
+	stub_log(__func__);
+	(void)s;
+	(void)transport;
+	(void)traddr;
+	(void)trsvcid;
+	(void)subsysnqn;
+	(void)host_traddr;
+	(void)host_iface;
+	return NULL;
+}
+
+void *nvme_ctrl_first_ns(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return NULL;
+}
+
+void *nvme_ctrl_next_ns(void *c, void *ns)
+{
+	stub_log(__func__);
+	(void)c;
+	(void)ns;
+	return NULL;
+}
+
+void *nvme_ctrl_first_path(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return NULL;
+}
+
+void *nvme_ctrl_next_path(void *c, void *p)
+{
+	stub_log(__func__);
+	(void)c;
+	(void)p;
+	return NULL;
+}
+
+void *nvme_subsys_first_ns(void *s)
+{
+	stub_log(__func__);
+	(void)s;
+	return NULL;
+}
+
+void *nvme_subsys_next_ns(void *s, void *ns)
+{
+	stub_log(__func__);
+	(void)s;
+	(void)ns;
+	return NULL;
+}
+
+void *nvme_ns_get_subsystem(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return NULL;
+}
+
+void *nvme_ns_get_ctrl(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return NULL;
+}
+
+int nvme_ns_get_fd(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return -1;
+}
+
+int nvme_ns_get_nsid(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return 0;
+}
+
+int nvme_ns_get_csi(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return 0;
+}
+
+const unsigned char *nvme_ns_get_eui64(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return NULL;
+}
+
+const unsigned char *nvme_ns_get_nguid(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return NULL;
+}
+
+const unsigned char *nvme_ns_get_uuid(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return NULL;
+}
+
+void *nvme_ns_get_transport_handle(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return NULL;
+}
+
+int nvme_ns_identify(void *ns, void *ns_id)
+{
+	stub_log(__func__);
+	(void)ns;
+	(void)ns_id;
+	errno = ENOTSUP;
+	return -1;
+}
+
+const char *nvme_ns_get_sysfs_dir(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return "";
+}
+
+const char *nvme_ns_get_name(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return "";
+}
+
+const char *nvme_ns_get_generic_name(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return "";
+}
+
+int nvme_ns_get_lba_size(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return 0;
+}
+
+unsigned long long nvme_ns_get_lba_count(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return 0;
+}
+
+unsigned long long nvme_ns_get_lba_util(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return 0;
+}
+
+const char *nvme_path_get_name(void *p)
+{
+	stub_log(__func__);
+	(void)p;
+	return "";
+}
+
+const char *nvme_path_get_sysfs_dir(void *p)
+{
+	stub_log(__func__);
+	(void)p;
+	return "";
+}
+
+const char *nvme_path_get_ana_state(void *p)
+{
+	stub_log(__func__);
+	(void)p;
+	return "";
+}
+
+void *nvme_path_get_ctrl(void *p)
+{
+	stub_log(__func__);
+	(void)p;
+	return NULL;
+}
+
+void *nvme_path_get_ns(void *p)
+{
+	stub_log(__func__);
+	(void)p;
+	return NULL;
+}
+
+const char *nvme_ctrl_get_name(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return "";
+}
+
+const char *nvme_ctrl_get_sysfs_dir(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return "";
+}
+
+const char *nvme_ctrl_get_address(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return "";
+}
+
+const char *nvme_ctrl_get_transport(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return "";
+}
+
+const char *nvme_ctrl_get_state(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return "";
+}
+
+void *nvme_ctrl_get_config(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return NULL;
+}
+
+int nvme_ctrl_get_fd(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return -1;
+}
+
+void *nvme_ctrl_get_subsystem(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return NULL;
+}
+
+void *nvme_ctrl_get_transport_handle(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return NULL;
+}
+
+void nvme_free_ctrl(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+}
+
+int nvme_disconnect_ctrl(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	errno = ENOTSUP;
+	return -1;
+}
+
+void nvme_unlink_ctrl(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+}
+
+const char *nvme_subsys_get_name(void *s)
+{
+	stub_log(__func__);
+	(void)s;
+	return "";
+}
+
+const char *nvme_subsys_get_nqn(void *s)
+{
+	stub_log(__func__);
+	(void)s;
+	return "";
+}
+
+const char *nvme_subsys_get_sysfs_dir(void *s)
+{
+	stub_log(__func__);
+	(void)s;
+	return "";
+}
+
+void *nvme_subsys_get_host(void *s)
+{
+	stub_log(__func__);
+	(void)s;
+	return NULL;
+}
+
+/* Subsystem functions (full name) - same as subsys */
+const char *nvme_subsystem_get_name(void *s)
+{
+	return nvme_subsys_get_name(s);
+}
+
+const char *nvme_subsystem_get_nqn(void *s)
+{
+	return nvme_subsys_get_nqn(s);
+}
+
+const char *nvme_subsystem_get_sysfs_dir(void *s)
+{
+	return nvme_subsys_get_sysfs_dir(s);
+}
+
+void *nvme_subsystem_get_host(void *s)
+{
+	return nvme_subsys_get_host(s);
+}
+
+void *nvme_subsystem_first_ctrl(void *s)
+{
+	return nvme_first_ctrl(s);
+}
+
+void *nvme_subsystem_next_ctrl(void *s, void *c)
+{
+	return nvme_next_ctrl(s, c);
+}
+
+void *nvme_subsystem_first_ns(void *s)
+{
+	return nvme_subsys_first_ns(s);
+}
+
+void *nvme_subsystem_next_ns(void *s, void *ns)
+{
+	return nvme_subsys_next_ns(s, ns);
+}
+
+const char *nvme_host_get_hostnqn(void *h)
+{
+	stub_log(__func__);
+	(void)h;
+	return "";
+}
+
+const char *nvme_host_get_hostid(void *h)
+{
+	stub_log(__func__);
+	(void)h;
+	return "";
+}
+
+void *nvme_host_get_root(void *h)
+{
+	stub_log(__func__);
+	(void)h;
+	return NULL;
+}
+
+int nvme_dump_tree(void *r)
+{
+	stub_log(__func__);
+	(void)r;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_dump_config(void *r)
+{
+	stub_log(__func__);
+	(void)r;
+	errno = ENOTSUP;
+	return -1;
+}
+
+/*
+ * Stub implementations for filter functions (filters.c)
+ */
+
+void *nvme_for_each_host_safe(void *r, void *h)
+{
+	stub_log(__func__);
+	(void)r;
+	(void)h;
+	return NULL;
+}
+
+void *nvme_for_each_subsystem_safe(void *h, void *s)
+{
+	stub_log(__func__);
+	(void)h;
+	(void)s;
+	return NULL;
+}
+
+void *nvme_for_each_ctrl_safe(void *s, void *c)
+{
+	stub_log(__func__);
+	(void)s;
+	(void)c;
+	return NULL;
+}
+
+void *nvme_for_each_ns_safe(void *s, void *ns)
+{
+	stub_log(__func__);
+	(void)s;
+	(void)ns;
+	return NULL;
+}
+
+void *nvme_for_each_path_safe(void *c, void *p)
+{
+	stub_log(__func__);
+	(void)c;
+	(void)p;
+	return NULL;
+}
+
+/*
+ * Stub implementations for MI functions (mi.c and mi-mctp.c)
+ */
+
+int nvme_mi_admin_admin_passthru(void *hdl, __u8 opcode, __u8 flags,
+				 __u16 rsvd, __u32 nsid, __u32 cdw2, __u32 cdw3,
+				 __u32 cdw10, __u32 cdw11, __u32 cdw12,
+				 __u32 cdw13, __u32 cdw14, __u32 cdw15,
+				 __u32 data_len, void *data, __u32 metadata_len,
+				 void *metadata, __u32 timeout_ms, __u32 *result)
+{
+	stub_log(__func__);
+	(void)hdl;
+	(void)opcode;
+	(void)flags;
+	(void)rsvd;
+	(void)nsid;
+	(void)cdw2;
+	(void)cdw3;
+	(void)cdw10;
+	(void)cdw11;
+	(void)cdw12;
+	(void)cdw13;
+	(void)cdw14;
+	(void)cdw15;
+	(void)data_len;
+	(void)data;
+	(void)metadata_len;
+	(void)metadata;
+	(void)timeout_ms;
+	(void)result;
+	errno = ENOTSUP;
+	return -1;
+}
+
+void *nvme_mi_create_root(void *fp, int log_level)
+{
+	stub_log(__func__);
+	(void)fp;
+	(void)log_level;
+	return NULL;
+}
+
+void nvme_mi_free_root(void *root)
+{
+	stub_log(__func__);
+	(void)root;
+}
+
+void *nvme_mi_first_endpoint(void *root)
+{
+	stub_log(__func__);
+	(void)root;
+	return NULL;
+}
+
+void *nvme_mi_next_endpoint(void *root, void *ep)
+{
+	stub_log(__func__);
+	(void)root;
+	(void)ep;
+	return NULL;
+}
+
+int nvme_mi_scan_ep(void *ep, int force_rescan)
+{
+	stub_log(__func__);
+	(void)ep;
+	(void)force_rescan;
+	errno = ENOTSUP;
+	return -1;
+}
+
+void *nvme_mi_first_ctrl(void *ep)
+{
+	stub_log(__func__);
+	(void)ep;
+	return NULL;
+}
+
+void *nvme_mi_next_ctrl(void *ep, void *c)
+{
+	stub_log(__func__);
+	(void)ep;
+	(void)c;
+	return NULL;
+}
+
+void nvme_mi_close(void *ep)
+{
+	stub_log(__func__);
+	(void)ep;
+}
+
+/*
+ * Stub for Linux-specific includes
+ */
+int nvme_linux_status_to_errno(int status)
+{
+	stub_log(__func__);
+	/* Simple passthrough - proper implementation would need status code mapping */
+	return status < 0 ? -status : status;
+}
+
+/*
+ * TLS/PSK key management stubs (linux.c functions)
+ */
+int nvme_export_tls_key_versioned(unsigned char version, unsigned char hmac,
+				  const unsigned char *key_data,
+				  size_t key_len, char **encoded_keyp)
+{
+	stub_log(__func__);
+	(void)version;
+	(void)hmac;
+	(void)key_data;
+	(void)key_len;
+	(void)encoded_keyp;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_export_tls_key(const unsigned char *key_data, int key_len, char **key)
+{
+	stub_log(__func__);
+	(void)key_data;
+	(void)key_len;
+	(void)key;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_import_tls_key_versioned(const char *encoded_key,
+				  unsigned char *version,
+				  unsigned char *hmac,
+				  size_t *key_len,
+				  unsigned char **keyp)
+{
+	stub_log(__func__);
+	(void)encoded_key;
+	(void)version;
+	(void)hmac;
+	(void)key_len;
+	(void)keyp;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_import_tls_key(const char *encoded_key, int *key_len,
+			unsigned char **keyp)
+{
+	stub_log(__func__);
+	(void)encoded_key;
+	(void)key_len;
+	(void)keyp;
+	errno = ENOTSUP;
+	return -1;
+}
+
+/*
+ * Additional stubs for nvme-cli linking
+ */
+
+/* Transport handle operations (linux.c) */
+int nvme_open(void *ctx, const char *name, void **hdlp)
+{
+	stub_log(__func__);
+	(void)ctx;
+	(void)name;
+	(void)hdlp;
+	errno = ENOTSUP;
+	return -1;
+}
+
+void nvme_close(void *hdl)
+{
+	stub_log(__func__);
+	(void)hdl;
+}
+
+int nvme_transport_handle_get_fd(void *hdl)
+{
+	stub_log(__func__);
+	(void)hdl;
+	return -1;
+}
+
+const char *nvme_transport_handle_get_name(void *hdl)
+{
+	stub_log(__func__);
+	(void)hdl;
+	return "";
+}
+
+int nvme_transport_handle_is_blkdev(void *hdl)
+{
+	stub_log(__func__);
+	(void)hdl;
+	return 0;
+}
+
+int nvme_transport_handle_is_chardev(void *hdl)
+{
+	stub_log(__func__);
+	(void)hdl;
+	return 0;
+}
+
+int nvme_transport_handle_is_direct(void *hdl)
+{
+	stub_log(__func__);
+	(void)hdl;
+	return 0;
+}
+
+/* Controller property getters (tree.c) */
+const char *nvme_ctrl_get_cntlid(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return "";
+}
+
+const char *nvme_ctrl_get_firmware(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return "";
+}
+
+const char *nvme_ctrl_get_model(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return "";
+}
+
+const char *nvme_ctrl_get_phy_slot(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return "";
+}
+
+const char *nvme_ctrl_get_serial(void *c)
+{
+	stub_log(__func__);
+	(void)c;
+	return "";
+}
+
+/* Subsystem property getters (tree.c) */
+const char *nvme_subsystem_get_fw_rev(void *s)
+{
+	stub_log(__func__);
+	(void)s;
+	return "";
+}
+
+const char *nvme_subsystem_get_iopolicy(void *s)
+{
+	stub_log(__func__);
+	(void)s;
+	return "";
+}
+
+const char *nvme_subsystem_get_model(void *s)
+{
+	stub_log(__func__);
+	(void)s;
+	return "";
+}
+
+const char *nvme_subsystem_get_serial(void *s)
+{
+	stub_log(__func__);
+	(void)s;
+	return "";
+}
+
+const char *nvme_subsystem_get_type(void *s)
+{
+	stub_log(__func__);
+	(void)s;
+	return "";
+}
+
+/* Namespace property getters (tree.c) */
+const char *nvme_ns_get_firmware(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return "";
+}
+
+int nvme_ns_get_meta_size(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return 0;
+}
+
+const char *nvme_ns_get_model(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return "";
+}
+
+const char *nvme_ns_get_serial(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return "";
+}
+
+/* Namespace path iteration (tree.c) */
+void *nvme_namespace_first_path(void *ns)
+{
+	stub_log(__func__);
+	(void)ns;
+	return NULL;
+}
+
+void *nvme_namespace_next_path(void *ns, void *p)
+{
+	stub_log(__func__);
+	(void)ns;
+	(void)p;
+	return NULL;
+}
+
+/* ANA log utilities (linux.c) */
+unsigned long nvme_get_ana_log_len_from_id_ctrl(const void *id_ctrl, int rgo)
+{
+	stub_log(__func__);
+	(void)id_ctrl;
+	(void)rgo;
+	return 0;
+}
+
+/* MI status string (mi.c) */
+const char *nvme_mi_status_to_string(int status)
+{
+	stub_log(__func__);
+	(void)status;
+	return "MI not supported on Windows";
+}
\ No newline at end of file
diff --git a/libnvme/test/ioctl/ana.c b/libnvme/test/ioctl/ana.c
index 411e15324c..77aa17e904 100644
--- a/libnvme/test/ioctl/ana.c
+++ b/libnvme/test/ioctl/ana.c
@@ -11,6 +11,7 @@
 #include <libnvme.h>
 
 #include "mock.h"
+#include "nvme/types.h"
 #include "util.h"
 
 #define TEST_FD 0xFD
diff --git a/libnvme/test/nbft/meson.build b/libnvme/test/nbft/meson.build
index 79b082a839..59b5af193a 100644
--- a/libnvme/test/nbft/meson.build
+++ b/libnvme/test/nbft/meson.build
@@ -41,6 +41,8 @@ nbft_dump = executable(
     ],
 )
 
+# Shell-based diff tests only work on Linux/Unix systems
+if not is_windows
 
 helper_data = configuration_data()
 helper_data.set('NBFT_DUMP_PATH', nbft_dump.full_path())
@@ -94,3 +96,5 @@ foreach table: tables_bad
         should_fail: true,
     )
 endforeach
+
+endif # Unix-only shell script tests
\ No newline at end of file
diff --git a/meson.build b/meson.build
index 603b15e922..a1df7747f3 100644
--- a/meson.build
+++ b/meson.build
@@ -90,7 +90,10 @@ endif
 
 ################################################################################
 prefixdir      = get_option('prefix')
+bindir         = join_paths(prefixdir, get_option('bindir'))
 datadir        = join_paths(prefixdir, get_option('datadir'))
+includedir     = join_paths(prefixdir, get_option('includedir'))
+libdir         = join_paths(prefixdir, get_option('libdir'))
 mandir         = join_paths(prefixdir, get_option('mandir'))
 sbindir        = join_paths(prefixdir, get_option('sbindir'))
 sysconfdir     = join_paths(prefixdir, get_option('sysconfdir'))
@@ -120,31 +123,121 @@ endif
 
 conf.set('SYSCONFDIR', '"@0@"'.format(sysconfdir))
 conf.set('RUNDIR', '"@0@"'.format(rundir))
+  
+################################################################################
+# Windows platform detection and configuration
+is_windows = host_machine.system() == 'windows'
 
-# Check for libjson-c availability
-if get_option('json-c').disabled()
+# Windows-specific dependency handling
+if is_windows
+    # Disable Linux-specific dependencies on Windows
     json_c_dep = dependency('', required: false)
+    liburing_dep = dependency('', required: false)
+    keyutils_dep = dependency('', required: false)
+    libdbus_dep = dependency('', required: false)
+    
+    # Find Windows system libraries
+    ws2_32_dep = cc.find_library('ws2_32', required: true)
+    wsock32_dep = cc.find_library('wsock32', required: true)
+    kernel32_dep = cc.find_library('kernel32', required: true)
+    iphlpapi_dep = cc.find_library('iphlpapi', required: true)
 else
-    json_c_dep = dependency(
-        'json-c',
-        required: get_option('json-c'),
-        version: '>=0.13',
-        fallback : ['json-c', 'json_c_dep'],
-    )
+    # Linux dependency detection
+    if get_option('json-c').disabled()
+        json_c_dep = dependency('', required: false)
+    else
+        json_c_dep = dependency(
+            'json-c',
+            required: get_option('json-c'),
+            version: '>=0.13',
+            fallback : ['json-c', 'json_c_dep'])
+    endif
     if json_c_dep.version().version_compare('>=0.14')
         conf.set('CONFIG_JSONC_14', true, description: 'Is json-c at least 0.14?')
         requires = 'Requires: json-c >= 0.14'
     else
         requires = 'Requires: json-c >= 0.13'
     endif
+
+    if get_option('liburing').disabled()
+        liburing_dep = dependency('', required: false)
+    else
+        liburing_dep = dependency('liburing', version: '>=2.2', required: get_option('liburing'))
+    endif
+
+    if get_option('keyutils').disabled()
+        keyutils_dep = dependency('', required: false)
+    else
+        keyutils_dep = dependency('libkeyutils',
+                                  required : get_option('keyutils'))
+    endif
+
+    if get_option('libdbus').disabled()
+        libdbus_dep = dependency('', required: false)
+    else
+        # Check for libdbus availability. Optional, only required for MCTP dbus scan
+
+        libdbus_dep = dependency(
+            'dbus-1',
+            required: true,
+            fallback: ['dbus', 'libdbus_dep'],
+            default_options: [
+                'default_library=static',
+                'embedded_tests=false',
+                'message_bus=false',
+                'modular_tests=disabled',
+                'tools=false',
+            ],
+        )
+    endif
+    
+    # Initialize Windows dependencies as empty for Linux
+    ws2_32_dep = dependency('', required: false)
+    wsock32_dep = dependency('', required: false)
+    kernel32_dep = dependency('', required: false)
+    iphlpapi_dep = dependency('', required: false)
 endif
-conf.set('CONFIG_JSONC', json_c_dep.found(), description: 'Is json-c available?')
 
 conf.set('NVME_VERSION', '"@0@"'.format(meson.project_version()))
 conf.set('LIBNVME_VERSION', '"@0@"'.format(meson.project_version()))
-
+conf.set('CONFIG_JSONC', json_c_dep.found(), description: 'Is json-c available?')
 conf.set10('DEFAULT_PDC_ENABLED', get_option('pdc-enabled'))
 
+# OpenSSL is supported on both platforms
+if get_option('openssl').disabled()
+  openssl_dep = dependency('', required: false)
+else
+  openssl_dep = dependency('openssl',
+                           version: '>=3.0.0',
+                           required: get_option('openssl'),
+                           fallback : ['openssl', 'libssl_dep'])
+endif
+if openssl_dep.found()
+  # Test for LibreSSL v3.x with incomplete OpenSSL v3 APIs
+  if openssl_dep.type_name() != 'internal'
+    is_libressl = cc.has_header_symbol('openssl/opensslv.h',
+                                       'LIBRESSL_VERSION_NUMBER',
+                                       dependencies: openssl_dep)
+    has_header = cc.has_header('openssl/core_names.h',
+                               dependencies: openssl_dep)
+    if is_libressl and not has_header
+      openssl_dep = dependency('', required: false)
+    endif
+  endif
+endif
+conf.set('CONFIG_OPENSSL', openssl_dep.found(),
+         description: 'Is OpenSSL/LibreSSL available?')
+
+# Windows-specific compiler flags
+if is_windows
+    add_project_arguments(
+        [
+            '-DHAVE_GLIBC_IOCTL=0',
+        ],
+        language : 'c',
+    )
+endif
+
 # local (cross-compilable) implementations of ccan configure steps
 conf.set10(
     'HAVE_BUILTIN_TYPES_COMPATIBLE_P',
@@ -269,68 +362,8 @@ else
     conf.set('fallthrough', 'do {} while (0) /* fallthrough */')
 endif
 
-
-if get_option('liburing').disabled()
-    liburing_dep = dependency('', required: false)
-else
-    liburing_dep = dependency('liburing', version: '>=2.2', required: get_option('liburing'))
-endif
 conf.set('CONFIG_LIBURING', liburing_dep.found(), description: 'Is liburing available?')
-
-if get_option('openssl').disabled()
-    openssl_dep = dependency('', required: false)
-else
-    openssl_dep = dependency(
-        'openssl',
-        version: '>=3.0.0',
-        required: get_option('openssl'),
-        fallback : ['openssl', 'libssl_dep'],
-    )
-endif
-if openssl_dep.found()
-    # Test for LibreSSL v3.x with incomplete OpenSSL v3 APIs
-    if openssl_dep.type_name() != 'internal'
-        is_libressl = cc.has_header_symbol(
-            'openssl/opensslv.h',
-            'LIBRESSL_VERSION_NUMBER',
-            dependencies: openssl_dep,
-        )
-        has_header = cc.has_header(
-            'openssl/core_names.h',
-            dependencies: openssl_dep,
-        )
-        if is_libressl and not has_header
-            openssl_dep = dependency('', required: false)
-        endif
-    endif
-endif
-conf.set('CONFIG_OPENSSL', openssl_dep.found(), description: 'Is OpenSSL/LibreSSL available?')
-
-if get_option('keyutils').disabled()
-    keyutils_dep = dependency('', required: false)
-else
-    keyutils_dep = dependency('libkeyutils', required : get_option('keyutils'))
-endif
 conf.set('CONFIG_KEYUTILS', keyutils_dep.found(), description: 'Is libkeyutils available?')
-
-if get_option('libdbus').disabled()
-    libdbus_dep = dependency('', required: false)
-else
-    # Check for libdus availability. Optional, only required for MCTP dbus scan
-    libdbus_dep = dependency(
-        'dbus-1',
-        required: true,
-        fallback: ['dbus', 'libdbus_dep'],
-        default_options: [
-            'default_library=static',
-            'embedded_tests=false',
-            'message_bus=false',
-            'modular_tests=disabled',
-            'tools=false',
-        ],
-    )
-endif
-
 conf.set('CONFIG_DBUS', libdbus_dep.found(), description: 'Enable dbus support?')
 
 conf.set10(
@@ -355,17 +388,17 @@ conf.set10(
 
 is_static = get_option('default_library') == 'static'
 have_netdb = false
-if not is_static
-    have_netdb = cc.links(
-        '''#include <sys/types.h>
-        #include <sys/socket.h>
-        #include <netdb.h>
-        int main(int argc, char **argv) {
-            struct addrinfo hints, *result;
-            return getaddrinfo(argv[1], argv[2], &hints, &result);
-        }
-        ''',
-        name: 'netdb',
+if not is_static and not is_windows
+  have_netdb = cc.links(
+      '''#include <sys/types.h>
+         #include <sys/socket.h>
+         #include <netdb.h>
+         int main(int argc, char **argv) {
+             struct addrinfo hints, *result;
+             return getaddrinfo(argv[1], argv[2], &hints, &result);
+      }
+      ''',
+      name: 'netdb',
     )
 endif
 conf.set(
@@ -434,6 +467,7 @@ if libtype == 'static'
     requires = ''
 endif
 
+################################################################################
 substs = configuration_data()
 substs.set('VERSION', meson.project_version())
 substs.set('NVMECLI_LICENSE', meson.project_license()[0])
@@ -595,12 +629,15 @@ path_dict = {
 summary(path_dict, section: 'Paths')
 
 dep_dict = {
-    'json-c':           json_c_dep.found(),
-    'OpenSSL':          openssl_dep.found(),
-    'keyutitls':        keyutils_dep.found(),
-    'libdbus':          libdbus_dep.found(),
-    'python3':          py3_dep.found(),
-    'liburing':         liburing_dep.found(),
+    'json-c':               json_c_dep.found(),
+    'OpenSSL':              openssl_dep.found(),
+    'keyutitls':            keyutils_dep.found(),
+    'libdbus':              libdbus_dep.found(),
+    'python3':              py3_dep.found(),
+    'liburing':             liburing_dep.found(),
+    'Windows (ws2_32)':     ws2_32_dep.found(),
+    'Windows (kernel32)':   kernel32_dep.found(),
+    'Windows (iphlpapi)':   iphlpapi_dep.found(),
 }
 summary(dep_dict, section: 'Dependencies', bool_yn: true)
 
@@ -617,4 +654,3 @@ conf_dict = {
     'pdc enabled':      get_option('pdc-enabled'),
 }
 summary(conf_dict, section: 'Configuration', bool_yn: true)
-

From 58a4ac27fb5661d5d05863ee672e7a2c3098f9a2 Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Tue, 13 Jan 2026 16:38:54 -0700
Subject: [PATCH 02/83] Add Micron build file.

---
 .github/workflows/micron-build.yml | 153 +++++++++++++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100644 .github/workflows/micron-build.yml

diff --git a/.github/workflows/micron-build.yml b/.github/workflows/micron-build.yml
new file mode 100644
index 0000000000..df08899f8c
--- /dev/null
+++ b/.github/workflows/micron-build.yml
@@ -0,0 +1,153 @@
+---
+name: build
+
+on:
+  push:
+    branches: [mingw]  # Changed from master
+  pull_request:
+    branches: [mingw]  # Changed from master
+
+  workflow_dispatch:
+
+jobs:
+  nvme-cli:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        compiler: [gcc, clang]
+        buildtype: [debug, release]
+    container:
+      image: ghcr.io/linux-nvme/debian.python:latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Mark repo as safe for git
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+      - name: build
+        run: |
+          scripts/build.sh -b ${{ matrix.buildtype }} -c ${{ matrix.compiler }} -x
+      - uses: actions/upload-artifact@v5
+        name: upload logs
+        if: failure()
+        with:
+          name: logs files
+          path: |
+            .build-ci/meson-logs/*.txt
+
+  libnvme:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        compiler: [gcc, clang]
+        buildtype: [debug, release]
+    container:
+      image: ghcr.io/linux-nvme/debian.python:latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Mark repo as safe for git
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+      - name: build
+        run: |
+          scripts/build.sh -b ${{ matrix.buildtype }} -c ${{ matrix.compiler }} -x libnvme
+      - uses: actions/upload-artifact@v5
+        name: upload logs
+        if: failure()
+        with:
+          name: libnvme logs files
+          path: |
+            .build-ci/meson-logs/*.txt
+
+  cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - arch: armhf
+          - arch: s390x
+          - arch: ppc64le
+    steps:
+      - uses: actions/checkout@v5
+      - name: enable foreign arch
+        uses: dbhi/qus/action@main
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: compile and run unit tests
+        uses: mosteo-actions/docker-run@v2
+        with:
+          image: ghcr.io/linux-nvme/ubuntu-cross-${{ matrix.arch }}:latest
+          guest-dir: /build
+          host-dir: ${{ github.workspace }}
+          command: |
+            git config --global --add safe.directory /build
+            scripts/build.sh -b release -c gcc -t ${{ matrix.arch }} cross
+          params: "--platform linux/amd64"
+          pull-params: "--platform linux/amd64"
+      - uses: actions/upload-artifact@v5
+        name: upload logs
+        if: failure()
+        with:
+          name: log files
+          path: |
+            .build-ci/meson-logs/*.txt
+
+  fallback-shared-libraries:
+    name: fallback shared libraries
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/linux-nvme/debian:latest
+    if: github.ref == 'refs/heads/mingw'  # Changed from master
+    steps:
+      - uses: actions/checkout@v5
+      - name: Mark repo as safe for git
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+      - name: build
+        run: |
+          scripts/build.sh -b release -c gcc fallback
+      - uses: actions/upload-artifact@v5
+        if: failure()
+        with:
+          name: log files
+          path: |
+            .build-ci/meson-logs/*.txt
+
+  build-muon:
+    name: muon minimal static
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/linux-nvme/debian:latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Mark repo as safe for git
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+      - name: build
+        run: |
+          scripts/build.sh -m muon
+
+  build-make-static:
+    name: make static
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/linux-nvme/debian:latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Mark repo as safe for git
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+      - name: build
+        run: |
+          make static
+
+  build-distro:
+    name: build libnvme and nvme-cli separately
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/linux-nvme/debian:latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Mark repo as safe for git
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+      - name: build
+        run: |
+          scripts/build.sh distro

From 8fdf9699badbb349df6c2308b4b18814a88f46de Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Tue, 13 Jan 2026 16:41:48 -0700
Subject: [PATCH 03/83] Update name.

---
 .github/workflows/micron-build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/micron-build.yml b/.github/workflows/micron-build.yml
index df08899f8c..061bf312c2 100644
--- a/.github/workflows/micron-build.yml
+++ b/.github/workflows/micron-build.yml
@@ -1,5 +1,5 @@
 ---
-name: build
+name: micron-build
 
 on:
   push:

From 936802b549b3ea66addec665405c5ca0681e764a Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Wed, 14 Jan 2026 14:55:34 -0700
Subject: [PATCH 04/83] Trigger CI after enabling Actions


From 67ec4ac172b1cce419d080d067b4984be7760bfc Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Wed, 14 Jan 2026 15:19:23 -0700
Subject: [PATCH 05/83] Change steps to use verified actions.

---
 .github/workflows/micron-build.yml | 34 +++++++++++++++++++-----------
 1 file changed, 22 insertions(+), 12 deletions(-)

diff --git a/.github/workflows/micron-build.yml b/.github/workflows/micron-build.yml
index 061bf312c2..d9b959e68c 100644
--- a/.github/workflows/micron-build.yml
+++ b/.github/workflows/micron-build.yml
@@ -66,25 +66,35 @@ jobs:
           - arch: ppc64le
     steps:
       - uses: actions/checkout@v5
-      - name: enable foreign arch
-        uses: dbhi/qus/action@main
+
+      # enable foreign arch (replace unverified dbhi/qus with verified Docker QEMU setup)
+      - name: Enable QEMU for cross-arch
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: arm,ppc64le,s390x
+
       - name: Login to GitHub Container Registry
         uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
+
+      # compile and run unit tests (replace unverified mosteo-actions/docker-run with native docker run)
       - name: compile and run unit tests
-        uses: mosteo-actions/docker-run@v2
-        with:
-          image: ghcr.io/linux-nvme/ubuntu-cross-${{ matrix.arch }}:latest
-          guest-dir: /build
-          host-dir: ${{ github.workspace }}
-          command: |
-            git config --global --add safe.directory /build
-            scripts/build.sh -b release -c gcc -t ${{ matrix.arch }} cross
-          params: "--platform linux/amd64"
-          pull-params: "--platform linux/amd64"
+        run: |
+          set -eux
+          docker pull --platform linux/amd64 ghcr.io/linux-nvme/ubuntu-cross-${{ matrix.arch }}:latest
+          docker run --rm \
+            --platform linux/amd64 \
+            -v "${{ github.workspace }}:/build" \
+            -w /build \
+            ghcr.io/linux-nvme/ubuntu-cross-${{ matrix.arch }}:latest \
+            bash -lc '
+              git config --global --add safe.directory /build
+              scripts/build.sh -b release -c gcc -t ${{ matrix.arch }} cross
+            '
+
       - uses: actions/upload-artifact@v5
         name: upload logs
         if: failure()

From a0464ffd1996b9c884f6e37ad1c6bb075adf3ad7 Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Thu, 15 Jan 2026 08:35:28 -0700
Subject: [PATCH 06/83] A Micron happy version of checkpatch workflow.

---
 .github/workflows/micron-checkpatch.yml | 51 +++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 .github/workflows/micron-checkpatch.yml

diff --git a/.github/workflows/micron-checkpatch.yml b/.github/workflows/micron-checkpatch.yml
new file mode 100644
index 0000000000..4d7b0ae39a
--- /dev/null
+++ b/.github/workflows/micron-checkpatch.yml
@@ -0,0 +1,51 @@
+name: Micron checkpatch review
+
+on:
+  pull_request:
+    branches: [mingw]  # Branch is not specified in upstream file.
+
+jobs:
+  checkpatch:
+    name: checkpatch review
+    runs-on: ubuntu-latest
+
+    steps:
+    # Same as upstream: compute how many commits to fetch
+    - name: Calculate PR commits + 1
+      run: echo "PR_FETCH_DEPTH=$(( ${{ github.event.pull_request.commits }} + 1 ))" >> $GITHUB_ENV
+
+    # GitHub-owned (allowed) checkout action
+    - name: Checkout PR branch
+      uses: actions/checkout@v5
+      with:
+        ref: ${{ github.event.pull_request.head.sha }}
+        fetch-depth: ${{ env.PR_FETCH_DEPTH }}
+
+    # Install dependencies needed to run checkpatch.pl
+    - name: Install prerequisites
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y wget perl
+
+    - name: Download checkpatch.pl and dependencies
+      run: |
+        wget https://raw.githubusercontent.com/torvalds/linux/master/scripts/checkpatch.pl \
+          -O checkpatch.pl
+        wget https://raw.githubusercontent.com/torvalds/linux/master/scripts/spelling.txt \
+          -O spelling.txt
+        chmod +x checkpatch.pl
+
+    - name: Run checkpatch review
+      run: |
+        git fetch origin ${{ github.base_ref }}
+        git diff origin/${{ github.base_ref }} > patch.diff
+        
+        echo "::group::Checkpatch Results"
+        if ./checkpatch.pl --no-tree --strict --show-types patch.diff; then
+          echo "::endgroup::"
+          echo "✅ No checkpatch issues found"
+        else
+          echo "::endgroup::"
+          echo "::error::Checkpatch found issues. Please fix them before merging."
+          exit 1
+        fi

From 1eff461eed87c7b59ee4eeb3d96ba7f3a63bac6c Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Thu, 15 Jan 2026 14:19:05 -0700
Subject: [PATCH 07/83] Remove trailing whitespace.

---
 .github/workflows/micron-checkpatch.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/micron-checkpatch.yml b/.github/workflows/micron-checkpatch.yml
index 4d7b0ae39a..60e2bc192a 100644
--- a/.github/workflows/micron-checkpatch.yml
+++ b/.github/workflows/micron-checkpatch.yml
@@ -39,7 +39,7 @@ jobs:
       run: |
         git fetch origin ${{ github.base_ref }}
         git diff origin/${{ github.base_ref }} > patch.diff
-        
+
         echo "::group::Checkpatch Results"
         if ./checkpatch.pl --no-tree --strict --show-types patch.diff; then
           echo "::endgroup::"

From eae9ebd04c0c3d372597c30f88f4e7994277ba63 Mon Sep 17 00:00:00 2001
From: Brandon Capener <bcapener@micron.com>
Date: Thu, 22 Jan 2026 15:16:56 -0700
Subject: [PATCH 08/83] Add support for build system to read git tag on windows

---
 meson.build               | 27 +++++++++++++++++---------
 scripts/meson-vcs-tag.ps1 | 41 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+), 9 deletions(-)
 create mode 100644 scripts/meson-vcs-tag.ps1

diff --git a/meson.build b/meson.build
index a1df7747f3..bc1ee82e2d 100644
--- a/meson.build
+++ b/meson.build
@@ -108,16 +108,28 @@ std_prefix = prefixdir == '/usr' or prefixdir == '/usr/local'
 conf = configuration_data()
 requires = ''
 
+# Windows platform detection and configuration
+is_windows = host_machine.system() == 'windows'
+
 version_tag = get_option('version-tag')
 if version_tag != ''
     conf.set('GIT_VERSION', '"@0@"'.format(version_tag))
 else
-    r = run_command(
-        'scripts/meson-vcs-tag.sh',
-        meson.current_source_dir(),
-        meson.project_version(),
-        check: true,
-    )
+    if is_windows
+        r = run_command(
+            'powershell', '-File', 'scripts/meson-vcs-tag.ps1',
+            meson.current_source_dir(),
+            meson.project_version(),
+            check: true,
+        )
+    else
+        r = run_command(
+            'scripts/meson-vcs-tag.sh',
+            meson.current_source_dir(),
+            meson.project_version(),
+            check: true,
+        )
+    endif
     conf.set('GIT_VERSION', '"@0@"'.format(r.stdout().strip()))
 endif
 
@@ -125,9 +137,6 @@ conf.set('SYSCONFDIR', '"@0@"'.format(sysconfdir))
 conf.set('RUNDIR', '"@0@"'.format(rundir))
   
 ################################################################################
-# Windows platform detection and configuration
-is_windows = host_machine.system() == 'windows'
-
 # Windows-specific dependency handling
 if is_windows
     # Disable Linux-specific dependencies on Windows
diff --git a/scripts/meson-vcs-tag.ps1 b/scripts/meson-vcs-tag.ps1
new file mode 100644
index 0000000000..09da8f512d
--- /dev/null
+++ b/scripts/meson-vcs-tag.ps1
@@ -0,0 +1,41 @@
+#!/usr/bin/env pwsh
+# SPDX-License-Identifier: LGPL-2.1-or-later
+
+param(
+    [Parameter(Mandatory=$true, Position=0)]
+    [string]$Directory,
+
+    [Parameter(Mandatory=$true, Position=1)]
+    [string]$Fallback
+)
+
+$ErrorActionPreference = "Stop"
+
+# Apparently git describe has a bug where it always considers the work-tree
+# dirty when invoked with --git-dir (even though 'git status' is happy). Work
+# around this issue by cd-ing to the source directory.
+Push-Location $Directory
+
+try {
+    # Check that we have either .git/ (a normal clone) or a .git file (a work-tree)
+    # and that we don't get confused if a tarball is extracted in a higher-level
+    # git repository.
+    if (Test-Path ".git") {
+        try {
+            $version = git describe --abbrev=7 --dirty=+ 2>&1
+            if ($LASTEXITCODE -eq 0) {
+                # Remove leading 'v' if present
+                $version = $version -replace '^v', ''
+                Write-Output $version
+            } else {
+                Write-Output $Fallback
+            }
+        } catch {
+            Write-Output $Fallback
+        }
+    } else {
+        Write-Output $Fallback
+    }
+} finally {
+    Pop-Location
+}

From 832fb96bf149a070a56ba4d75415c269090aa1c6 Mon Sep 17 00:00:00 2001
From: Brandon Capener <bcapener@micron.com>
Date: Mon, 26 Jan 2026 12:11:17 -0700
Subject: [PATCH 09/83] Add libnvme tests kdoc and UUID (#26)

* add tests kdoc and uuid

* Update libnvme/scripts/kernel-doc-check.ps1 no perl found error message

Co-authored-by: Broc Going <bgoing@micron.com>

---------

Co-authored-by: Broc Going <bgoing@micron.com>
---
 libnvme/doc/meson.build                      |  13 +-
 libnvme/scripts/kernel-doc-check.ps1         |  28 +++
 libnvme/src/meson.build                      |   1 +
 libnvme/src/nvme/platform/platform_linux.h   |  21 ++
 libnvme/src/nvme/platform/platform_windows.h |  17 ++
 libnvme/src/nvme/util.c                      |  15 +-
 libnvme/test/meson.build                     | 194 ++++++++++---------
 7 files changed, 181 insertions(+), 108 deletions(-)
 create mode 100644 libnvme/scripts/kernel-doc-check.ps1

diff --git a/libnvme/doc/meson.build b/libnvme/doc/meson.build
index df0d92f3d9..b81222c1e1 100644
--- a/libnvme/doc/meson.build
+++ b/libnvme/doc/meson.build
@@ -50,9 +50,18 @@ subdir('rst')
 top_source_dir = meson.current_source_dir() + '/../'
 
 kernel_doc = find_program(top_source_dir + 'scripts/kernel-doc')
-kernel_doc_check = find_program(top_source_dir +'scripts/kernel-doc-check')
 
-test('libnvme - kdoc', kernel_doc_check, args: api_paths)
+if is_windows
+    powershell = find_program('powershell', required: false)
+    if powershell.found()
+        kernel_doc_check_script = top_source_dir + 'scripts/kernel-doc-check.ps1'
+        test('libnvme - kdoc', powershell,
+             args: ['-ExecutionPolicy', 'Bypass', '-File', kernel_doc_check_script] + api_paths)
+    endif
+else
+    kernel_doc_check = find_program(top_source_dir +'scripts/kernel-doc-check')
+    test('libnvme - kdoc', kernel_doc_check, args: api_paths)
+endif
 
 if want_docs != 'false'
     if want_docs == 'all' or want_docs == 'man'
diff --git a/libnvme/scripts/kernel-doc-check.ps1 b/libnvme/scripts/kernel-doc-check.ps1
new file mode 100644
index 0000000000..7988f7bb8a
--- /dev/null
+++ b/libnvme/scripts/kernel-doc-check.ps1
@@ -0,0 +1,28 @@
+
+# SPDX-License-Identifier: LGPL-2.1-or-later
+
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$kernelDoc = Join-Path $scriptDir "kernel-doc"
+
+# Check if perl is available
+$perl = Get-Command perl -ErrorAction SilentlyContinue
+if (-not $perl) {
+    Write-Error "Perl is not installed or not in PATH."
+    exit 1
+}
+
+# Run kernel-doc and capture output and exit code
+$output = & perl $kernelDoc -none $args 2>&1
+$kernelDocExitCode = $LASTEXITCODE
+
+# Filter for warnings and errors
+$filtered = $output | Select-String -Pattern '(warning|error)'
+
+# Check that kernel-doc succeeded (exit code 0) and no warnings/errors were found
+if ($kernelDocExitCode -eq 0 -and $filtered.Count -eq 0) {
+    exit 0
+} else {
+    # Print any warnings/errors found
+    $filtered | ForEach-Object { Write-Host $_ }
+    exit 1
+}
diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index f098e19ca9..760a46a387 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -65,6 +65,7 @@ if is_windows
         cc.find_library('ws2_32'),
         cc.find_library('wsock32'),
         cc.find_library('iphlpapi'),
+        cc.find_library('bcrypt'),  # For BCryptGenRandom in nvme_uuid_random
     ]
 endif
 
diff --git a/libnvme/src/nvme/platform/platform_linux.h b/libnvme/src/nvme/platform/platform_linux.h
index b96e58761b..783e369090 100644
--- a/libnvme/src/nvme/platform/platform_linux.h
+++ b/libnvme/src/nvme/platform/platform_linux.h
@@ -13,6 +13,7 @@
 /* Linux standard includes */
 #include <unistd.h>
 #include <fcntl.h>
+#include <errno.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
@@ -31,6 +32,7 @@
 #include <linux/types.h>
 #include <endian.h>
 #include <net/if.h>
+#include "cleanup.h"
 
 /* Linux cleanup attribute */
 #define __nvme_cleanup(fn) __attribute__((__cleanup__(fn)))
@@ -38,4 +40,23 @@
 /* Extract IPv4 from IPv6 mapped address */
 #define ipv4_from_in6_addr(addr) &(addr.s6_addr32[3])
 
+/* Platform-specific UUID generation using /dev/urandom */
+static inline int random_uuid(unsigned char *uuid, size_t len)
+{
+	_cleanup_fd_ int f = -1;
+	ssize_t n;
+
+	f = open("/dev/urandom", O_RDONLY);
+	if (f < 0)
+		return -errno;
+
+	n = read(f, uuid, len);
+	if (n < 0)
+		return -errno;
+	else if ((size_t)n != len)
+		return -EIO;
+
+	return 0;
+}
+
 #endif /* _LIBNVME_PLATFORM_LINUX_H */
\ No newline at end of file
diff --git a/libnvme/src/nvme/platform/platform_windows.h b/libnvme/src/nvme/platform/platform_windows.h
index 067899f466..002cc19a54 100644
--- a/libnvme/src/nvme/platform/platform_windows.h
+++ b/libnvme/src/nvme/platform/platform_windows.h
@@ -18,8 +18,10 @@
 #undef WIN32_LEAN_AND_MEAN
 #include <winioctl.h>
 #include <ntddstor.h>
+#include <bcrypt.h>
 #include <stdint.h>
 #include <stdarg.h>
+#include <errno.h>
 #include <io.h>
 #include <direct.h>
 #include <process.h>
@@ -244,11 +246,26 @@ static inline size_t malloc_usable_size(void *ptr) {
 #endif /* _IOC_NONE */
 
 /* MIN/min macros for Windows */
+#ifndef __cplusplus
 #ifndef MIN
 #define MIN(a,b) ((a) < (b) ? (a) : (b))
 #endif
 #ifndef min
 #define min(a,b) ((a) < (b) ? (a) : (b))
 #endif
+#endif /* __cplusplus */
+
+/* Platform-specific UUID generation using BCryptGenRandom */
+static inline int random_uuid(unsigned char *uuid, size_t len)
+{
+	NTSTATUS status;
+
+	status = BCryptGenRandom(NULL, uuid, (ULONG)len,
+				 BCRYPT_USE_SYSTEM_PREFERRED_RNG);
+	if (!BCRYPT_SUCCESS(status))
+		return -EIO;
+
+	return 0;
+}
 
 #endif /* _LIBNVME_PLATFORM_WINDOWS_H */
\ No newline at end of file
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 6bb68d79d0..255d123836 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -944,17 +944,12 @@ int nvme_uuid_from_string(const char *str, unsigned char uuid[NVME_UUID_LEN])
 
 int nvme_uuid_random(unsigned char uuid[NVME_UUID_LEN])
 {
-	_cleanup_fd_ int f = -1;
-	ssize_t n;
+	int ret;
 
-	f = open("/dev/urandom", O_RDONLY);
-	if (f < 0)
-		return -errno;
-	n = read(f, uuid, NVME_UUID_LEN);
-	if (n < 0)
-		return -errno;
-	else if (n != NVME_UUID_LEN)
-		return -EIO;
+	/* Generate random bytes using platform-specific implementation */
+	ret = random_uuid(uuid, NVME_UUID_LEN);
+	if (ret < 0)
+		return ret;
 
 	/*
 	 * See https://www.rfc-editor.org/rfc/rfc4122#section-4.4
diff --git a/libnvme/test/meson.build b/libnvme/test/meson.build
index 6512f5b959..66e04ce608 100644
--- a/libnvme/test/meson.build
+++ b/libnvme/test/meson.build
@@ -45,50 +45,6 @@ if cxx_available
 
 endif
 
-register = executable(
-    'test-register',
-    ['register.c'],
-    dependencies: [
-        config_dep,
-        ccan_dep,
-        libnvme_dep,
-    ],
-)
-
-zns = executable(
-    'test-zns',
-    ['zns.c'],
-    dependencies: [
-        config_dep,
-        ccan_dep,
-        libnvme_dep,
-    ],
-)
-
-mi = executable(
-    'test-mi',
-    ['mi.c', 'utils.c'],
-    dependencies: [
-        config_dep,
-        ccan_dep,
-        libnvme_test_dep,
-    ],
-)
-
-test('libnvme - mi', mi)
-
-mi_mctp = executable(
-    'test-mi-mctp',
-    ['mi-mctp.c', 'utils.c'],
-    dependencies: [
-        config_dep,
-        ccan_dep,
-        libnvme_test_dep,
-    ],
-)
-
-test('libnvme - mi-mctp', mi_mctp)
-
 uuid = executable(
     'test-uuid',
     ['uuid.c'],
@@ -101,78 +57,124 @@ uuid = executable(
 
 test('libnvme - uuid', uuid)
 
-uriparser = executable(
-    'test-uriparser',
-    ['uriparser.c'],
-    dependencies: [
-        config_dep,
-        ccan_dep,
-        libnvme_dep,
-    ],
-)
+if not is_windows
+    register = executable(
+        'test-register',
+        ['register.c'],
+        dependencies: [
+            config_dep,
+            ccan_dep,
+            libnvme_dep,
+        ],
+    )
 
-test('libnvme - uriparser', uriparser)
+    zns = executable(
+        'test-zns',
+        ['zns.c'],
+        dependencies: [
+            config_dep,
+            ccan_dep,
+            libnvme_dep,
+        ],
+    )
 
-if conf.get('HAVE_NETDB')
-    mock_ifaddrs = library(
-        'mock-ifaddrs',
-        ['mock-ifaddrs.c', ],
+    mi = executable(
+        'test-mi',
+        ['mi.c', 'utils.c'],
+        dependencies: [
+            config_dep,
+            ccan_dep,
+            libnvme_test_dep,
+        ],
     )
 
-    # See comment in test/ioctl/meson.build explaining how LD_PRELOAD is used
-    mock_ifaddrs_env = environment()
-    mock_ifaddrs_env.append('LD_PRELOAD', mock_ifaddrs.full_path())
-    mock_ifaddrs_env.set('ASAN_OPTIONS', 'verify_asan_link_order=0')
+    test('libnvme - mi', mi)
 
-    tree = executable(
-        'tree',
-        ['tree.c'],
+    mi_mctp = executable(
+        'test-mi-mctp',
+        ['mi-mctp.c', 'utils.c'],
         dependencies: [
             config_dep,
             ccan_dep,
-            libnvme_dep,
+            libnvme_test_dep,
         ],
-        link_with: mock_ifaddrs,
     )
 
-    test('libnvme - tree', tree, env: mock_ifaddrs_env)
+    test('libnvme - mi-mctp', mi_mctp)
 
-    test_util = executable(
-        'test-util',
-        ['test-util.c'],
+    uriparser = executable(
+        'test-uriparser',
+        ['uriparser.c'],
         dependencies: [
             config_dep,
             ccan_dep,
             libnvme_dep,
         ],
     )
-    test('libnvme - util', test_util)
-endif
 
-psk = executable(
-    'test-psk',
-    ['psk.c'],
-    dependencies: [
-        config_dep,
-        ccan_dep,
-        libnvme_dep,
-    ],
-)
+    test('libnvme - uriparser', uriparser)
+
+    if conf.get('HAVE_NETDB')
+        mock_ifaddrs = library(
+            'mock-ifaddrs',
+            ['mock-ifaddrs.c', ],
+        )
+
+        # See comment in test/ioctl/meson.build explaining how LD_PRELOAD is used
+        mock_ifaddrs_env = environment()
+        mock_ifaddrs_env.append('LD_PRELOAD', mock_ifaddrs.full_path())
+        mock_ifaddrs_env.set('ASAN_OPTIONS', 'verify_asan_link_order=0')
+
+        tree = executable(
+            'tree',
+            ['tree.c'],
+            dependencies: [
+                config_dep,
+                ccan_dep,
+                libnvme_dep,
+            ],
+            link_with: mock_ifaddrs,
+        )
+
+        test('libnvme - tree', tree, env: mock_ifaddrs_env)
+
+        test_util = executable(
+            'test-util',
+            ['test-util.c'],
+            dependencies: [
+                config_dep,
+                ccan_dep,
+                libnvme_dep,
+            ],
+        )
+        test('libnvme - util', test_util)
+    endif
+
+    psk = executable(
+        'test-psk',
+        ['psk.c'],
+        dependencies: [
+            config_dep,
+            ccan_dep,
+            libnvme_dep,
+        ],
+    )
 
-test('libnvme - psk', psk)
+    test('libnvme - psk', psk)
 
-subdir('ioctl')
-subdir('nbft')
+    subdir('ioctl')
+    subdir('nbft')
 
-if json_c_dep.found()
-    subdir('sysfs')
-    subdir('config')
-endif
+    if json_c_dep.found()
+        subdir('sysfs')
+        subdir('config')
+    endif
 
-if openssl_dep.found()
-    hkdf_add1 = executable(
-        'hkdf_add1',
-        ['hkdf_add1.c'],
-        dependencies: openssl_dep,
-    )
-endif
+    if openssl_dep.found()
+        hkdf_add1 = executable(
+            'hkdf_add1',
+            ['hkdf_add1.c'],
+            dependencies: openssl_dep,
+        )
+    endif
+endif # not is_windows

From a2b0d098b5b68df20f53490e9a6f48077dea0093 Mon Sep 17 00:00:00 2001
From: Brandon Capener <bcapener@micron.com>
Date: Fri, 30 Jan 2026 14:48:03 -0700
Subject: [PATCH 10/83] update windows-stubs.c to match actual signatures (#27)

---
 libnvme/src/nvme/windows-stubs.c | 348 +++++++++++++------------------
 1 file changed, 142 insertions(+), 206 deletions(-)

diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index e28825a836..c1b217c7ca 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -10,13 +10,7 @@
 #include <errno.h>
 #include <stdio.h>
 #include <nvme/types.h>
-
-/* Forward declarations for Linux-specific structures */
-struct nvme_host;
-struct nvme_subsystem;
-struct nvme_ctrl;
-struct nvme_path;
-struct nvme_ns;
+#include "private.h"
 
 /* Logging control for stub calls */
 static int stub_log_enabled = 0;
@@ -38,20 +32,21 @@ void nvme_stubs_set_debug(int enable)
  */
 
 /* Fabrics configuration stubs - just return errors */
-void nvmf_default_config(void *cfg)
+void nvmf_default_config(struct nvme_fabrics_config *cfg)
 {
 	stub_log(__func__);
 	(void)cfg;
 }
 
-void nvmf_update_config(void *c, const void *cfg)
+void nvmf_update_config(nvme_ctrl_t c, const struct nvme_fabrics_config *cfg)
 {
 	stub_log(__func__);
 	(void)c;
 	(void)cfg;
 }
 
-int nvmf_add_ctrl(void *h, void *c, const void *cfg)
+int nvmf_add_ctrl(nvme_host_t h, nvme_ctrl_t c,
+		  const struct nvme_fabrics_config *cfg)
 {
 	stub_log(__func__);
 	(void)h;
@@ -61,7 +56,7 @@ int nvmf_add_ctrl(void *h, void *c, const void *cfg)
 	return -1;
 }
 
-int nvmf_connect_ctrl(void *c)
+int nvmf_connect_ctrl(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
@@ -69,7 +64,7 @@ int nvmf_connect_ctrl(void *c)
 	return -1;
 }
 
-int nvmf_get_discovery_log(void *c, void **logp, int max_retries)
+int nvmf_get_discovery_log(nvme_ctrl_t c, struct nvmf_discovery_log **logp, int max_retries)
 {
 	stub_log(__func__);
 	(void)c;
@@ -79,7 +74,7 @@ int nvmf_get_discovery_log(void *c, void **logp, int max_retries)
 	return -1;
 }
 
-int nvmf_get_discovery_wargs(void *args, void **logp)
+int nvmf_get_discovery_wargs(struct nvme_get_discovery_args *args, struct nvmf_discovery_log **logp)
 {
 	stub_log(__func__);
 	(void)args;
@@ -100,14 +95,14 @@ int nvmf_connect_disc_entry(void *h, void *e, const void *defcfg, int *discover,
 	return -1;
 }
 
-int nvmf_is_registration_supported(void *c)
+bool nvmf_is_registration_supported(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
-	return 0; /* Not supported */
+	return false; /* Not supported */
 }
 
-int nvmf_register_ctrl(void *c, int tas, __u32 *result)
+int nvmf_register_ctrl(nvme_ctrl_t c, enum nvmf_dim_tas tas, __u32 *result)
 {
 	stub_log(__func__);
 	(void)c;
@@ -117,7 +112,7 @@ int nvmf_register_ctrl(void *c, int tas, __u32 *result)
 	return -1;
 }
 
-int nvme_parse_uri(const char *str, void **uri)
+int nvme_parse_uri(const char *str, struct nvme_fabrics_uri **uri)
 {
 	stub_log(__func__);
 	(void)str;
@@ -126,7 +121,7 @@ int nvme_parse_uri(const char *str, void **uri)
 	return -1;
 }
 
-void nvme_free_uri(void *uri)
+void nvme_free_uri(struct nvme_fabrics_uri *uri)
 {
 	stub_log(__func__);
 	(void)uri;
@@ -137,10 +132,10 @@ void nvme_free_uri(void *uri)
  * Minimal support - just return NULL/errors
  */
 
-void nvme_release_fds(void *r)
+void nvme_release_fds(struct nvme_global_ctx *ctx)
 {
 	stub_log(__func__);
-	(void)r;
+	(void)ctx;
 }
 
 void *nvme_create_root(const char *config_file, int log_level)
@@ -178,13 +173,14 @@ void nvme_root_set_application(void *r, const char *a)
 	(void)a;
 }
 
-void *nvme_scan(const char *config_file, int log_level)
+int nvme_scan(const char *config_file, struct nvme_global_ctx **ctx)
 {
 	stub_log(__func__);
 	(void)config_file;
-	(void)log_level;
+	(void)ctx;
 	/* Scanning not supported on Windows */
-	return NULL;
+	errno = ENOTSUP;
+	return -1;
 }
 
 struct nvme_global_ctx *nvme_create_global_ctx(FILE *fp, int log_level)
@@ -196,63 +192,67 @@ struct nvme_global_ctx *nvme_create_global_ctx(FILE *fp, int log_level)
 	return NULL;
 }
 
-void *nvme_scan_ctrl(void *ctx, const char *name)
+int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name, nvme_ctrl_t *c)
 {
 	stub_log(__func__);
 	(void)ctx;
 	(void)name;
-	return NULL;
+	(void)c;
+	errno = ENOTSUP;
+	return -1;
 }
 
-int nvme_scan_topology(void *r, void *f, void *f_args)
+int nvme_scan_topology(struct nvme_global_ctx *ctx, nvme_scan_filter_t f, void *f_args)
 {
 	stub_log(__func__);
-	(void)r;
+	(void)ctx;
 	(void)f;
 	(void)f_args;
 	errno = ENOTSUP;
 	return -1;
 }
 
-void *nvme_first_host(void *r)
+nvme_host_t nvme_first_host(struct nvme_global_ctx *ctx)
 {
 	stub_log(__func__);
-	(void)r;
+	(void)ctx;
 	return NULL;
 }
 
-void *nvme_next_host(void *r, void *h)
+nvme_host_t nvme_next_host(struct nvme_global_ctx *ctx, nvme_host_t h)
 {
 	stub_log(__func__);
-	(void)r;
+	(void)ctx;
 	(void)h;
 	return NULL;
 }
 
-void *nvme_lookup_host(void *r, const char *hostnqn, const char *hostid)
+nvme_host_t nvme_lookup_host(struct nvme_global_ctx *ctx, const char *hostnqn, const char *hostid)
 {
 	stub_log(__func__);
-	(void)r;
+	(void)ctx;
 	(void)hostnqn;
 	(void)hostid;
 	return NULL;
 }
 
-void *nvme_default_host(void *r)
+int nvme_default_host(struct nvme_global_ctx *ctx, nvme_host_t *h)
 {
 	stub_log(__func__);
-	(void)r;
-	return NULL;
+	(void)ctx;
+	(void)h;
+	errno = ENOTSUP;
+	return -1;
 }
 
-void *nvme_first_subsystem(void *h)
+nvme_subsystem_t nvme_first_subsystem(nvme_host_t h)
 {
 	stub_log(__func__);
 	(void)h;
 	return NULL;
 }
 
-void *nvme_next_subsystem(void *h, void *s)
+nvme_subsystem_t nvme_next_subsystem(nvme_host_t h, nvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)h;
@@ -260,7 +260,7 @@ void *nvme_next_subsystem(void *h, void *s)
 	return NULL;
 }
 
-void *nvme_lookup_subsystem(struct nvme_host *h, const char *name, const char *subsysnqn)
+nvme_subsystem_t nvme_lookup_subsystem(struct nvme_host *h, const char *name, const char *subsysnqn)
 {
 	stub_log(__func__);
 	(void)h;
@@ -284,9 +284,9 @@ void *nvme_next_ctrl(void *s, void *c)
 	return NULL;
 }
 
-void *nvme_lookup_ctrl(void *s, const char *transport, const char *traddr,
+nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport, const char *traddr,
 		       const char *trsvcid, const char *subsysnqn,
-		       const char *host_traddr, const char *host_iface)
+		       const char *host_traddr, nvme_ctrl_t p)
 {
 	stub_log(__func__);
 	(void)s;
@@ -295,33 +295,33 @@ void *nvme_lookup_ctrl(void *s, const char *transport, const char *traddr,
 	(void)trsvcid;
 	(void)subsysnqn;
 	(void)host_traddr;
-	(void)host_iface;
+	(void)p;
 	return NULL;
 }
 
-void *nvme_ctrl_first_ns(void *c)
+nvme_ns_t nvme_ctrl_first_ns(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-void *nvme_ctrl_next_ns(void *c, void *ns)
+nvme_ns_t nvme_ctrl_next_ns(nvme_ctrl_t c, nvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)c;
-	(void)ns;
+	(void)n;
 	return NULL;
 }
 
-void *nvme_ctrl_first_path(void *c)
+nvme_path_t nvme_ctrl_first_path(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-void *nvme_ctrl_next_path(void *c, void *p)
+nvme_path_t nvme_ctrl_next_path(nvme_ctrl_t c, nvme_path_t p)
 {
 	stub_log(__func__);
 	(void)c;
@@ -344,17 +344,17 @@ void *nvme_subsys_next_ns(void *s, void *ns)
 	return NULL;
 }
 
-void *nvme_ns_get_subsystem(void *ns)
+nvme_subsystem_t nvme_ns_get_subsystem(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return NULL;
 }
 
-void *nvme_ns_get_ctrl(void *ns)
+nvme_ctrl_t nvme_ns_get_ctrl(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return NULL;
 }
 
@@ -365,170 +365,170 @@ int nvme_ns_get_fd(void *ns)
 	return -1;
 }
 
-int nvme_ns_get_nsid(void *ns)
+int nvme_ns_get_nsid(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return 0;
 }
 
-int nvme_ns_get_csi(void *ns)
+enum nvme_csi nvme_ns_get_csi(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return 0;
 }
 
-const unsigned char *nvme_ns_get_eui64(void *ns)
+const uint8_t *nvme_ns_get_eui64(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return NULL;
 }
 
-const unsigned char *nvme_ns_get_nguid(void *ns)
+const uint8_t *nvme_ns_get_nguid(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return NULL;
 }
 
-const unsigned char *nvme_ns_get_uuid(void *ns)
+void nvme_ns_get_uuid(nvme_ns_t n, unsigned char out[NVME_UUID_LEN])
 {
 	stub_log(__func__);
-	(void)ns;
-	return NULL;
+	(void)n;
+	(void)out;
 }
 
-void *nvme_ns_get_transport_handle(void *ns)
+struct nvme_transport_handle *nvme_ns_get_transport_handle(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return NULL;
 }
 
-int nvme_ns_identify(void *ns, void *ns_id)
+int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns)
 {
 	stub_log(__func__);
+	(void)n;
 	(void)ns;
-	(void)ns_id;
 	errno = ENOTSUP;
 	return -1;
 }
 
-const char *nvme_ns_get_sysfs_dir(void *ns)
+const char *nvme_ns_get_sysfs_dir(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return "";
 }
 
-const char *nvme_ns_get_name(void *ns)
+const char *nvme_ns_get_name(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return "";
 }
 
-const char *nvme_ns_get_generic_name(void *ns)
+const char *nvme_ns_get_generic_name(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return "";
 }
 
-int nvme_ns_get_lba_size(void *ns)
+int nvme_ns_get_lba_size(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return 0;
 }
 
-unsigned long long nvme_ns_get_lba_count(void *ns)
+uint64_t nvme_ns_get_lba_count(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return 0;
 }
 
-unsigned long long nvme_ns_get_lba_util(void *ns)
+uint64_t nvme_ns_get_lba_util(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return 0;
 }
 
-const char *nvme_path_get_name(void *p)
+const char *nvme_path_get_name(nvme_path_t p)
 {
 	stub_log(__func__);
 	(void)p;
 	return "";
 }
 
-const char *nvme_path_get_sysfs_dir(void *p)
+const char *nvme_path_get_sysfs_dir(nvme_path_t p)
 {
 	stub_log(__func__);
 	(void)p;
 	return "";
 }
 
-const char *nvme_path_get_ana_state(void *p)
+const char *nvme_path_get_ana_state(nvme_path_t p)
 {
 	stub_log(__func__);
 	(void)p;
 	return "";
 }
 
-void *nvme_path_get_ctrl(void *p)
+nvme_ctrl_t nvme_path_get_ctrl(nvme_path_t p)
 {
 	stub_log(__func__);
 	(void)p;
 	return NULL;
 }
 
-void *nvme_path_get_ns(void *p)
+nvme_ns_t nvme_path_get_ns(nvme_path_t p)
 {
 	stub_log(__func__);
 	(void)p;
 	return NULL;
 }
 
-const char *nvme_ctrl_get_name(void *c)
+const char *nvme_ctrl_get_name(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return "";
 }
 
-const char *nvme_ctrl_get_sysfs_dir(void *c)
+const char *nvme_ctrl_get_sysfs_dir(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return "";
 }
 
-const char *nvme_ctrl_get_address(void *c)
+const char *nvme_ctrl_get_address(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return "";
 }
 
-const char *nvme_ctrl_get_transport(void *c)
+const char *nvme_ctrl_get_transport(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return "";
 }
 
-const char *nvme_ctrl_get_state(void *c)
+const char *nvme_ctrl_get_state(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return "";
 }
 
-void *nvme_ctrl_get_config(void *c)
+struct nvme_fabrics_config *nvme_ctrl_get_config(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
@@ -542,27 +542,27 @@ int nvme_ctrl_get_fd(void *c)
 	return -1;
 }
 
-void *nvme_ctrl_get_subsystem(void *c)
+nvme_subsystem_t nvme_ctrl_get_subsystem(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-void *nvme_ctrl_get_transport_handle(void *c)
+struct nvme_transport_handle *nvme_ctrl_get_transport_handle(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-void nvme_free_ctrl(void *c)
+void nvme_free_ctrl(struct nvme_ctrl *c)
 {
 	stub_log(__func__);
 	(void)c;
 }
 
-int nvme_disconnect_ctrl(void *c)
+int nvme_disconnect_ctrl(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
@@ -570,7 +570,7 @@ int nvme_disconnect_ctrl(void *c)
 	return -1;
 }
 
-void nvme_unlink_ctrl(void *c)
+void nvme_unlink_ctrl(struct nvme_ctrl *c)
 {
 	stub_log(__func__);
 	(void)c;
@@ -605,54 +605,54 @@ void *nvme_subsys_get_host(void *s)
 }
 
 /* Subsystem functions (full name) - same as subsys */
-const char *nvme_subsystem_get_name(void *s)
+const char *nvme_subsystem_get_name(nvme_subsystem_t s)
 {
 	return nvme_subsys_get_name(s);
 }
 
-const char *nvme_subsystem_get_nqn(void *s)
+const char *nvme_subsystem_get_nqn(nvme_subsystem_t s)
 {
 	return nvme_subsys_get_nqn(s);
 }
 
-const char *nvme_subsystem_get_sysfs_dir(void *s)
+const char *nvme_subsystem_get_sysfs_dir(nvme_subsystem_t s)
 {
 	return nvme_subsys_get_sysfs_dir(s);
 }
 
-void *nvme_subsystem_get_host(void *s)
+nvme_host_t nvme_subsystem_get_host(nvme_subsystem_t s)
 {
 	return nvme_subsys_get_host(s);
 }
 
-void *nvme_subsystem_first_ctrl(void *s)
+nvme_ctrl_t nvme_subsystem_first_ctrl(nvme_subsystem_t s)
 {
 	return nvme_first_ctrl(s);
 }
 
-void *nvme_subsystem_next_ctrl(void *s, void *c)
+nvme_ctrl_t nvme_subsystem_next_ctrl(nvme_subsystem_t s, nvme_ctrl_t c)
 {
 	return nvme_next_ctrl(s, c);
 }
 
-void *nvme_subsystem_first_ns(void *s)
+nvme_ns_t nvme_subsystem_first_ns(nvme_subsystem_t s)
 {
 	return nvme_subsys_first_ns(s);
 }
 
-void *nvme_subsystem_next_ns(void *s, void *ns)
+nvme_ns_t nvme_subsystem_next_ns(nvme_subsystem_t s, nvme_ns_t n)
 {
-	return nvme_subsys_next_ns(s, ns);
+	return nvme_subsys_next_ns(s, n);
 }
 
-const char *nvme_host_get_hostnqn(void *h)
+const char *nvme_host_get_hostnqn(nvme_host_t h)
 {
 	stub_log(__func__);
 	(void)h;
 	return "";
 }
 
-const char *nvme_host_get_hostid(void *h)
+const char *nvme_host_get_hostid(nvme_host_t h)
 {
 	stub_log(__func__);
 	(void)h;
@@ -666,97 +666,32 @@ void *nvme_host_get_root(void *h)
 	return NULL;
 }
 
-int nvme_dump_tree(void *r)
+int nvme_dump_tree(struct nvme_global_ctx *ctx)
 {
 	stub_log(__func__);
-	(void)r;
+	(void)ctx;
 	errno = ENOTSUP;
 	return -1;
 }
 
-int nvme_dump_config(void *r)
+int nvme_dump_config(struct nvme_global_ctx *ctx)
 {
 	stub_log(__func__);
-	(void)r;
+	(void)ctx;
 	errno = ENOTSUP;
 	return -1;
 }
 
-/*
- * Stub implementations for filter functions (filters.c)
- */
-
-void *nvme_for_each_host_safe(void *r, void *h)
-{
-	stub_log(__func__);
-	(void)r;
-	(void)h;
-	return NULL;
-}
-
-void *nvme_for_each_subsystem_safe(void *h, void *s)
-{
-	stub_log(__func__);
-	(void)h;
-	(void)s;
-	return NULL;
-}
-
-void *nvme_for_each_ctrl_safe(void *s, void *c)
-{
-	stub_log(__func__);
-	(void)s;
-	(void)c;
-	return NULL;
-}
-
-void *nvme_for_each_ns_safe(void *s, void *ns)
-{
-	stub_log(__func__);
-	(void)s;
-	(void)ns;
-	return NULL;
-}
-
-void *nvme_for_each_path_safe(void *c, void *p)
-{
-	stub_log(__func__);
-	(void)c;
-	(void)p;
-	return NULL;
-}
-
 /*
  * Stub implementations for MI functions (mi.c and mi-mctp.c)
  */
 
-int nvme_mi_admin_admin_passthru(void *hdl, __u8 opcode, __u8 flags,
-				 __u16 rsvd, __u32 nsid, __u32 cdw2, __u32 cdw3,
-				 __u32 cdw10, __u32 cdw11, __u32 cdw12,
-				 __u32 cdw13, __u32 cdw14, __u32 cdw15,
-				 __u32 data_len, void *data, __u32 metadata_len,
-				 void *metadata, __u32 timeout_ms, __u32 *result)
+int nvme_mi_admin_admin_passthru(struct nvme_transport_handle *hdl,
+				 struct nvme_passthru_cmd *cmd)
 {
 	stub_log(__func__);
 	(void)hdl;
-	(void)opcode;
-	(void)flags;
-	(void)rsvd;
-	(void)nsid;
-	(void)cdw2;
-	(void)cdw3;
-	(void)cdw10;
-	(void)cdw11;
-	(void)cdw12;
-	(void)cdw13;
-	(void)cdw14;
-	(void)cdw15;
-	(void)data_len;
-	(void)data;
-	(void)metadata_len;
-	(void)metadata;
-	(void)timeout_ms;
-	(void)result;
+	(void)cmd;
 	errno = ENOTSUP;
 	return -1;
 }
@@ -775,22 +710,22 @@ void nvme_mi_free_root(void *root)
 	(void)root;
 }
 
-void *nvme_mi_first_endpoint(void *root)
+nvme_mi_ep_t nvme_mi_first_endpoint(struct nvme_global_ctx *ctx)
 {
 	stub_log(__func__);
-	(void)root;
+	(void)ctx;
 	return NULL;
 }
 
-void *nvme_mi_next_endpoint(void *root, void *ep)
+nvme_mi_ep_t nvme_mi_next_endpoint(struct nvme_global_ctx *ctx, nvme_mi_ep_t e)
 {
 	stub_log(__func__);
-	(void)root;
-	(void)ep;
+	(void)ctx;
+	(void)e;
 	return NULL;
 }
 
-int nvme_mi_scan_ep(void *ep, int force_rescan)
+int nvme_mi_scan_ep(nvme_mi_ep_t ep, bool force_rescan)
 {
 	stub_log(__func__);
 	(void)ep;
@@ -814,7 +749,7 @@ void *nvme_mi_next_ctrl(void *ep, void *c)
 	return NULL;
 }
 
-void nvme_mi_close(void *ep)
+void nvme_mi_close(nvme_mi_ep_t ep)
 {
 	stub_log(__func__);
 	(void)ep;
@@ -889,7 +824,8 @@ int nvme_import_tls_key(const char *encoded_key, int *key_len,
  */
 
 /* Transport handle operations (linux.c) */
-int nvme_open(void *ctx, const char *name, void **hdlp)
+int nvme_open(struct nvme_global_ctx *ctx, const char *name,
+	      struct nvme_transport_handle **hdlp)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -899,7 +835,7 @@ int nvme_open(void *ctx, const char *name, void **hdlp)
 	return -1;
 }
 
-void nvme_close(void *hdl)
+void nvme_close(struct nvme_transport_handle *hdl)
 {
 	stub_log(__func__);
 	(void)hdl;
@@ -941,35 +877,35 @@ int nvme_transport_handle_is_direct(void *hdl)
 }
 
 /* Controller property getters (tree.c) */
-const char *nvme_ctrl_get_cntlid(void *c)
+const char *nvme_ctrl_get_cntlid(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return "";
 }
 
-const char *nvme_ctrl_get_firmware(void *c)
+const char *nvme_ctrl_get_firmware(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return "";
 }
 
-const char *nvme_ctrl_get_model(void *c)
+const char *nvme_ctrl_get_model(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return "";
 }
 
-const char *nvme_ctrl_get_phy_slot(void *c)
+const char *nvme_ctrl_get_phy_slot(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return "";
 }
 
-const char *nvme_ctrl_get_serial(void *c)
+const char *nvme_ctrl_get_serial(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
@@ -977,35 +913,35 @@ const char *nvme_ctrl_get_serial(void *c)
 }
 
 /* Subsystem property getters (tree.c) */
-const char *nvme_subsystem_get_fw_rev(void *s)
+const char *nvme_subsystem_get_fw_rev(nvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)s;
 	return "";
 }
 
-const char *nvme_subsystem_get_iopolicy(void *s)
+const char *nvme_subsystem_get_iopolicy(nvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)s;
 	return "";
 }
 
-const char *nvme_subsystem_get_model(void *s)
+const char *nvme_subsystem_get_model(nvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)s;
 	return "";
 }
 
-const char *nvme_subsystem_get_serial(void *s)
+const char *nvme_subsystem_get_serial(nvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)s;
 	return "";
 }
 
-const char *nvme_subsystem_get_type(void *s)
+const char *nvme_subsystem_get_type(nvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)s;
@@ -1013,43 +949,43 @@ const char *nvme_subsystem_get_type(void *s)
 }
 
 /* Namespace property getters (tree.c) */
-const char *nvme_ns_get_firmware(void *ns)
+const char *nvme_ns_get_firmware(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return "";
 }
 
-int nvme_ns_get_meta_size(void *ns)
+int nvme_ns_get_meta_size(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return 0;
 }
 
-const char *nvme_ns_get_model(void *ns)
+const char *nvme_ns_get_model(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return "";
 }
 
-const char *nvme_ns_get_serial(void *ns)
+const char *nvme_ns_get_serial(nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)ns;
+	(void)n;
 	return "";
 }
 
 /* Namespace path iteration (tree.c) */
-void *nvme_namespace_first_path(void *ns)
+nvme_path_t nvme_namespace_first_path(nvme_ns_t ns)
 {
 	stub_log(__func__);
 	(void)ns;
 	return NULL;
 }
 
-void *nvme_namespace_next_path(void *ns, void *p)
+nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p)
 {
 	stub_log(__func__);
 	(void)ns;

From a2dc5b2b4cc21adfa3a1f0b3172a12f9afaba91a Mon Sep 17 00:00:00 2001
From: Brandon Capener <bcapener@micron.com>
Date: Fri, 30 Jan 2026 16:33:19 -0700
Subject: [PATCH 11/83] Merge origin/master into mingw (#37)

* Merge origin/master into mingw

* add guards around the incoming upstream MIN macro
---
 .github/workflows/libnvme-release-python.yml |   16 +-
 .gitignore                                   |    4 +
 README.md                                    |    6 +
 fabrics.c                                    |  103 +-
 libnvme/examples/discover-loop.c             |    2 +-
 libnvme/libnvme/.gitignore                   |    4 -
 libnvme/libnvme/nvme.i                       |   30 +-
 libnvme/libnvme/tests/test-nbft.py           |    4 +-
 libnvme/scripts/release.sh                   |   20 +-
 libnvme/src/{libnvme.map => libnvme.ld}      |   27 +-
 libnvme/src/meson.build                      |    4 +-
 libnvme/src/nvme/fabrics.c                   |  214 ++-
 libnvme/src/nvme/fabrics.h                   |   20 +-
 libnvme/src/nvme/linux.c                     |  455 ++---
 libnvme/src/nvme/linux.h                     |  130 +-
 libnvme/src/nvme/log.c                       |   61 +-
 libnvme/src/nvme/log.h                       |   43 +-
 libnvme/src/nvme/nbft.c                      |  386 ++--
 libnvme/src/nvme/nbft.h                      |    7 +-
 libnvme/src/nvme/private.h                   |   26 +-
 libnvme/src/nvme/tree.c                      |  149 +-
 libnvme/src/nvme/tree.h                      |  108 +-
 libnvme/test/config/config-diff.sh           |   22 +-
 libnvme/test/config/config-dump.c            |    2 +-
 libnvme/test/config/psk-json.c               |   10 +-
 libnvme/test/ioctl/discovery.c               |    7 +-
 libnvme/test/ioctl/mock.c                    |    3 +-
 libnvme/test/meson.build                     |    2 +-
 libnvme/test/nbft/nbft-dump.c                |   15 +-
 libnvme/test/psk.c                           |   62 +-
 libnvme/test/sysfs/meson.build               |    2 +-
 libnvme/test/sysfs/tree-diff.sh              |   21 +-
 libnvme/test/tree.c                          |   47 +-
 meson.build                                  |  156 +-
 meson_options.txt                            |    6 +
 nvme-print-json.c                            |    4 +-
 nvme-print-stdout.c                          |   40 +-
 nvme-print.c                                 |   30 +
 nvme-print.h                                 |    5 +
 nvme.c                                       | 1694 +++++++++---------
 plugins/nbft/nbft-plugin.c                   |   14 +-
 plugins/ocp/ocp-print-json.c                 |    8 +
 plugins/ocp/ocp-print-stdout.c               |    8 +
 plugins/ocp/ocp-smart-extended-log.h         |    8 +-
 plugins/sandisk/sandisk-utils.c              |    2 +-
 plugins/solidigm/solidigm-get-drive-info.c   |    3 +-
 plugins/solidigm/solidigm-nvme.h             |    2 +-
 plugins/solidigm/solidigm-telemetry.c        |   69 +-
 plugins/solidigm/solidigm-telemetry/config.c |   29 +-
 plugins/wdc/wdc-nvme.c                       |    2 +-
 pyproject.toml                               |   13 +-
 51 files changed, 2199 insertions(+), 1906 deletions(-)
 delete mode 100644 libnvme/libnvme/.gitignore
 rename libnvme/src/{libnvme.map => libnvme.ld} (97%)

diff --git a/.github/workflows/libnvme-release-python.yml b/.github/workflows/libnvme-release-python.yml
index 8ee388517c..40e0a25813 100644
--- a/.github/workflows/libnvme-release-python.yml
+++ b/.github/workflows/libnvme-release-python.yml
@@ -57,6 +57,11 @@ jobs:
         run: |
           git config --global --add safe.directory "$GITHUB_WORKSPACE"
 
+      - name: Configure git identity for CI
+        run: |
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+
       - name: Compute dev version from git
         id: version
         run: |
@@ -68,8 +73,17 @@ jobs:
           echo "Computed dev version: $VERSION"
 
       - name: Patch project version in meson.build
+        env:
+          DEV_VERSION: ${{ steps.version.outputs.dev_version }}
+        run: |
+          sed -i -e "/^project(/,/)/ s/^\(\s*\)version:\s*.*/\1version: '${DEV_VERSION}',/" meson.build
+
+      - name: Commit CI version bump
+        env:
+          DEV_VERSION: ${{ steps.version.outputs.dev_version }}
         run: |
-          sed -i -e "/^project(/,/)/ s/^\(\s*\)version:\s*.*/\1version: '${{ steps.version.outputs.dev_version }}',/" meson.build
+          git add meson.build
+          git commit -m "ci: set project version to ${DEV_VERSION}"
 
       - name: Build sdist
         run: |
diff --git a/.gitignore b/.gitignore
index 9f50b93cde..5ce3d1fbe6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,4 +18,8 @@ tests/*.pyc
 .build
 .build-ci
 .cache
+
+# Ignore PyPI build artifacts
+dist/
+
 .vscode/
diff --git a/README.md b/README.md
index fd35d42cba..d0ca16747f 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,12 @@
 ![Coverity Scan Build Status](https://scan.coverity.com/projects/24883/badge.svg)
 ![MesonBuild](https://github.com/linux-nvme/nvme-cli/actions/workflows/build.yml/badge.svg)
 ![GitHub](https://img.shields.io/github/license/linux-nvme/nvme-cli)
+![GitHub](https://img.shields.io/github/license/linux-nvme/libnvme)
+![PyBuild](https://github.com/linux-nvme/nvme-cli/actions/workflows/libnvme-release-python.yml/badge.svg)
+[![PyPI](https://img.shields.io/pypi/v/libnvme)](https://pypi.org/project/libnvme/)
+[![PyPI - Wheel](https://img.shields.io/pypi/wheel/libnvme)](https://pypi.org/project/libnvme/)
+[![codecov](https://codecov.io/gh/linux-nvme/nvme-cli/branch/master/graph/badge.svg)](https://codecov.io/gh/linux-nvme/nvme-cli)
+[![Read the libnvme Docs](https://img.shields.io/readthedocs/libnvme)](https://libnvme.readthedocs.io/en/latest/)
 
 NVM-Express user space tooling for Linux.
 
diff --git a/fabrics.c b/fabrics.c
index 6c846e7a14..9a1f0a0e98 100644
--- a/fabrics.c
+++ b/fabrics.c
@@ -579,39 +579,11 @@ int fabrics_discovery(const char *desc, int argc, char **argv, bool connect)
 
 out_free:
 	if (dump_config)
-		nvme_dump_config(ctx);
+		nvme_dump_config(ctx, NULL);
 
 	return ret;
 }
 
-static void nvme_parse_tls_args(const char *keyring, const char *tls_key,
-				const char *tls_key_identity,
-				struct nvme_fabrics_config *cfg, nvme_ctrl_t c)
-{
-	if (keyring) {
-		char *endptr;
-		long id = strtol(keyring, &endptr, 0);
-
-		if (endptr != keyring)
-			cfg->keyring = id;
-		else
-			nvme_ctrl_set_keyring(c, keyring);
-	}
-
-	if (tls_key_identity)
-		nvme_ctrl_set_tls_key_identity(c, tls_key_identity);
-
-	if (tls_key) {
-		char *endptr;
-		long id = strtol(tls_key, &endptr, 0);
-
-		if (endptr != tls_key)
-			cfg->tls_key = id;
-		else
-			nvme_ctrl_set_tls_key(c, tls_key);
-	}
-}
-
 int fabrics_connect(const char *desc, int argc, char **argv)
 {
 	_cleanup_free_ char *hnqn = NULL;
@@ -708,13 +680,13 @@ int fabrics_connect(const char *desc, int argc, char **argv)
 
 	ret = nvmf_connect(ctx, fctx);
 	if (ret) {
-		fprintf(stderr, "failed to connected: %s\n",
-			nvme_strerror(ret));
+		fprintf(stderr, "failed to connect: %s\n",
+			nvme_strerror(-ret));
 		return ret;
 	}
 
 	if (dump_config)
-		nvme_dump_config(ctx);
+		nvme_dump_config(ctx, NULL);
 
 	return 0;
 }
@@ -924,24 +896,15 @@ int fabrics_disconnect_all(const char *desc, int argc, char **argv)
 
 int fabrics_config(const char *desc, int argc, char **argv)
 {
-	char *subsysnqn = NULL;
-	char *transport = NULL, *traddr = NULL;
-	char *trsvcid = NULL, *hostnqn = NULL, *hostid = NULL;
-	char *host_traddr = NULL, *host_iface = NULL;
-	_cleanup_free_ char *hnqn = NULL;
-	_cleanup_free_ char *hid = NULL;
-	char *hostkey = NULL, *ctrlkey = NULL;
-	char *keyring = NULL, *tls_key = NULL, *tls_key_identity = NULL;
-	char *config_file = PATH_NVMF_CONFIG;
-	unsigned int verbose = 0;
+	bool scan_tree = false, modify_config = false, update_config = false;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
-	int ret;
+	char *config_file = PATH_NVMF_CONFIG;
 	struct nvme_fabrics_config cfg;
 	struct fabric_args fa = { };
-	bool scan_tree = false, modify_config = false, update_config = false;
+	unsigned int verbose = 0;
+	int ret;
 
 	NVMF_ARGS(opts, fa, cfg,
-		  OPT_STRING("dhchap-ctrl-secret", 'C', "STR", &ctrlkey,      nvmf_ctrlkey),
 		  OPT_STRING("config",             'J', "FILE", &config_file, nvmf_config_file),
 		  OPT_INCR("verbose",              'v', &verbose,             "Increase logging verbosity"),
 		  OPT_FLAG("scan",                 'R', &scan_tree,           "Scan current NVMeoF topology"),
@@ -980,59 +943,37 @@ int fabrics_config(const char *desc, int argc, char **argv)
 	}
 
 	if (modify_config) {
-		nvme_host_t h;
-		nvme_subsystem_t s;
-		nvme_ctrl_t c;
+		_cleanup_free_ struct nvmf_context *fctx = NULL;
 
-		if (!subsysnqn) {
+		if (!fa.subsysnqn) {
 			fprintf(stderr,
 				"required argument [--nqn | -n] needed with --modify\n");
 			return -EINVAL;
 		}
 
-		if (!transport) {
+		if (!fa.transport) {
 			fprintf(stderr,
 				"required argument [--transport | -t] needed with --modify\n");
 			return -EINVAL;
 		}
 
-		if (!hostnqn)
-			hostnqn = hnqn = nvmf_hostnqn_from_file();
-		if (!hostid && hnqn)
-			hostid = hid = nvmf_hostid_from_file();
-		h = nvme_lookup_host(ctx, hostnqn, hostid);
-		if (!h) {
-			fprintf(stderr, "Failed to lookup host '%s'\n",
-				hostnqn);
-			return -ENODEV;
-		}
-		if (hostkey)
-			nvme_host_set_dhchap_key(h, hostkey);
-		s = nvme_lookup_subsystem(h, NULL, subsysnqn);
-		if (!s) {
-			fprintf(stderr, "Failed to lookup subsystem '%s'\n",
-				subsysnqn);
-			return -ENODEV;
-		}
-		c = nvme_lookup_ctrl(s, transport, traddr,
-				     host_traddr, host_iface,
-				     trsvcid, NULL);
-		if (!c) {
-			fprintf(stderr, "Failed to lookup controller\n");
-			return -ENODEV;
-		}
-		if (ctrlkey)
-			nvme_ctrl_set_dhchap_key(c, ctrlkey);
-		nvme_parse_tls_args(keyring, tls_key, tls_key_identity, &cfg, c);
+		ret = create_common_context(ctx, persistent, &fa,
+			&cfg, NULL, &fctx);
+		if (ret)
+			return ret;
 
-		nvmf_update_config(c, &cfg);
+		ret = nvmf_config_modify(ctx, fctx);
+		if (ret) {
+			fprintf(stderr, "failed to update config\n");
+			return ret;
+		}
 	}
 
 	if (update_config)
-		nvme_update_config(ctx);
+		nvme_dump_config(ctx, config_file);
 
 	if (dump_config)
-		nvme_dump_config(ctx);
+		nvme_dump_config(ctx, NULL);
 
 	return 0;
 }
diff --git a/libnvme/examples/discover-loop.c b/libnvme/examples/discover-loop.c
index c3aa7c0cb1..367507d9d2 100644
--- a/libnvme/examples/discover-loop.c
+++ b/libnvme/examples/discover-loop.c
@@ -62,7 +62,7 @@ int main()
 	ret = nvme_scan(NULL, &ctx);
 	if (ret)
 		return ret;
-	ret = nvme_default_host(ctx, &h);
+	ret = nvme_host_get(ctx, NULL, NULL, &h);
 	if (ret) {
 		fprintf(stderr, "Failed to allocated memory\n");
 		return ret;
diff --git a/libnvme/libnvme/.gitignore b/libnvme/libnvme/.gitignore
deleted file mode 100644
index e943f50cdf..0000000000
--- a/libnvme/libnvme/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-build/
-__pycache__/
-nvme.py
-nvme_wrap.c
diff --git a/libnvme/libnvme/nvme.i b/libnvme/libnvme/nvme.i
index 2cca7d6565..a8851edf86 100644
--- a/libnvme/libnvme/nvme.i
+++ b/libnvme/libnvme/nvme.i
@@ -528,11 +528,8 @@ struct nvme_ns {
 	void refresh_topology() {
 		nvme_refresh_topology($self);
 	}
-	void update_config() {
-		nvme_update_config($self);
-	}
 	void dump_config() {
-		nvme_dump_config($self);
+		nvme_dump_config($self, NULL);
 	}
 }
 
@@ -559,9 +556,7 @@ struct nvme_ns {
 		  const char *hostkey = NULL,
 		  const char *hostsymname = NULL) {
 		nvme_host_t h;
-		if (hostnqn)
-			h = nvme_lookup_host(ctx, hostnqn, hostid);
-		if (nvme_default_host(ctx, &h))
+		if (nvme_host_get(ctx, hostnqn, hostid, &h))
 			return NULL;
 		if (hostsymname)
 			nvme_host_set_hostsymname(h, hostsymname);
@@ -605,15 +600,22 @@ struct nvme_ns {
 	}
 %};
 
-%pythonappend nvme_subsystem::nvme_subsystem(struct nvme_host *host,
+%pythonappend nvme_subsystem::nvme_subsystem(struct nvme_global_ctx *ctx,
+					     struct nvme_host *host,
 					     const char *subsysnqn,
 					     const char *name) {
     self.__parent = host  # Keep a reference to parent to ensure garbage collection happens in the right order}
 %extend nvme_subsystem {
-	nvme_subsystem(struct nvme_host *host,
+	nvme_subsystem(struct nvme_global_ctx *ctx,
+		       struct nvme_host *host,
 		       const char *subsysnqn,
 		       const char *name = NULL) {
-		return nvme_lookup_subsystem(host, name, subsysnqn);
+		struct nvme_subsystem *s;
+
+		if (nvme_subsystem_get(ctx, host, name, subsysnqn, &s))
+			return NULL;
+
+		return s;
 	}
 	~nvme_subsystem() {
 		nvme_free_subsystem($self);
@@ -1236,26 +1238,26 @@ struct nvme_ns {
 		return output;
 	}
 
-	PyObject *nbft_get(const char * filename)
+	PyObject *nbft_get(struct nvme_global_ctx *ctx, const char * filename)
 	{
 		struct nbft_info *nbft;
 		PyObject *output;
 		int ret;
 
-		ret = nvme_nbft_read(&nbft, filename);
+		ret = nvme_nbft_read(ctx, &nbft, filename);
 		if (ret) {
 			Py_RETURN_NONE;
 		}
 
 		output = nbft_to_pydict(nbft);
-		nvme_nbft_free(nbft);
+		nvme_nbft_free(ctx, nbft);
 		return output;
 	}
 %};
 
 %feature("autodoc", "@return an NBFT table as a dict on success, None otherwise.\n"
 		    "@param filename: file to read") nbft_get;
-PyObject *nbft_get(const char * filename);
+PyObject *nbft_get(struct nvme_global_ctx *ctx, const char * filename);
 
 // We want to swig all the #define and enum from types.h, but none of the structs.
 #pragma SWIG nowarn=503             // Supress warnings about unnamed struct
diff --git a/libnvme/libnvme/tests/test-nbft.py b/libnvme/libnvme/tests/test-nbft.py
index 3aeeba453a..aa96745391 100755
--- a/libnvme/libnvme/tests/test-nbft.py
+++ b/libnvme/libnvme/tests/test-nbft.py
@@ -77,7 +77,9 @@ def setUp(self):
 
     def test_read_nbft_file(self):
         """Make sure we get expected data when reading from binary NBFT file"""
-        actual_nbft = nvme.nbft_get(args.filename)
+        ctx = nvme.global_ctx()
+        ctx.log_level('debug')
+        actual_nbft = nvme.nbft_get(ctx, args.filename)
         self.assertEqual(actual_nbft, self.expected_nbft)
 
 
diff --git a/libnvme/scripts/release.sh b/libnvme/scripts/release.sh
index 0323ee536d..20b33720b3 100755
--- a/libnvme/scripts/release.sh
+++ b/libnvme/scripts/release.sh
@@ -132,18 +132,18 @@ if [ "$build_doc" = true ]; then
     git commit -s -m "doc: Regenerate all docs for $VERSION"
 fi
 
-declare -A maps
-maps=(
-    [src/libnvme.map]=LIBNVME
+declare -A ldscripts
+ldscripts=(
+    [src/libnvme.ld]=LIBNVME
 )
 
 lib_ver="${ver//./_}"
 
-for map_file in "${!maps[@]}"
+for ld_file in "${!ldscripts[@]}"
 do
-    lib_name=${maps[$map_file]}
+    lib_name=${ldscripts[$ld_file]}
 
-    if [ ! -f "${map_file}" ]; then
+    if [ ! -f "${ld_file}" ]; then
        continue
     fi
 
@@ -155,16 +155,16 @@ do
         in_section && $0 ~ /\}/ { exit }
         in_section && $0 !~ /^[[:space:]]*($|\/|\/\*|\*|#)/ { found = 1; exit }
         END { exit !found }
-    ' "${map_file}"; then
+    ' "${ld_file}"; then
         continue
     fi
 
     sed -i \
         -e "s/^${lib_unreleased}\s*{/&\n};\n\n${lib_name}_${lib_ver} {/" \
-        "$map_file"
+        "$ld_file"
 
-    git add "${map_file}"
-    echo "${map_file} updated."
+    git add "${ld_file}"
+    echo "${ld_file} updated."
 done
 
 # update meson.build
diff --git a/libnvme/src/libnvme.map b/libnvme/src/libnvme.ld
similarity index 97%
rename from libnvme/src/libnvme.map
rename to libnvme/src/libnvme.ld
index 4054de184f..ce97672ee0 100644
--- a/libnvme/src/libnvme.map
+++ b/libnvme/src/libnvme.ld
@@ -2,22 +2,13 @@
 LIBNVME_UNRELEASED {
 };
 
-LIBNVME_1_16 {
-	global:
-		nvme_get_uuid_list;
-		nvme_set_etdas;
-		nvme_clear_etdas;
-		nvme_insert_tls_key_compat;
-		nvme_generate_tls_key_identity_compat;
-};
-
 LIBNVME_2_0 {
 	global:
+		nvme_clear_etdas;
 		nvme_close;
 		nvme_create_ctrl;
 		nvme_create_global_ctx;
 		nvme_ctrl_config_match;
-		nvme_ctrl_find;
 		nvme_ctrl_first_ns;
 		nvme_ctrl_first_path;
 		nvme_ctrl_get_address;
@@ -64,7 +55,6 @@ LIBNVME_2_0 {
 		nvme_ctrl_set_tls_key_identity;
 		nvme_ctrl_set_unique_discovery_ctrl;
 		nvme_ctrls_filter;
-		nvme_default_host;
 		nvme_describe_key_serial;
 		nvme_disconnect_ctrl;
 		nvme_dump_config;
@@ -83,6 +73,7 @@ LIBNVME_2_0 {
 		nvme_fw_download_seq;
 		nvme_gen_dhchap_key;
 		nvme_generate_tls_key_identity;
+		nvme_generate_tls_key_identity_compat;
 		nvme_get_ana_log_atomic;
 		nvme_get_ana_log_len;
 		nvme_get_ana_log_len_from_id_ctrl;
@@ -90,12 +81,10 @@ LIBNVME_2_0 {
 		nvme_get_attr;
 		nvme_get_ctrl_attr;
 		nvme_get_ctrl_telemetry;
-		nvme_get_debug;
 		nvme_get_directive_receive_length;
 		nvme_get_feature_length;
 		nvme_get_host_telemetry;
 		nvme_get_log;
-		nvme_get_logging_level;
 		nvme_get_logical_block_size;
 		nvme_get_new_host_telemetry;
 		nvme_get_ns_attr;
@@ -105,7 +94,9 @@ LIBNVME_2_0 {
 		nvme_get_subsys_attr;
 		nvme_get_telemetry_log;
 		nvme_get_telemetry_max;
+		nvme_get_uuid_list;
 		nvme_get_version;
+		nvme_host_get;
 		nvme_host_get_dhchap_key;
 		nvme_host_get_global_ctx;
 		nvme_host_get_hostid;
@@ -125,17 +116,14 @@ LIBNVME_2_0 {
 		nvme_init_copy_range_f3;
 		nvme_init_ctrl;
 		nvme_init_ctrl_list;
-		nvme_init_default_logging;
 		nvme_init_dsm_range;
 		nvme_init_logging;
 		nvme_insert_tls_key;
+		nvme_insert_tls_key_compat;
 		nvme_insert_tls_key_versioned;
 		nvme_ipaddrs_eq;
-		nvme_lookup_ctrl;
-		nvme_lookup_host;
 		nvme_lookup_key;
 		nvme_lookup_keyring;
-		nvme_lookup_subsystem;
 		nvme_mi_admin_admin_passthru;
 		nvme_mi_admin_xfer;
 		nvme_mi_aem_disable;
@@ -239,8 +227,8 @@ LIBNVME_2_0 {
 		nvme_scan_tls_keys;
 		nvme_scan_topology;
 		nvme_set_application;
-		nvme_set_debug;
 		nvme_set_dry_run;
+		nvme_set_etdas;
 		nvme_set_keyring;
 		nvme_set_property;
 		nvme_set_root;
@@ -253,6 +241,7 @@ LIBNVME_2_0 {
 		nvme_subsys_filter;
 		nvme_subsystem_first_ctrl;
 		nvme_subsystem_first_ns;
+		nvme_subsystem_get;
 		nvme_subsystem_get_application;
 		nvme_subsystem_get_fw_rev;
 		nvme_subsystem_get_host;
@@ -279,7 +268,6 @@ LIBNVME_2_0 {
 		nvme_transport_handle_set_submit_entry;
 		nvme_transport_handle_set_submit_exit;
 		nvme_unlink_ctrl;
-		nvme_update_config;
 		nvme_update_key;
 		nvme_uuid_find;
 		nvme_uuid_from_string;
@@ -288,6 +276,7 @@ LIBNVME_2_0 {
 		nvmf_add_ctrl;
 		nvmf_adrfam_str;
 		nvmf_cms_str;
+		nvmf_config_modify;
 		nvmf_connect;
 		nvmf_connect_config_json;
 		nvmf_connect_ctrl;
diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index 760a46a387..fe8eb9af87 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -69,10 +69,10 @@ if is_windows
     ]
 endif
 
-mapfile = 'libnvme.map'
+ldfile = 'libnvme.ld'
 
 libnvme_link_args = [
-    '-Wl,--version-script=@0@'.format(meson.current_source_dir() / mapfile),
+    '-Wl,--version-script=@0@'.format(meson.current_source_dir() / ldfile),
 ]
 # Skipping accessor generation for now on Windows. Needs to be ported.
 if not is_windows
diff --git a/libnvme/src/nvme/fabrics.c b/libnvme/src/nvme/fabrics.c
index 2ae3eaa040..4e47a0d54f 100644
--- a/libnvme/src/nvme/fabrics.c
+++ b/libnvme/src/nvme/fabrics.c
@@ -727,8 +727,24 @@ static int build_options(nvme_host_t h, nvme_ctrl_t c, char **argstr)
 
 	ctrlkey = nvme_ctrl_get_dhchap_key(c);
 
+	if (cfg->tls && cfg->concat) {
+		nvme_msg(h->ctx, LOG_ERR, "cannot specify --tls and --concat together\n");
+		return -ENVME_CONNECT_INVAL;
+	}
+
+	if (cfg->concat && !hostkey) {
+		nvme_msg(h->ctx, LOG_ERR, "required argument [--dhchap-secret | -S] not specified with --concat\n");
+		return -ENVME_CONNECT_INVAL;
+	}
+
+	if (cfg->concat && ctrlkey) {
+		nvme_msg(h->ctx, LOG_ERR, "cannot specify [--dhchap-ctrl-secret | -C] with --concat\n");
+		return -ENVME_CONNECT_INVAL;
+	}
+
 	if (cfg->tls) {
-		ret = __nvme_import_keys_from_config(h, c, &keyring_id, &key_id);
+		ret = __nvme_import_keys_from_config(h, c,
+			&keyring_id, &key_id);
 		if (ret)
 			return ret;
 
@@ -1188,8 +1204,17 @@ static int nvmf_connect_disc_entry(nvme_host_t h,
 		c->cfg.disable_sqflow = true;
 
 	if (e->trtype == NVMF_TRTYPE_TCP &&
-	    e->tsas.tcp.sectype != NVMF_TCP_SECTYPE_NONE)
-		c->cfg.tls = true;
+	    e->tsas.tcp.sectype != NVMF_TCP_SECTYPE_NONE) {
+		if (e->treq & NVMF_TREQ_REQUIRED) {
+			nvme_msg(h->ctx, LOG_DEBUG, "setting --tls due to treq %s and sectype %s\n",
+					nvmf_treq_str(e->treq), nvmf_sectype_str(e->tsas.tcp.sectype));
+			c->cfg.tls = true;
+		} else if (e->treq & NVMF_TREQ_NOT_REQUIRED) {
+			nvme_msg(h->ctx, LOG_DEBUG, "setting --concat due to treq %s and sectype %s\n",
+					nvmf_treq_str(e->treq), nvmf_sectype_str(e->tsas.tcp.sectype));
+			c->cfg.concat = true;
+		}
+	}
 
 	ret = nvmf_add_ctrl(h, c, cfg);
 	if (!ret) {
@@ -1222,7 +1247,7 @@ static int nvmf_connect_disc_entry(nvme_host_t h,
 static int nvme_discovery_log(const struct nvme_get_discovery_args *args,
 			      struct nvmf_discovery_log **logp)
 {
-	struct nvme_global_ctx *ctx = ctx_from_ctrl(args->c);
+	struct nvme_global_ctx *ctx = args->c->ctx;
 	struct nvmf_discovery_log *log;
 	int retries = 0;
 	int err;
@@ -2091,6 +2116,35 @@ static int set_discovery_kato(struct nvmf_context *fctx,
 	return tmo;
 }
 
+static void nvme_parse_tls_args(const char *keyring, const char *tls_key,
+				const char *tls_key_identity,
+				struct nvme_fabrics_config *cfg, nvme_ctrl_t c)
+{
+	if (keyring) {
+		char *endptr;
+		long id = strtol(keyring, &endptr, 0);
+
+		if (endptr != keyring)
+			cfg->keyring = id;
+		else
+			nvme_ctrl_set_keyring(c, keyring);
+	}
+
+	if (tls_key_identity)
+		nvme_ctrl_set_tls_key_identity(c, tls_key_identity);
+
+	if (tls_key) {
+		char *endptr;
+		long id = strtol(tls_key, &endptr, 0);
+
+		if (endptr != tls_key)
+			cfg->tls_key = id;
+		else
+			nvme_ctrl_set_tls_key(c, tls_key);
+	}
+}
+
+
 static int _nvmf_discovery(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx, bool connect,
 		struct nvme_ctrl *c)
@@ -2136,9 +2190,9 @@ static int _nvmf_discovery(struct nvme_global_ctx *ctx,
 			.subsysnqn	= e->subnqn,
 			.transport	= nvmf_trtype_str(e->trtype),
 			.traddr		= e->traddr,
+			.trsvcid	= e->trsvcid,
 			.host_traddr	= fctx->host_traddr,
 			.host_iface	= fctx->host_iface,
-			.trsvcid	= e->trsvcid,
 		};
 
 		/* Already connected ? */
@@ -2308,6 +2362,12 @@ static int nvmf_create_discovery_ctrl(struct nvme_global_ctx *ctx,
 		return -ENOMEM;
 	}
 
+	ret = nvme_open(ctx, c->name, &c->hdl);
+	if (ret) {
+		nvme_msg(ctx, LOG_ERR, "failed to open %s\n", c->name);
+		return ret;
+	}
+
 	/* Find out the name of discovery controller */
 	ret = nvme_ctrl_identify(c, id);
 	if (ret)  {
@@ -2395,12 +2455,12 @@ int _discovery_config_json(struct nvme_global_ctx *ctx,
 	memcpy(&cfg, fctx->cfg, sizeof(cfg));
 
 	struct fabric_args trcfg = {
-		.subsysnqn = subsysnqn,
-		.transport = transport,
-		.traddr = traddr,
-		.host_traddr = host_traddr,
-		.host_iface = host_iface,
-		.trsvcid = trsvcid,
+		.subsysnqn	= subsysnqn,
+		.transport	= transport,
+		.traddr		= traddr,
+		.trsvcid	= trsvcid,
+		.host_traddr	= host_traddr,
+		.host_iface	= host_iface,
 	};
 
 	if (!force) {
@@ -2556,12 +2616,12 @@ int nvmf_discovery_config_file(struct nvme_global_ctx *ctx,
 			break;
 
 		struct fabric_args trcfg = {
-			.transport = fctx->transport,
-			.traddr = fctx->traddr,
-			.trsvcid = fctx->trsvcid,
-			.subsysnqn = fctx->subsysnqn,
-			.host_traddr = fctx->host_traddr,
-			.host_iface = fctx->host_iface,
+			.subsysnqn	= fctx->subsysnqn,
+			.transport	= fctx->transport,
+			.traddr		= fctx->traddr,
+			.trsvcid	= fctx->trsvcid,
+			.host_traddr	= fctx->host_traddr,
+			.host_iface	= fctx->host_iface,
 		};
 
 		if (!force) {
@@ -2591,6 +2651,56 @@ int nvmf_discovery_config_file(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
+int nvmf_config_modify(struct nvme_global_ctx *ctx,
+		struct nvmf_context *fctx)
+{
+	_cleanup_free_ char *hnqn = NULL;
+	_cleanup_free_ char *hid = NULL;
+	struct nvme_host *h;
+	struct nvme_subsystem *s;
+	struct nvme_ctrl *c;
+
+	if (!fctx->hostnqn)
+		fctx->hostnqn = hnqn = nvmf_hostnqn_from_file();
+	if (!fctx->hostid && hnqn)
+		fctx->hostid = hid = nvmf_hostid_from_file();
+
+	h = nvme_lookup_host(ctx, fctx->hostnqn, fctx->hostid);
+	if (!h) {
+		nvme_msg(ctx, LOG_ERR, "Failed to lookup host '%s'\n",
+			fctx->hostnqn);
+		return -ENODEV;
+	}
+
+	if (fctx->hostkey)
+		nvme_host_set_dhchap_key(h, fctx->hostkey);
+
+	s = nvme_lookup_subsystem(h, NULL, fctx->subsysnqn);
+	if (!s) {
+		nvme_msg(ctx, LOG_ERR, "Failed to lookup subsystem '%s'\n",
+			fctx->subsysnqn);
+		return -ENODEV;
+	}
+
+	c = nvme_lookup_ctrl(s, fctx->transport, fctx->traddr,
+			     fctx->host_traddr, fctx->host_iface,
+			     fctx->trsvcid, NULL);
+	if (!c) {
+		nvme_msg(ctx, LOG_ERR, "Failed to lookup controller\n");
+		return -ENODEV;
+	}
+
+	if (fctx->ctrlkey)
+		nvme_ctrl_set_dhchap_key(c, fctx->ctrlkey);
+
+	nvme_parse_tls_args(fctx->keyring, fctx->tls_key,
+			    fctx->tls_key_identity, fctx->cfg, c);
+
+	nvmf_update_config(c, fctx->cfg);
+
+	return 0;
+}
+
 #define NBFT_SYSFS_FILENAME	"NBFT*"
 
 static int nbft_filter(const struct dirent *dent)
@@ -2598,7 +2708,8 @@ static int nbft_filter(const struct dirent *dent)
 	return !fnmatch(NBFT_SYSFS_FILENAME, dent->d_name, FNM_PATHNAME);
 }
 
-int nvmf_nbft_read_files(char *path, struct nbft_file_entry **head)
+int nvmf_nbft_read_files(struct nvme_global_ctx *ctx, char *path,
+		struct nbft_file_entry **head)
 {
 	struct nbft_file_entry *entry = NULL;
 	struct nbft_info *nbft;
@@ -2614,7 +2725,7 @@ int nvmf_nbft_read_files(char *path, struct nbft_file_entry **head)
 		snprintf(filename, sizeof(filename), "%s/%s", path,
 			dent[i]->d_name);
 
-		ret = nvme_nbft_read(&nbft, filename);
+		ret = nvme_nbft_read(ctx, &nbft, filename);
 		if (!ret) {
 			struct nbft_file_entry *new;
 
@@ -2636,12 +2747,12 @@ int nvmf_nbft_read_files(char *path, struct nbft_file_entry **head)
 	return 0;
 }
 
-void nvmf_nbft_free(struct nbft_file_entry *head)
+void nvmf_nbft_free(struct nvme_global_ctx *ctx, struct nbft_file_entry *head)
 {
 	while (head) {
 		struct nbft_file_entry *next = head->next;
 
-		nvme_nbft_free(head->nbft);
+		nvme_nbft_free(ctx, head->nbft);
 		free(head);
 
 		head = next;
@@ -2866,7 +2977,7 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 		/* TODO: print discovery-type info from NBFT tables */
 		return 0;
 
-	ret = nvmf_nbft_read_files(nbft_path, &entry);
+	ret = nvmf_nbft_read_files(ctx, nbft_path, &entry);
 	if (ret) {
 		if (ret != -ENOENT)
 			nvme_msg(ctx, LOG_ERR,
@@ -2924,9 +3035,9 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 					.subsysnqn	= (*ss)->subsys_nqn,
 					.transport	= (*ss)->transport,
 					.traddr		= (*ss)->traddr,
+					.trsvcid	= (*ss)->trsvcid,
 					.host_traddr	= host_traddr,
 					.host_iface	= NULL,
-					.trsvcid	= (*ss)->trsvcid,
 				};
 
 				rr = nbft_connect(ctx, fctx, h, NULL,
@@ -3014,9 +3125,9 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 				.subsysnqn	= NVME_DISC_SUBSYS_NAME,
 				.transport	= uri->protocol,
 				.traddr		= uri->host,
+				.trsvcid	= trsvcid,
 				.host_traddr	= host_traddr,
 				.host_iface	= NULL,
-				.trsvcid	= trsvcid,
 			};
 
 			/* Lookup existing discovery controller */
@@ -3056,7 +3167,7 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 		}
 	}
 out_free:
-	nvmf_nbft_free(entry);
+	nvmf_nbft_free(ctx, entry);
 	return ret;
 }
 
@@ -3219,12 +3330,12 @@ int nvmf_discovery(struct nvme_global_ctx *ctx, struct nvmf_context *fctx,
 	}
 
 	struct fabric_args trcfg = {
-		.subsysnqn = fctx->subsysnqn,
-		.transport = fctx->transport,
-		.traddr = fctx->traddr,
-		.host_traddr = fctx->host_traddr,
-		.host_iface = fctx->host_iface,
-		.trsvcid = fctx->trsvcid,
+		.subsysnqn	= fctx->subsysnqn,
+		.transport	= fctx->transport,
+		.traddr		= fctx->traddr,
+		.trsvcid	= fctx->trsvcid,
+		.host_traddr	= fctx->host_traddr,
+		.host_iface	= fctx->host_iface,
 	};
 
 	if (!c && !force) {
@@ -3253,34 +3364,6 @@ int nvmf_discovery(struct nvme_global_ctx *ctx, struct nvmf_context *fctx,
 	return ret;
 }
 
-static void nvme_parse_tls_args(const char *keyring, const char *tls_key,
-				const char *tls_key_identity,
-				struct nvme_fabrics_config *cfg, nvme_ctrl_t c)
-{
-	if (keyring) {
-		char *endptr;
-		long id = strtol(keyring, &endptr, 0);
-
-		if (endptr != keyring)
-			cfg->keyring = id;
-		else
-			nvme_ctrl_set_keyring(c, keyring);
-	}
-
-	if (tls_key_identity)
-		nvme_ctrl_set_tls_key_identity(c, tls_key_identity);
-
-	if (tls_key) {
-		char *endptr;
-		long id = strtol(tls_key, &endptr, 0);
-
-		if (endptr != tls_key)
-			cfg->tls_key = id;
-		else
-			nvme_ctrl_set_tls_key(c, tls_key);
-	}
-}
-
 int nvmf_connect(struct nvme_global_ctx *ctx, struct nvmf_context *fctx)
 {
 	struct nvme_host *h;
@@ -3296,12 +3379,12 @@ int nvmf_connect(struct nvme_global_ctx *ctx, struct nvmf_context *fctx)
 		return err;
 
 	struct fabric_args trcfg = {
-		.subsysnqn = fctx->subsysnqn,
-		.transport = fctx->transport,
-		.traddr = fctx->traddr,
-		.host_traddr = fctx->host_traddr,
-		.host_iface = fctx->host_iface,
-		.trsvcid = fctx->trsvcid,
+		.subsysnqn	= fctx->subsysnqn,
+		.transport	= fctx->transport,
+		.traddr		= fctx->traddr,
+		.trsvcid	= fctx->trsvcid,
+		.host_traddr	= fctx->host_traddr,
+		.host_iface	= fctx->host_iface,
 	};
 
 	c = lookup_ctrl(h, &trcfg);
@@ -3338,6 +3421,7 @@ int nvmf_connect(struct nvme_global_ctx *ctx, struct nvmf_context *fctx)
 	if (err) {
 		nvme_msg(ctx, LOG_ERR, "could not add new controller: %s\n",
 			nvme_strerror(-err));
+		nvme_free_ctrl(c);
 		return err;
 	}
 
diff --git a/libnvme/src/nvme/fabrics.h b/libnvme/src/nvme/fabrics.h
index c4d0ba7fba..b75d6bbff1 100644
--- a/libnvme/src/nvme/fabrics.h
+++ b/libnvme/src/nvme/fabrics.h
@@ -632,6 +632,19 @@ int nvmf_connect(struct nvme_global_ctx *ctx, struct nvmf_context *fctx);
 int nvmf_connect_config_json(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx);
 
+/**
+ * nvmf_config_modify() - Modify and update the configurtion
+ * @ctx: Global context
+ * @fctx: Fabrics context
+ *
+ * Update the current configuration by adding the crypto
+ * information.
+ *
+ * Return: 0 on success, or a negative error code on failure.
+ */
+int nvmf_config_modify(struct nvme_global_ctx *ctx,
+		struct nvmf_context *fctx);
+
 /**
  * struct nbft_file_entry - Linked list entry for NBFT files
  * @next: Pointer to next entry
@@ -644,6 +657,7 @@ struct nbft_file_entry {
 
 /**
  * nvmf_nbft_read_files() - Read NBFT files from path
+ * @ctx: struct nvme_global_ctx object
  * @path: Path to NBFT files
  * @head: Pointer to store linked list of NBFT file entries
  *
@@ -651,14 +665,16 @@ struct nbft_file_entry {
  *
  * Return: 0 on success, or a negative error code on failure.
  */
-int nvmf_nbft_read_files(char *path, struct nbft_file_entry **head);
+int nvmf_nbft_read_files(struct nvme_global_ctx *ctx, char *path,
+		struct nbft_file_entry **head);
 
 /**
  * nvmf_nbft_free() - Free NBFT file entry list
+ * @ctx: struct nvme_global_ctx object
  * @head: Head of the NBFT file entry list
  *
  * Frees all memory associated with the NBFT file entry list.
  */
-void nvmf_nbft_free(struct nbft_file_entry *head);
+void nvmf_nbft_free(struct nvme_global_ctx *ctx, struct nbft_file_entry *head);
 
 #endif /* _LIBNVME_FABRICS_H */
diff --git a/libnvme/src/nvme/linux.c b/libnvme/src/nvme/linux.c
index ee43cc5f1e..175e7e3460 100644
--- a/libnvme/src/nvme/linux.c
+++ b/libnvme/src/nvme/linux.c
@@ -694,12 +694,13 @@ static unsigned char default_hmac(size_t key_len)
 	return NVME_HMAC_ALG_NONE;
 }
 
-int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac,
-			unsigned int key_len, unsigned char *secret,
-			unsigned char *key)
+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)
 {
 	if (hmac != NVME_HMAC_ALG_NONE) {
-		nvme_msg(NULL, LOG_ERR, "HMAC transformation not supported; " \
+		nvme_msg(ctx, LOG_ERR, "HMAC transformation not supported; "
 			"recompile with OpenSSL support.\n");
 		return -EINVAL;
 	}
@@ -708,50 +709,49 @@ int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac,
 	return 0;
 }
 
-static int derive_retained_key(int hmac, const char *hostnqn,
-			       unsigned char *generated,
-			       unsigned char *retained,
-			       size_t key_len)
+static int derive_retained_key(struct nvme_global_ctx *ctx,
+		int hmac, const char *hostnqn, unsigned char *generated,
+		unsigned char *retained, size_t key_len)
 {
-	nvme_msg(NULL, LOG_ERR, "NVMe TLS is not supported; "
+	nvme_msg(ctx, LOG_ERR, "NVMe TLS is not supported; "
 		 "recompile with OpenSSL support.\n");
 	return -ENOTSUP;
 }
 
-static int derive_retained_key_compat(int hmac, const char *hostnqn,
-				      unsigned char *generated,
-				      unsigned char *retained,
-				      size_t key_len)
+static int derive_retained_key_compat(struct nvme_global_ctx *ctx,
+		int hmac, const char *hostnqn, unsigned char *generated,
+		unsigned char *retained, size_t key_len)
 {
-	nvme_msg(NULL, LOG_ERR, "NVMe TLS is not supported; "
+	nvme_msg(ctx, LOG_ERR, "NVMe TLS is not supported; "
 		 "recompile with OpenSSL support.\n");
 	return -ENOTSUP;
 }
 
-static int derive_psk_digest(const char *hostnqn, const char *subsysnqn,
-			     int version, int cipher,
-			     unsigned char *retained, size_t key_len,
-			     char *digest, size_t digest_len)
+static int derive_psk_digest(struct nvme_global_ctx *ctx,
+		const char *hostnqn, const char *subsysnqn,
+		int version, int cipher,
+		unsigned char *retained, size_t key_len,
+		char *digest, size_t digest_len)
 {
-	nvme_msg(NULL, LOG_ERR, "NVMe TLS 2.0 is not supported; "
+	nvme_msg(ctx, LOG_ERR, "NVMe TLS 2.0 is not supported; "
 		 "recompile with OpenSSL support.\n");
 	return -ENOTSUP;
 }
 
-static int derive_tls_key(int version, int cipher, const char *context,
-			  unsigned char *retained,
-			  unsigned char *psk, size_t key_len)
+static int derive_tls_key(struct nvme_global_ctx *ctx,
+		int version, unsigned char cipher, const char *context,
+		unsigned char *retained, unsigned char *psk, size_t key_len)
 {
-	nvme_msg(NULL, LOG_ERR, "NVMe TLS is not supported; "
+	nvme_msg(ctx, LOG_ERR, "NVMe TLS is not supported; "
 		 "recompile with OpenSSL support.\n");
 	return -ENOTSUP;
 }
 
-static int derive_tls_key_compat(int version, int cipher, const char *context,
-				 unsigned char *retained,
-				 unsigned char *psk, size_t key_len)
+static int derive_tls_key_compat(struct nvme_global_ctx *ctx,
+		int version, unsigned char cipher, const char *context,
+		unsigned char *retained, unsigned char *psk, size_t key_len)
 {
-	nvme_msg(NULL, LOG_ERR, "NVMe TLS is not supported; "
+	nvme_msg(ctx, LOG_ERR, "NVMe TLS is not supported; "
 		 "recompile with OpenSSL support.\n");
 	return -ENOTSUP;
 }
@@ -833,12 +833,12 @@ static DEFINE_CLEANUP_FUNC(
  * - 1 indicates SHA-256
  * - 2 indicates SHA-384
  */
-static int derive_retained_key(int hmac, const char *hostnqn,
-			       unsigned char *configured,
-			       unsigned char *retained,
-			       size_t key_len)
+static int derive_retained_key(struct nvme_global_ctx *ctx,
+		int hmac, const char *hostnqn,
+		unsigned char *configured, unsigned char *retained,
+		size_t key_len)
 {
-	_cleanup_evp_pkey_ctx_ EVP_PKEY_CTX *ctx = NULL;
+	_cleanup_evp_pkey_ctx_ EVP_PKEY_CTX *ectx = NULL;
 	_cleanup_free_ uint8_t *hkdf_info = NULL;
 	char *hkdf_label;
 	const EVP_MD *md;
@@ -860,17 +860,17 @@ static int derive_retained_key(int hmac, const char *hostnqn,
 	if (!md || !hmac_len)
 		return -EINVAL;
 
-	ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL);
-	if (!ctx)
+	ectx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL);
+	if (!ectx)
 		return -ENOMEM;
 
-	if (EVP_PKEY_derive_init(ctx) <= 0)
+	if (EVP_PKEY_derive_init(ectx) <= 0)
 		return -ENOMEM;
 
-	if (EVP_PKEY_CTX_set_hkdf_md(ctx, md) <= 0)
+	if (EVP_PKEY_CTX_set_hkdf_md(ectx, md) <= 0)
 		return -ENOKEY;
 
-	if (EVP_PKEY_CTX_set1_hkdf_key(ctx, configured, key_len) <= 0)
+	if (EVP_PKEY_CTX_set1_hkdf_key(ectx, configured, key_len) <= 0)
 		return -ENOKEY;
 
 	if (key_len > USHRT_MAX)
@@ -893,22 +893,21 @@ static int derive_retained_key(int hmac, const char *hostnqn,
 		return -ENOKEY;
 	pos += ret;
 
-	if (EVP_PKEY_CTX_add1_hkdf_info(ctx, hkdf_info,
+	if (EVP_PKEY_CTX_add1_hkdf_info(ectx, hkdf_info,
 					(pos - (char *)hkdf_info)) <= 0)
 		return -ENOKEY;
 
-	if (EVP_PKEY_derive(ctx, retained, &key_len) <= 0)
+	if (EVP_PKEY_derive(ectx, retained, &key_len) <= 0)
 		return -ENOKEY;
 
 	return key_len;
 }
 
-static int derive_retained_key_compat(int hmac, const char *hostnqn,
-			       unsigned char *configured,
-			       unsigned char *retained,
-			       size_t key_len)
+static int derive_retained_key_compat(struct nvme_global_ctx *ctx,
+		int hmac, const char *hostnqn, unsigned char *configured,
+		unsigned char *retained, size_t key_len)
 {
-	_cleanup_evp_pkey_ctx_ EVP_PKEY_CTX *ctx = NULL;
+	_cleanup_evp_pkey_ctx_ EVP_PKEY_CTX *ectx = NULL;
 	_cleanup_free_ uint8_t *hkdf_info = NULL;
 	const EVP_MD *md;
 	size_t hmac_len;
@@ -924,17 +923,17 @@ static int derive_retained_key_compat(int hmac, const char *hostnqn,
 	if (!md || !hmac_len)
 		return -EINVAL;
 
-	ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL);
-	if (!ctx)
+	ectx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL);
+	if (!ectx)
 		return -ENOMEM;
 
-	if (EVP_PKEY_derive_init(ctx) <= 0)
+	if (EVP_PKEY_derive_init(ectx) <= 0)
 		return -ENOMEM;
 
-	if (EVP_PKEY_CTX_set_hkdf_md(ctx, md) <= 0)
+	if (EVP_PKEY_CTX_set_hkdf_md(ectx, md) <= 0)
 		return -ENOKEY;
 
-	if (EVP_PKEY_CTX_set1_hkdf_key(ctx, configured, key_len) <= 0)
+	if (EVP_PKEY_CTX_set1_hkdf_key(ectx, configured, key_len) <= 0)
 		return -ENOKEY;
 
 	/* +1 byte so that the snprintf terminating null can not overflow */
@@ -952,11 +951,11 @@ static int derive_retained_key_compat(int hmac, const char *hostnqn,
 		return -ENOKEY;
 	pos += ret;
 
-	if (EVP_PKEY_CTX_add1_hkdf_info(ctx, hkdf_info,
+	if (EVP_PKEY_CTX_add1_hkdf_info(ectx, hkdf_info,
 					(pos - (char *)hkdf_info)) <= 0)
 		return -ENOKEY;
 
-	if (EVP_PKEY_derive(ctx, retained, &key_len) <= 0)
+	if (EVP_PKEY_derive(ectx, retained, &key_len) <= 0)
 		return -ENOKEY;
 
 	return key_len;
@@ -985,11 +984,11 @@ static int derive_retained_key_compat(int hmac, const char *hostnqn,
  * and the value '0' is invalid here.
  */
 
-static int derive_tls_key(int version, unsigned char cipher,
-			  const char *context, unsigned char *retained,
-			  unsigned char *psk, size_t key_len)
+static int derive_tls_key(struct nvme_global_ctx *ctx,
+		int version, unsigned char cipher, const char *context,
+		unsigned char *retained, unsigned char *psk, size_t key_len)
 {
-	_cleanup_evp_pkey_ctx_ EVP_PKEY_CTX *ctx = NULL;
+	_cleanup_evp_pkey_ctx_ EVP_PKEY_CTX *ectx = NULL;
 	_cleanup_free_ uint8_t *hkdf_info = NULL;
 	char *hkdf_label;
 	const EVP_MD *md;
@@ -1006,17 +1005,17 @@ static int derive_tls_key(int version, unsigned char cipher,
 	if (!md || !hmac_len)
 		return -EINVAL;
 
-	ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL);
-	if (!ctx)
+	ectx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL);
+	if (!ectx)
 		return -ENOMEM;
 
-	if (EVP_PKEY_derive_init(ctx) <= 0)
+	if (EVP_PKEY_derive_init(ectx) <= 0)
 		return -ENOMEM;
 
-	if (EVP_PKEY_CTX_set_hkdf_md(ctx, md) <= 0)
+	if (EVP_PKEY_CTX_set_hkdf_md(ectx, md) <= 0)
 		return -ENOKEY;
 
-	if (EVP_PKEY_CTX_set1_hkdf_key(ctx, retained, key_len) <= 0)
+	if (EVP_PKEY_CTX_set1_hkdf_key(ectx, retained, key_len) <= 0)
 		return -ENOKEY;
 
 	if (key_len > USHRT_MAX)
@@ -1052,21 +1051,21 @@ static int derive_tls_key(int version, unsigned char cipher,
 		return -ENOKEY;
 	}
 
-	if (EVP_PKEY_CTX_add1_hkdf_info(ctx, hkdf_info,
+	if (EVP_PKEY_CTX_add1_hkdf_info(ectx, hkdf_info,
 					(pos - (char *)hkdf_info)) <= 0)
 		return -ENOKEY;
 
-	if (EVP_PKEY_derive(ctx, psk, &key_len) <= 0)
+	if (EVP_PKEY_derive(ectx, psk, &key_len) <= 0)
 		return -ENOKEY;
 
 	return key_len;
 }
 
-static int derive_tls_key_compat(int version, unsigned char cipher,
-			  const char *context, unsigned char *retained,
-			  unsigned char *psk, size_t key_len)
+static int derive_tls_key_compat(struct nvme_global_ctx *ctx,
+		int version, unsigned char cipher, const char *context,
+		unsigned char *retained, unsigned char *psk, size_t key_len)
 {
-	_cleanup_evp_pkey_ctx_ EVP_PKEY_CTX *ctx = NULL;
+	_cleanup_evp_pkey_ctx_ EVP_PKEY_CTX *ectx = NULL;
 	_cleanup_free_ uint8_t *hkdf_info = NULL;
 	const EVP_MD *md;
 	size_t hmac_len;
@@ -1077,17 +1076,17 @@ static int derive_tls_key_compat(int version, unsigned char cipher,
 	if (!md || !hmac_len)
 		return -EINVAL;
 
-	ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL);
-	if (!ctx)
+	ectx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL);
+	if (!ectx)
 		return -ENOMEM;
 
-	if (EVP_PKEY_derive_init(ctx) <= 0)
+	if (EVP_PKEY_derive_init(ectx) <= 0)
 		return -ENOMEM;
 
-	if (EVP_PKEY_CTX_set_hkdf_md(ctx, md) <= 0)
+	if (EVP_PKEY_CTX_set_hkdf_md(ectx, md) <= 0)
 		return -ENOKEY;
 
-	if (EVP_PKEY_CTX_set1_hkdf_key(ctx, retained, key_len) <= 0)
+	if (EVP_PKEY_CTX_set1_hkdf_key(ectx, retained, key_len) <= 0)
 		return -ENOKEY;
 
 	/* +1 byte so that the snprintf terminating null can not overflow */
@@ -1122,11 +1121,11 @@ static int derive_tls_key_compat(int version, unsigned char cipher,
 		return -ENOKEY;
 	}
 
-	if (EVP_PKEY_CTX_add1_hkdf_info(ctx, hkdf_info,
+	if (EVP_PKEY_CTX_add1_hkdf_info(ectx, hkdf_info,
 					(pos - (char *)hkdf_info)) <= 0)
 		return -ENOKEY;
 
-	if (EVP_PKEY_derive(ctx, psk, &key_len) <= 0)
+	if (EVP_PKEY_derive(ectx, psk, &key_len) <= 0)
 		return -ENOKEY;
 
 	return key_len;
@@ -1140,9 +1139,10 @@ 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(char *hostnqn, enum nvme_hmac_alg hmac,
-			unsigned int key_len, unsigned char *secret,
-			unsigned char *key)
+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)
 {
 	const char hmac_seed[] = "NVMe-over-Fabrics";
 	_cleanup_ossl_lib_ctx_ OSSL_LIB_CTX *lib_ctx = NULL;
@@ -1206,10 +1206,11 @@ int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac,
 	return 0;
 }
 
-static int derive_psk_digest(const char *hostnqn, const char *subsysnqn,
-			     int version, int cipher,
-			     unsigned char *retained, size_t key_len,
-			     char *digest, size_t digest_len)
+static int derive_psk_digest(struct nvme_global_ctx *ctx,
+		const char *hostnqn, const char *subsysnqn,
+		int version, int cipher,
+		unsigned char *retained, size_t key_len,
+		char *digest, size_t digest_len)
 {
 	static const char hmac_seed[] = "NVMe-over-Fabrics";
 	_cleanup_ossl_lib_ctx_ OSSL_LIB_CTX *lib_ctx = NULL;
@@ -1309,10 +1310,11 @@ static int gen_tls_identity(const char *hostnqn, const char *subsysnqn,
 	return strlen(identity);
 }
 
-static int derive_nvme_keys(const char *hostnqn, const char *subsysnqn,
-			    char *identity, int version,
-			    int hmac, unsigned char *configured,
-			    unsigned char *psk, int key_len, bool compat)
+static int derive_nvme_keys(struct nvme_global_ctx *ctx,
+		const char *hostnqn, const char *subsysnqn,
+		char *identity, int version,
+		int hmac, unsigned char *configured,
+		unsigned char *psk, int key_len, bool compat)
 {
 	_cleanup_free_ unsigned char *retained = NULL;
 	_cleanup_free_ char *digest = NULL;
@@ -1328,10 +1330,10 @@ static int derive_nvme_keys(const char *hostnqn, const char *subsysnqn,
 		return -ENOMEM;
 
 	if (compat)
-		ret = derive_retained_key_compat(hmac, hostnqn, configured,
+		ret = derive_retained_key_compat(ctx, hmac, hostnqn, configured,
 						 retained, key_len);
 	else
-		ret = derive_retained_key(hmac, hostnqn, configured,
+		ret = derive_retained_key(ctx, hmac, hostnqn, configured,
 					  retained, key_len);
 	if (ret < 0)
 		return ret;
@@ -1348,9 +1350,9 @@ static int derive_nvme_keys(const char *hostnqn, const char *subsysnqn,
 		if (!digest)
 			return -ENOMEM;
 
-		ret = derive_psk_digest(hostnqn, subsysnqn, version, cipher,
-					retained, key_len,
-					digest, digest_len);
+		ret = derive_psk_digest(ctx, hostnqn, subsysnqn, version,
+					cipher, retained, key_len, digest,
+					digest_len);
 		if (ret < 0)
 			return ret;
 		context = digest;
@@ -1360,10 +1362,10 @@ static int derive_nvme_keys(const char *hostnqn, const char *subsysnqn,
 	if (ret < 0)
 		return ret;
 	if (compat)
-		return derive_tls_key_compat(version, cipher, context, retained,
-					     psk, key_len);
-	return derive_tls_key(version, cipher, context, retained,
-			      psk, key_len);
+		return derive_tls_key_compat(ctx, version, cipher, context,
+			retained, psk, key_len);
+	return derive_tls_key(ctx, version, cipher, context, retained,
+			psk, key_len);
 }
 
 static ssize_t nvme_identity_len(int hmac, int version, const char *hostnqn,
@@ -1385,10 +1387,11 @@ static ssize_t nvme_identity_len(int hmac, int version, const char *hostnqn,
 	return len;
 }
 
-int nvme_generate_tls_key_identity(const char *hostnqn, const char *subsysnqn,
-				   int version, int hmac,
-				   unsigned char *configured_key, int key_len,
-				   char **ident)
+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,
+		char **ident)
 {
 	_cleanup_free_ unsigned char *psk = NULL;
 	_cleanup_free_ char *identity = NULL;
@@ -1408,7 +1411,7 @@ int nvme_generate_tls_key_identity(const char *hostnqn, const char *subsysnqn,
 		return -ENOMEM;
 
 	memset(psk, 0, key_len);
-	ret = derive_nvme_keys(hostnqn, subsysnqn, identity, version, hmac,
+	ret = derive_nvme_keys(ctx, hostnqn, subsysnqn, identity, version, hmac,
 			       configured_key, psk, key_len, false);
 	if (ret != key_len) {
 		if (ret < 0)
@@ -1422,10 +1425,10 @@ int nvme_generate_tls_key_identity(const char *hostnqn, const char *subsysnqn,
 	return 0;
 }
 
-int nvme_generate_tls_key_identity_compat(const char *hostnqn, const char *subsysnqn,
-					 int version, int hmac,
-					 unsigned char *configured_key, int key_len,
-					 char **ident)
+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)
 {
 	_cleanup_free_ unsigned char *psk = NULL;
 	_cleanup_free_ char *identity = NULL;
@@ -1445,7 +1448,7 @@ int nvme_generate_tls_key_identity_compat(const char *hostnqn, const char *subsy
 		return -ENOMEM;
 
 	memset(psk, 0, key_len);
-	ret = derive_nvme_keys(hostnqn, subsysnqn, identity, version, hmac,
+	ret = derive_nvme_keys(ctx, hostnqn, subsysnqn, identity, version, hmac,
 			       configured_key, psk, key_len, true);
 	if (ret != key_len) {
 		if (ret < 0)
@@ -1460,7 +1463,8 @@ int nvme_generate_tls_key_identity_compat(const char *hostnqn, const char *subsy
 }
 
 #ifdef CONFIG_KEYUTILS
-int nvme_lookup_keyring(const char *keyring, long *key)
+int nvme_lookup_keyring(struct nvme_global_ctx *ctx, const char *keyring,
+		long *key)
 {
 	key_serial_t keyring_id;
 
@@ -1474,7 +1478,7 @@ int nvme_lookup_keyring(const char *keyring, long *key)
 	return 0;
 }
 
-char *nvme_describe_key_serial(long key_id)
+char *nvme_describe_key_serial(struct nvme_global_ctx *ctx, long key_id)
 {
 	_cleanup_free_ char *str = NULL;
 	char *last;
@@ -1493,7 +1497,8 @@ char *nvme_describe_key_serial(long key_id)
 	return strdup(last);
 }
 
-int nvme_lookup_key(const char *type, const char *identity, long *keyp)
+int nvme_lookup_key(struct nvme_global_ctx *ctx, const char *type,
+		const char *identity, long *keyp)
 {
 	key_serial_t key;
 
@@ -1503,12 +1508,12 @@ int nvme_lookup_key(const char *type, const char *identity, long *keyp)
 	return key;
 }
 
-int nvme_set_keyring(long key_id)
+int nvme_set_keyring(struct nvme_global_ctx *ctx, long key_id)
 {
 	long err;
 
 	if (key_id == 0) {
-		if (nvme_lookup_keyring(NULL, &key_id))
+		if (nvme_lookup_keyring(ctx, NULL, &key_id))
 			return -ENOKEY;
 	}
 
@@ -1518,13 +1523,13 @@ int nvme_set_keyring(long key_id)
 	return 0;
 }
 
-int nvme_read_key(long keyring_id, long key_id, int *len,
-		  unsigned char **key)
+int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
+		long key_id, int *len, unsigned char **key)
 {
 	void *buffer;
 	int ret;
 
-	ret = nvme_set_keyring(keyring_id);
+	ret = nvme_set_keyring(ctx, keyring_id);
 	if (ret < 0)
 		return ret;
 
@@ -1537,9 +1542,9 @@ int nvme_read_key(long keyring_id, long key_id, int *len,
 	return 0;
 }
 
-int nvme_update_key(long keyring_id, const char *key_type,
-		    const char *identity, unsigned char *key_data,
-		    int key_len, long *keyp)
+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)
 {
 	long key;
 
@@ -1558,13 +1563,14 @@ int nvme_update_key(long keyring_id, const char *key_type,
 }
 
 struct __scan_keys_data {
+	struct nvme_global_ctx *ctx;
 	nvme_scan_tls_keys_cb_t cb;
 	key_serial_t keyring;
 	void *data;
 };
 
-int __scan_keys_cb(key_serial_t parent, key_serial_t key,
-		   char *desc, int desc_len, void *data)
+int __scan_keys_cb(key_serial_t parent, key_serial_t key, char *desc,
+		int desc_len, void *data)
 {
 	struct __scan_keys_data *d = data;
 	int ver, hmac, uid, gid, perm;
@@ -1592,28 +1598,29 @@ int __scan_keys_cb(key_serial_t parent, key_serial_t key,
 	if (!ptr)
 		return 0;
 	/* Only use the key description for the callback */
-	(d->cb)(d->keyring, key, ptr + 1, strlen(ptr) - 1, d->data);
+	(d->cb)(d->ctx, d->keyring, key, ptr + 1, strlen(ptr) - 1, d->data);
 	return 1;
 }
 
-int nvme_scan_tls_keys(const char *keyring, nvme_scan_tls_keys_cb_t cb,
-		       void *data)
+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;
 	long keyring_id;
 	int ret;
 
-	ret = nvme_lookup_keyring(keyring, &keyring_id);
+	ret = nvme_lookup_keyring(ctx, keyring, &keyring_id);
 	if (ret)
 		return ret;
 
 	if (!keyring_id)
 		return -EINVAL;
 
-	ret = nvme_set_keyring(keyring_id);
+	ret = nvme_set_keyring(ctx, keyring_id);
 	if (ret < 0)
 		return ret;
 
+	d.ctx = ctx;
 	d.keyring = keyring_id;
 	d.cb = cb;
 	d.data = data;
@@ -1621,11 +1628,11 @@ int nvme_scan_tls_keys(const char *keyring, nvme_scan_tls_keys_cb_t cb,
 	return ret;
 }
 
-static int __nvme_insert_tls_key(key_serial_t keyring_id, const char *key_type,
-				 const char *hostnqn, const char *subsysnqn,
-				 int version, int hmac,
-				 unsigned char *configured_key, int key_len,
-				 bool compat, long *keyp)
+static int __nvme_insert_tls_key(struct nvme_global_ctx *ctx,
+		key_serial_t keyring_id, const char *key_type,
+		const char *hostnqn, const char *subsysnqn,
+		int version, int hmac, unsigned char *configured_key,
+		int key_len, bool compat, long *keyp)
 {
 	_cleanup_free_ unsigned char *psk = NULL;
 	_cleanup_free_ char *identity = NULL;
@@ -1646,7 +1653,7 @@ static int __nvme_insert_tls_key(key_serial_t keyring_id, const char *key_type,
 	if (!psk)
 		return -ENOMEM;
 	memset(psk, 0, key_len);
-	ret = derive_nvme_keys(hostnqn, subsysnqn, identity, version, hmac,
+	ret = derive_nvme_keys(ctx, hostnqn, subsysnqn, identity, version, hmac,
 			       configured_key, psk, key_len, compat);
 	if (ret != key_len) {
 		if (ret < 0)
@@ -1654,7 +1661,7 @@ static int __nvme_insert_tls_key(key_serial_t keyring_id, const char *key_type,
 		return -ENOKEY;
 	}
 
-	ret = nvme_update_key(keyring_id, key_type, identity,
+	ret = nvme_update_key(ctx, keyring_id, key_type, identity,
 			      psk, key_len, &key);
 	if (ret)
 		return ret;
@@ -1663,59 +1670,60 @@ static int __nvme_insert_tls_key(key_serial_t keyring_id, const char *key_type,
 	return 0;
 }
 
-int nvme_insert_tls_key_versioned(const char *keyring, const char *key_type,
-				  const char *hostnqn, const char *subsysnqn,
-				  int version, int hmac,
-				  unsigned char *configured_key, int key_len,
-				  long *key)
+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,
+		unsigned char *configured_key, int key_len,
+		long *key)
 {
 	long keyring_id;
 	int ret;
 
-	ret = nvme_lookup_keyring(keyring, &keyring_id);
+	ret = nvme_lookup_keyring(ctx, keyring, &keyring_id);
 	if (ret)
 		return ret;
 
-	ret = nvme_set_keyring(keyring_id);
+	ret = nvme_set_keyring(ctx, keyring_id);
 	if (ret < 0)
 		return 0;
 
-	return __nvme_insert_tls_key(keyring_id, key_type,
-				     hostnqn, subsysnqn,
-				     version, hmac,
-				     configured_key, key_len, false, key);
+	return __nvme_insert_tls_key(ctx, keyring_id, key_type,
+		hostnqn, subsysnqn, version, hmac,
+		configured_key, key_len, false, key);
 }
 
-int nvme_insert_tls_key_compat(const char *keyring, const char *key_type,
-			       const char *hostnqn, const char *subsysnqn,
-			       int version, int hmac,
-			       unsigned char *configured_key, int key_len,
-			       long *key)
+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,
+		unsigned char *configured_key, int key_len,
+		long *key)
 {
 	long keyring_id;
 	int ret;
 
-	ret = nvme_lookup_keyring(keyring, &keyring_id);
+	ret = nvme_lookup_keyring(ctx, keyring, &keyring_id);
 	if (ret)
 		return ret;
 
-	ret = nvme_set_keyring(keyring_id);
+	ret = nvme_set_keyring(ctx, keyring_id);
 	if (ret < 0)
 		return 0;
 
-	return __nvme_insert_tls_key(keyring_id, key_type,
-				     hostnqn, subsysnqn,
-				     version, hmac,
-				     configured_key, key_len, true, key);
+	return __nvme_insert_tls_key(ctx, keyring_id, key_type,
+		hostnqn, subsysnqn, version, hmac,
+		configured_key, key_len, true, key);
 }
 
-int nvme_revoke_tls_key(const char *keyring, const char *key_type,
-			const char *identity)
+int nvme_revoke_tls_key(struct nvme_global_ctx *ctx,
+		const char *keyring, const char *key_type,
+		const char *identity)
 {
 	long keyring_id, key;
 	int ret;
 
-	ret = nvme_lookup_keyring(keyring, &keyring_id);
+	ret = nvme_lookup_keyring(ctx, keyring, &keyring_id);
 	if (ret)
 		return ret;
 
@@ -1730,10 +1738,10 @@ int nvme_revoke_tls_key(const char *keyring, const char *key_type,
 	return 0;
 }
 
-static int __nvme_import_tls_key(long keyring_id,
-				 const char *hostnqn, const char *subsysnqn,
-				 const char *identity, const char *key,
-				 long *keyp)
+static int __nvme_import_tls_key(struct nvme_global_ctx *ctx, long keyring_id,
+		const char *hostnqn, const char *subsysnqn,
+		const char *identity, const char *key,
+		long *keyp)
 {
 	_cleanup_free_ unsigned char *key_data = NULL;
 	unsigned char version;
@@ -1741,7 +1749,7 @@ static int __nvme_import_tls_key(long keyring_id,
 	size_t key_len;
 	int ret;
 
-	ret = nvme_import_tls_key_versioned(key, &version,
+	ret = nvme_import_tls_key_versioned(ctx, key, &version,
 					    &hmac, &key_len, &key_data);
 	if (ret)
 		return ret;
@@ -1753,18 +1761,17 @@ static int __nvme_import_tls_key(long keyring_id,
 		 * configured key. Derive a new key and load the newly
 		 * created key into the keystore.
 		 */
-		return __nvme_insert_tls_key(keyring_id, "psk",
-					     hostnqn, subsysnqn,
-					     version, hmac,
-					     key_data, key_len, false, keyp);
+		return __nvme_insert_tls_key(ctx, keyring_id, "psk",
+			hostnqn, subsysnqn, version, hmac,
+			key_data, key_len, false, keyp);
 	}
 
-	return nvme_update_key(keyring_id, "psk", identity,
+	return nvme_update_key(ctx, keyring_id, "psk", identity,
 			      key_data, key_len, keyp);
 }
 
 int __nvme_import_keys_from_config(nvme_host_t h, nvme_ctrl_t c,
-				   long *keyring_id, long *key_id)
+		long *keyring_id, long *key_id)
 {
 	const char *hostnqn = nvme_host_get_hostnqn(h);
 	const char *subsysnqn = nvme_ctrl_get_subsysnqn(c);
@@ -1785,7 +1792,7 @@ int __nvme_import_keys_from_config(nvme_host_t h, nvme_ctrl_t c,
 
 	keyring = nvme_ctrl_get_keyring(c);
 	if (keyring) {
-		ret = nvme_lookup_keyring(keyring, &kr_id);
+		ret = nvme_lookup_keyring(h->ctx, keyring, &kr_id);
 		if (ret)
 			return ret;
 	} else
@@ -1797,19 +1804,19 @@ int __nvme_import_keys_from_config(nvme_host_t h, nvme_ctrl_t c,
 	 * That means we are explicitly selecting the keyring.
 	 */
 	if (!kr_id) {
-		ret = nvme_lookup_keyring(".nvme", &kr_id);
+		ret = nvme_lookup_keyring(h->ctx, ".nvme", &kr_id);
 		if (ret)
 			return ret;
 	}
 
-	if (nvme_set_keyring(kr_id) < 0) {
+	if (nvme_set_keyring(h->ctx, kr_id) < 0) {
 		nvme_msg(h->ctx, LOG_ERR, "Failed to set keyring\n");
 		return -errno;
 	}
 
 	identity = nvme_ctrl_get_tls_key_identity(c);
 	if (identity) {
-		ret = nvme_lookup_key("psk", identity, &id);
+		ret = nvme_lookup_key(h->ctx, "psk", identity, &id);
 		if (ret && !(ret == -ENOKEY || ret == -EKEYREVOKED)) {
 			nvme_msg(h->ctx, LOG_ERR,
 				 "Failed to lookup key for identity %s, error %d\n",
@@ -1819,7 +1826,7 @@ int __nvme_import_keys_from_config(nvme_host_t h, nvme_ctrl_t c,
 	}
 
 	if (!id) {
-		ret = __nvme_import_tls_key(kr_id, hostnqn,
+		ret = __nvme_import_tls_key(h->ctx, kr_id, hostnqn,
 					    subsysnqn, identity, key, &id);
 		if (ret) {
 			nvme_msg(h->ctx, LOG_ERR,
@@ -1835,79 +1842,90 @@ int __nvme_import_keys_from_config(nvme_host_t h, nvme_ctrl_t c,
 	return 0;
 }
 #else
-int nvme_lookup_keyring(const char *keyring, long *key)
+int nvme_lookup_keyring(struct nvme_global_ctx *ctx, const char *keyring,
+		long *key)
 {
-	nvme_msg(NULL, LOG_ERR, "key operations not supported; "\
+	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
 		 "recompile with keyutils support.\n");
 	return -ENOTSUP;
 }
 
-char *nvme_describe_key_serial(long key_id)
+char *nvme_describe_key_serial(struct nvme_global_ctx *ctx, long key_id)
 {
-	nvme_msg(NULL, LOG_ERR, "key operations not supported; "\
+	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
 		 "recompile with keyutils support.\n");
 	return NULL;
 }
 
-int nvme_lookup_key(const char *type, const char *identity, long *key)
+int nvme_lookup_key(struct nvme_global_ctx *ctx, const char *type,
+		const char *identity, long *key)
 {
-	nvme_msg(NULL, LOG_ERR, "key operations not supported; "\
+	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
 		 "recompile with keyutils support.\n");
 	return -ENOTSUP;
 }
 
-int nvme_set_keyring(long key_id)
+int nvme_set_keyring(struct nvme_global_ctx *ctx, long key_id)
 {
-	nvme_msg(NULL, LOG_ERR, "key operations not supported; "\
+	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
 		 "recompile with keyutils support.\n");
 	return -ENOTSUP;
 }
 
-int nvme_read_key(long keyring_id, long key_id, int *len,
-		  unsigned char **key)
+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; "
+		 "recompile with keyutils support.\n");
 	return -ENOTSUP;
 }
 
-int nvme_update_key(long keyring_id, const char *key_type,
-		     const char *identity, unsigned char *key_data,
-		     int key_len, long *key)
+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)
 {
+	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
+		 "recompile with keyutils support.\n");
 	return -ENOTSUP;
 }
 
-int nvme_scan_tls_keys(const char *keyring, nvme_scan_tls_keys_cb_t cb,
-		       void *data)
+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; "
+		 "recompile with keyutils support.\n");
 	return -ENOTSUP;
 }
 
-int nvme_insert_tls_key_versioned(const char *keyring, const char *key_type,
-				  const char *hostnqn, const char *subsysnqn,
-				  int version, int hmac,
-				  unsigned char *configured_key, int key_len,
-				  long *keyp)
+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,
+		unsigned char *configured_key, int key_len,
+		long *keyp)
 {
-	nvme_msg(NULL, LOG_ERR, "key operations not supported; "
+	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
 		 "recompile with keyutils support.\n");
 	return -ENOTSUP;
 }
 
-int nvme_insert_tls_key_compat(const char *keyring, const char *key_type,
-			       const char *hostnqn, const char *subsysnqn,
-			       int version, int hmac,
-			       unsigned char *configured_key, int key_len,
-			       long *keyp)
+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,
+		unsigned char *configured_key, int key_len,
+		long *keyp)
 {
-	nvme_msg(NULL, LOG_ERR, "key operations not supported; "
+	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
 		 "recompile with keyutils support.\n");
 	return -ENOTSUP;
 }
 
-int nvme_revoke_tls_key(const char *keyring, const char *key_type,
-			const char *identity)
+int nvme_revoke_tls_key(struct nvme_global_ctx *ctx,
+		const char *keyring, const char *key_type,
+		const char *identity)
 {
-	nvme_msg(NULL, LOG_ERR, "key operations not supported; "
+	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
 		 "recompile with keyutils support.\n");
 	return -ENOTSUP;
 }
@@ -1922,11 +1940,12 @@ int __nvme_import_keys_from_config(nvme_host_t h, nvme_ctrl_t c,
 }
 #endif
 
-int nvme_insert_tls_key(const char *keyring, const char *key_type,
-			 const char *hostnqn, const char *subsysnqn, int hmac,
-			 unsigned char *configured_key, int key_len, long *key)
+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)
 {
-	return nvme_insert_tls_key_versioned(keyring, key_type,
+	return nvme_insert_tls_key_versioned(ctx, keyring, key_type,
 					     hostnqn, subsysnqn, 0, hmac,
 					     configured_key, key_len, key);
 }
@@ -1943,9 +1962,10 @@ int nvme_insert_tls_key(const char *keyring, const char *key_type,
  * 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(unsigned char version, unsigned char hmac,
-				  const unsigned char *key_data,
-				  size_t key_len, char **encoded_keyp)
+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)
 {
 	unsigned int raw_len, encoded_len, len;
 	unsigned long crc = crc32(0L, NULL, 0);
@@ -1992,7 +2012,8 @@ int nvme_export_tls_key_versioned(unsigned char version, unsigned char hmac,
 	return 0;
 }
 
-int nvme_export_tls_key(const unsigned char *key_data, int key_len, char **key)
+int nvme_export_tls_key(struct nvme_global_ctx *ctx,
+		const unsigned char *key_data, int key_len, char **key)
 {
 	unsigned char hmac;
 
@@ -2001,14 +2022,14 @@ int nvme_export_tls_key(const unsigned char *key_data, int key_len, char **key)
 	else
 		hmac = NVME_HMAC_ALG_SHA2_384;
 
-	return nvme_export_tls_key_versioned(1, hmac, key_data, key_len, key);
+	return nvme_export_tls_key_versioned(ctx, 1, hmac, key_data,
+		key_len, key);
 }
 
-int nvme_import_tls_key_versioned(const char *encoded_key,
-				  unsigned char *version,
-				  unsigned char *hmac,
-				  size_t *key_len,
-				  unsigned char **keyp)
+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)
 {
 	unsigned char decoded_key[128], *key_data;
 	unsigned int crc = crc32(0L, NULL, 0);
@@ -2059,7 +2080,7 @@ int nvme_import_tls_key_versioned(const char *encoded_key,
 		((uint32_t)decoded_key[decoded_len + 2] << 16) |
 		((uint32_t)decoded_key[decoded_len + 3] << 24);
 	if (key_crc != crc) {
-		nvme_msg(NULL, LOG_ERR, "CRC mismatch (key %08x, crc %08x)",
+		nvme_msg(ctx, LOG_ERR, "CRC mismatch (key %08x, crc %08x)",
 			 key_crc, crc);
 		return -ENOKEY;
 	}
@@ -2074,15 +2095,15 @@ int nvme_import_tls_key_versioned(const char *encoded_key,
 	return 0;
 }
 
-int nvme_import_tls_key(const char *encoded_key, int *key_len,
-			unsigned int *hmac, unsigned char **keyp)
+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;
 	unsigned char *psk;
 	size_t len;
 	int ret;
 
-	ret = nvme_import_tls_key_versioned(encoded_key, &version,
+	ret = nvme_import_tls_key_versioned(ctx, encoded_key, &version,
 					    &_hmac, &len, &psk);
 	if (ret)
 		return ret;
diff --git a/libnvme/src/nvme/linux.h b/libnvme/src/nvme/linux.h
index f136e0a011..45c2e6da07 100644
--- a/libnvme/src/nvme/linux.h
+++ b/libnvme/src/nvme/linux.h
@@ -227,7 +227,7 @@ int nvme_namespace_detach_ctrls(struct nvme_transport_handle *hdl, __u32 nsid, _
  */
 int nvme_open(struct nvme_global_ctx *ctx, const char *name,
 	      struct nvme_transport_handle **hdl);
-                                          
+
 /**
  * nvme_close() - Close transport handle
  * @hdl:	Transport handle
@@ -367,6 +367,7 @@ enum nvme_hmac_alg {
 
 /**
  * nvme_gen_dhchap_key() - DH-HMAC-CHAP key generation
+ * @ctx:	struct nvme_global_ctx object
  * @hostnqn:	Host NVMe Qualified Name
  * @hmac:	HMAC algorithm
  * @key_len:	Output key length
@@ -376,12 +377,14 @@ enum nvme_hmac_alg {
  * Return: If key generation was successful the function returns 0 or
  * a negative error code otherwise.
  */
-int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac,
-			unsigned int key_len, unsigned char *secret,
-			unsigned char *key);
+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);
 
 /**
  * nvme_lookup_keyring() - Lookup keyring serial number
+ * @ctx:	struct nvme_global_ctx object
  * @keyring:    Keyring name
  * @key:	Key serial number to return
  *
@@ -389,10 +392,12 @@ int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac,
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_lookup_keyring(const char *keyring, long *key);
+int nvme_lookup_keyring(struct nvme_global_ctx *ctx,
+		const char *keyring, long *key);
 
 /**
  * nvme_describe_key_serial() - Return key description
+ * @ctx:	struct nvme_global_ctx object
  * @key_id:    Key serial number
  *
  * Fetches the description of the key or keyring identified
@@ -401,10 +406,12 @@ int nvme_lookup_keyring(const char *keyring, long *key);
  * Return: The description of @key_id or NULL on failure.
  * The returned string needs to be freed by the caller.
  */
-char *nvme_describe_key_serial(long key_id);
+char *nvme_describe_key_serial(struct nvme_global_ctx *ctx,
+		long key_id);
 
 /**
  * nvme_lookup_key() - Lookup key serial number
+ * @ctx:	struct nvme_global_ctx object
  * @type:	Key type
  * @identity:	Key description
  * @key:	Key serial number to return
@@ -414,10 +421,12 @@ char *nvme_describe_key_serial(long key_id);
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_lookup_key(const char *type, const char *identity, long *key);
+int nvme_lookup_key(struct nvme_global_ctx *ctx, const char *type,
+		const char *identity, long *key);
 
 /**
  * nvme_set_keyring() - Link keyring for lookup
+ * @ctx:           struct nvme_global_ctx object
  * @keyring_id:    Keyring id
  *
  * Links @keyring_id into the session keyring such that
@@ -425,10 +434,11 @@ int nvme_lookup_key(const char *type, const char *identity, long *key);
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_set_keyring(long keyring_id);
+int nvme_set_keyring(struct nvme_global_ctx *ctx, long keyring_id);
 
 /**
  * nvme_read_key() - Read key raw data
+ * @ctx:		struct nvme_global_ctx object
  * @keyring_id:		Id of the keyring holding %key_id
  * @key_id:		Key id
  * @len:		Length of the returned data
@@ -441,11 +451,12 @@ int nvme_set_keyring(long keyring_id);
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_read_key(long keyring_id, long key_id, int *len,
-		  unsigned char **key);
+int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
+		long key_id, int *len, unsigned char **key);
 
 /**
  * nvme_update_key() - Update key raw data
+ * @ctx:	struct nvme_global_ctx object
  * @keyring_id:	Id of the keyring holding %key_id
  * @key_type:	Type of the key to insert
  * @identity:	Key identity string
@@ -460,12 +471,13 @@ int nvme_read_key(long keyring_id, long key_id, int *len,
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_update_key(long keyring_id, const char *key_type,
-		    const char *identity, unsigned char *key_data,
-		    int key_len, long *key);
+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);
 
 /**
  * typedef nvme_scan_tls_keys_cb_t - Callback for iterating TLS keys
+ * @ctx:	struct nvme_global_ctx object
  * @keyring:	Keyring which has been iterated
  * @key:	Key for which the callback has been invoked
  * @desc:	Description of the key
@@ -474,11 +486,12 @@ int nvme_update_key(long keyring_id, const char *key_type,
  *
  * Called for each TLS PSK in the keyring.
  */
-typedef void (*nvme_scan_tls_keys_cb_t)(long keyring, long key,
-					char *desc, int desc_len, void *data);
+typedef void (*nvme_scan_tls_keys_cb_t)(struct nvme_global_ctx *ctx,
+		long keyring, long key, char *desc, int desc_len, void *data);
 
 /**
  * nvme_scan_tls_keys() - Iterate over TLS keys in a keyring
+ * @ctx:	struct nvme_global_ctx object
  * @keyring:	Keyring holding TLS keys
  * @cb:		Callback function
  * @data:	Pointer for data to be passed to @cb
@@ -491,11 +504,12 @@ typedef void (*nvme_scan_tls_keys_cb_t)(long keyring, long key,
  *
  * Return: Number of keys for which @cb was called, or negative error code
  */
-int nvme_scan_tls_keys(const char *keyring, nvme_scan_tls_keys_cb_t cb,
-		       void *data);
+int nvme_scan_tls_keys(struct nvme_global_ctx *ctx, const char *keyring,
+		nvme_scan_tls_keys_cb_t cb, void *data);
 
 /**
  * nvme_insert_tls_key() - Derive and insert TLS key
+ * @ctx:	struct nvme_global_ctx object
  * @keyring:	Keyring to use
  * @key_type:	Type of the resulting key
  * @hostnqn:	Host NVMe Qualified Name
@@ -510,12 +524,14 @@ int nvme_scan_tls_keys(const char *keyring, nvme_scan_tls_keys_cb_t cb,
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_insert_tls_key(const char *keyring, const char *key_type,
-			 const char *hostnqn, const char *subsysnqn, int hmac,
-			 unsigned char *configured_key, int key_len, long *key);
+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);
 
 /**
  * nvme_insert_tls_key_versioned() - Derive and insert TLS key
+ * @ctx:	struct nvme_global_ctx object
  * @keyring:    Keyring to use
  * @key_type:	Type of the resulting key
  * @hostnqn:	Host NVMe Qualified Name
@@ -532,14 +548,16 @@ int nvme_insert_tls_key(const char *keyring, const char *key_type,
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_insert_tls_key_versioned(const char *keyring, const char *key_type,
-				  const char *hostnqn, const char *subsysnqn,
-				  int version, int hmac,
-				  unsigned char *configured_key, int key_len,
-				  long *key);
+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,
+		unsigned char *configured_key, int key_len,
+		long *key);
 
 /**
  * nvme_insert_tls_key_compat() - Derive and insert TLS key
+ * @ctx:	struct nvme_global_ctx object
  * @keyring:    Keyring to use
  * @key_type:	Type of the resulting key
  * @hostnqn:	Host NVMe Qualified Name
@@ -560,14 +578,16 @@ int nvme_insert_tls_key_versioned(const char *keyring, const char *key_type,
  * Return: The key serial number if the key could be inserted into
  * the keyring or 0 with errno otherwise.
  */
-int nvme_insert_tls_key_compat(const char *keyring, const char *key_type,
-			       const char *hostnqn, const char *subsysnqn,
-			       int version, int hmac,
-			       unsigned char *configured_key, int key_len,
-			       long *key);
+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,
+		unsigned char *configured_key, int key_len,
+		long *key);
 
 /**
  * nvme_generate_tls_key_identity() - Generate the TLS key identity
+ * @ctx:	struct nvme_global_ctx object
  * @hostnqn:	Host NVMe Qualified Name
  * @subsysnqn:	Subsystem NVMe Qualified Name
  * @version:	Key version to use
@@ -583,13 +603,15 @@ int nvme_insert_tls_key_compat(const char *keyring, const char *key_type,
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_generate_tls_key_identity(const char *hostnqn, const char *subsysnqn,
-				   int version, int hmac,
-				   unsigned char *configured_key, int key_len,
-				   char **identity);
+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,
+		char **identity);
 
 /**
  * nvme_generate_tls_key_identity_compat() - Generate the TLS key identity
+ * @ctx:	struct nvme_global_ctx object
  * @hostnqn:	Host NVMe Qualified Name
  * @subsysnqn:	Subsystem NVMe Qualified Name
  * @version:	Key version to use
@@ -608,25 +630,26 @@ int nvme_generate_tls_key_identity(const char *hostnqn, const char *subsysnqn,
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_generate_tls_key_identity_compat(const char *hostnqn,
-					  const char *subsysnqn,
-					  int version, int hmac,
-					  unsigned char *configured_key,
-					  int key_len, char **identity);
+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 **identity);
 
 /**
  * nvme_revoke_tls_key() - Revoke TLS key from keyring
+ * @ctx:	struct nvme_global_ctx object
  * @keyring:    Keyring to use
  * @key_type:    Type of the key to revoke
  * @identity:    Key identity string
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_revoke_tls_key(const char *keyring, const char *key_type,
-			const char *identity);
+int nvme_revoke_tls_key(struct nvme_global_ctx *ctx, const char *keyring,
+		const char *key_type, const char *identity);
 
 /**
  * nvme_export_tls_key() - Export a TLS key
+ * @ctx:	struct nvme_global_ctx object
  * @key_data:	Raw data of the key
  * @key_len:	Length of @key_data
  * @identity:	TLS identity
@@ -639,10 +662,12 @@ int nvme_revoke_tls_key(const char *keyring, const char *key_type,
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_export_tls_key(const unsigned char *key_data, int key_len, char **identity);
+int nvme_export_tls_key(struct nvme_global_ctx *ctx,
+		const unsigned char *key_data, int key_len, char **identity);
 
 /**
  * nvme_export_tls_key_versioned() - Export a TLS pre-shared key
+ * @ctx:	struct nvme_global_ctx object
  * @version:	Indicated the representation of the TLS PSK
  * @hmac:	HMAC algorithm used to transfor the configured PSK
  *		in a retained PSK
@@ -658,12 +683,14 @@ int nvme_export_tls_key(const unsigned char *key_data, int key_len, char **ident
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_export_tls_key_versioned(unsigned char version, unsigned char hmac,
-				  const unsigned char *key_data,
-				  size_t key_len, char **identity);
+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 **identity);
 
 /**
  * nvme_import_tls_key() - Import a TLS key
+ * @ctx:		struct nvme_global_ctx object
  * @encoded_key:	TLS key in PSK interchange format
  * @key_len:		Length of the resulting key data
  * @hmac:		HMAC algorithm
@@ -676,11 +703,12 @@ int nvme_export_tls_key_versioned(unsigned char version, unsigned char hmac,
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_import_tls_key(const char *encoded_key, int *key_len,
-			unsigned int *hmac, unsigned char **key);
+int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encoded_key,
+		 int *key_len, unsigned int *hmac, unsigned char **key);
 
 /**
  * nvme_import_tls_key_versioned() - Import a TLS key
+ * @ctx:		struct nvme_global_ctx object
  * @encoded_key:	TLS key in PSK interchange format
  * @version:		Indicated the representation of the TLS PSK
  * @hmac:		HMAC algorithm used to transfor the configured
@@ -695,11 +723,9 @@ int nvme_import_tls_key(const char *encoded_key, int *key_len,
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_import_tls_key_versioned(const char *encoded_key,
-				  unsigned char *version,
-				  unsigned char *hmac,
-				  size_t *key_len,
-				  unsigned char **key);
+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 **key);
 
 /**
  * nvme_set_dry_run() - Set global dry run state
diff --git a/libnvme/src/nvme/log.c b/libnvme/src/nvme/log.c
index 95d0e99aa3..1e5e880809 100644
--- a/libnvme/src/nvme/log.c
+++ b/libnvme/src/nvme/log.c
@@ -10,12 +10,10 @@
 
 #include <sys/types.h>
 #include <stdio.h>
-#include <stdlib.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include "platform/platform_includes.h"  /* Platform abstraction - includes syslog */
 #include <time.h>
-#include <string.h>
 #define LOG_FUNCNAME 1
 #include "private.h"
 #include "log.h"
@@ -25,18 +23,11 @@
 #define LOG_CLOCK CLOCK_MONOTONIC
 #endif
 
-static struct nvme_log def_log = {
-	.fd = STDERR_FILENO,
-	.level = DEFAULT_LOGLEVEL,
-	.pid = false,
-	.timestamp = false,
-};
-
 void __attribute__((format(printf, 4, 5)))
 __nvme_msg(struct nvme_global_ctx *ctx, int level,
 	   const char *func, const char *format, ...)
 {
-	struct nvme_log *l;
+	struct nvme_log *l = &ctx->log;
 	va_list ap;
 	char pidbuf[16];
 	char timebuf[32];
@@ -54,11 +45,6 @@ __nvme_msg(struct nvme_global_ctx *ctx, int level,
 	_cleanup_free_ char *message = NULL;
 	int idx = 0;
 
-	if (ctx)
-		l = &ctx->log;
-	else
-		l = &def_log;
-
 	if (level > l->level)
 		return;
 
@@ -95,51 +81,20 @@ __nvme_msg(struct nvme_global_ctx *ctx, int level,
 		message ? message : "<error>");
 }
 
-void nvme_init_logging(struct nvme_global_ctx *ctx, int lvl, bool log_pid, bool log_tstamp)
+void nvme_init_logging(struct nvme_global_ctx *ctx, int lvl,
+		bool log_pid, bool log_tstamp)
 {
 	ctx->log.level = lvl;
 	ctx->log.pid = log_pid;
 	ctx->log.timestamp = log_tstamp;
 }
 
-int nvme_get_logging_level(struct nvme_global_ctx *ctx, bool *log_pid, bool *log_tstamp)
+int nvme_get_logging_level(struct nvme_global_ctx *ctx,
+		bool *log_pid, bool *log_tstamp)
 {
-	struct nvme_log *l;
-
-	if (ctx)
-		l = &ctx->log;
-	else
-		l = &def_log;
-
 	if (log_pid)
-		*log_pid = l->pid;
+		*log_pid = ctx->log.pid;
 	if (log_tstamp)
-		*log_tstamp = l->timestamp;
-	return l->level;
-}
-
-void nvme_init_default_logging(FILE *fp, int level, bool log_pid, bool log_tstamp)
-{
-	def_log.fd = fileno(fp);
-	def_log.level = level;
-	def_log.pid = log_pid;
-	def_log.timestamp = log_tstamp;
-}
-
-void nvme_set_global_ctx(struct nvme_global_ctx *ctx)
-{
-	def_log.fd = ctx->log.fd;
-	def_log.level = ctx->log.level;
-	def_log.pid = ctx->log.pid;
-	def_log.timestamp = ctx->log.timestamp;
-}
-
-void nvme_set_debug(bool debug)
-{
-	def_log.level = debug ? LOG_DEBUG : DEFAULT_LOGLEVEL;
-}
-
-bool nvme_get_debug(void)
-{
-	return def_log.level == LOG_DEBUG;
+		*log_tstamp = ctx->log.timestamp;
+	return ctx->log.level;
 }
diff --git a/libnvme/src/nvme/log.h b/libnvme/src/nvme/log.h
index 5bd4bad4ad..dfe9624830 100644
--- a/libnvme/src/nvme/log.h
+++ b/libnvme/src/nvme/log.h
@@ -33,7 +33,8 @@
  *
  * Sets the default logging variables for the library.
  */
-void nvme_init_logging(struct nvme_global_ctx *ctx, int lvl, bool log_pid, bool log_tstamp);
+void nvme_init_logging(struct nvme_global_ctx *ctx, int lvl,
+		bool log_pid, bool log_tstamp);
 
 /**
  * nvme_init_default_logging() - Initialize default (fallback) logging
@@ -45,7 +46,8 @@ void nvme_init_logging(struct nvme_global_ctx *ctx, int lvl, bool log_pid, bool
  * Sets the default logging settings for the library in case the root object
  * is absent.
  */
-void nvme_init_default_logging(FILE *fp, int lvl, bool log_pid, bool log_tstamp);
+void nvme_init_default_logging(FILE *fp, int lvl, bool log_pid,
+		bool log_tstamp);
 
 /**
  * nvme_get_logging_level() - Get current logging level
@@ -59,40 +61,7 @@ void nvme_init_default_logging(FILE *fp, int lvl, bool log_pid, bool log_tstamp)
  *
  * Return: current log level value or DEFAULT_LOGLEVEL if not initialized.
  */
-int nvme_get_logging_level(struct nvme_global_ctx *ctx, bool *log_pid, bool *log_tstamp);
-
-/**
- * nvme_set_global_ctx() - Set global context
- * @ctx:		struct nvme_global_ctx object
- *
- * In order to be able to log from code paths where no global context
- * object is passed in via the arguments use the the default one which
- * can be set via this call. When creating a new global context object
- * with @nvme_create_global_ctx the global context object will be set as
- * well. This means the global context object is always pointing to the
- * latest created global context object. Note the first
- * @nvme_free_global_ctx call will reset the global context object.
- *
- * This function is deprecated. Use nvme_init_default_logging or/and
- * nvme_init_logging instead.
- */
-void nvme_set_global_ctx(struct nvme_global_ctx *ctx) __attribute__((deprecated));
-
-/**
- * nvme_set_debug - Set NVMe command debugging output
- * @debug:	true to enable or false to disable
- *
- * This function is deprecated. Use nvme_init_default_logging instead.
- */
-void nvme_set_debug(bool debug) __attribute__((deprecated));
-
-/**
- * nvme_get_debug - Get NVMe command debugging output
- *
- * This function is deprecated. Use nvme_get_logging_level instead.
- *
- * Return: false if disabled or true if enabled.
- */
-bool nvme_get_debug(void) __attribute__((deprecated));
+int nvme_get_logging_level(struct nvme_global_ctx *ctx, bool *log_pid,
+		bool *log_tstamp);
 
 #endif /* _LOG_H */
diff --git a/libnvme/src/nvme/nbft.c b/libnvme/src/nvme/nbft.c
index b5de827b3c..13cb0f50f4 100644
--- a/libnvme/src/nvme/nbft.c
+++ b/libnvme/src/nvme/nbft.c
@@ -7,7 +7,6 @@
  *
  */
 
-#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -18,6 +17,10 @@
 #include "nbft.h"
 #include "log.h"
 
+#ifndef MIN
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#endif
+
 static __u8 csum(const __u8 *buffer, ssize_t length)
 {
 	int n;
@@ -69,27 +72,28 @@ static char *trtype_to_string(__u8 transport_type)
 	}
 }
 
-#define verify(condition, message)					\
+#define verify(ctx, condition, message)					\
 	do {								\
 		if (!(condition)) {					\
-			nvme_msg(NULL, LOG_DEBUG, "file %s: " message "\n", \
+			nvme_msg(ctx, LOG_DEBUG, "file %s: " message "\n", \
 				 nbft->filename);			\
 			return -EINVAL;					\
 		}							\
 	} while (0)
 
-static int __get_heap_obj(struct nbft_header *header, const char *filename,
-			  const char *descriptorname, const char *fieldname,
-			  struct nbft_heap_obj obj, bool is_string,
-			  char **output)
+static int __get_heap_obj(struct nvme_global_ctx *ctx,
+		struct nbft_header *header, const char *filename,
+		const char *descriptorname, const char *fieldname,
+		struct nbft_heap_obj obj, bool is_string,
+		char **output)
 {
 	if (le16_to_cpu(obj.length) == 0)
 		return -ENOENT;
 
 	if (!in_heap(header, obj)) {
-		nvme_msg(NULL, LOG_DEBUG,
-			 "file %s: field '%s' in descriptor '%s' has invalid offset or length\n",
-			 filename, fieldname, descriptorname);
+		nvme_msg(ctx, LOG_DEBUG,
+			"file %s: field '%s' in descriptor '%s' has invalid offset or length\n",
+			filename, fieldname, descriptorname);
 		return -EINVAL;
 	}
 
@@ -97,17 +101,18 @@ static int __get_heap_obj(struct nbft_header *header, const char *filename,
 	*output = (char *)header + le32_to_cpu(obj.offset);
 
 	if (is_string) {
-		if (strnlen(*output, le16_to_cpu(obj.length) + 1) < le16_to_cpu(obj.length)) {
-			nvme_msg(NULL, LOG_DEBUG,
+		if (strnlen(*output, le16_to_cpu(obj.length) + 1) <
+				le16_to_cpu(obj.length)) {
+			nvme_msg(ctx, LOG_DEBUG,
 				"file %s: string '%s' in descriptor '%s' is shorter (%u) than specified length (%u)\n",
 				filename, fieldname, descriptorname,
 				(unsigned int)strnlen(*output, le16_to_cpu(obj.length) + 1),
-				le16_to_cpu(obj.length));
+					le16_to_cpu(obj.length));
 		} else if (strnlen(*output, le16_to_cpu(obj.length) + 1) >
-			le16_to_cpu(obj.length)) {
-			nvme_msg(NULL, LOG_DEBUG,
-				 "file %s: string '%s' in descriptor '%s' is not zero terminated\n",
-				 filename, fieldname, descriptorname);
+				le16_to_cpu(obj.length)) {
+			nvme_msg(ctx, LOG_DEBUG,
+				"file %s: string '%s' in descriptor '%s' is not zero terminated\n",
+				filename, fieldname, descriptorname);
 			return -EINVAL;
 		}
 	}
@@ -115,13 +120,14 @@ static int __get_heap_obj(struct nbft_header *header, const char *filename,
 	return 0;
 }
 
-#define get_heap_obj(descriptor, obj, is_string, output)	\
-	__get_heap_obj(header, nbft->filename,			\
+#define get_heap_obj(ctx, descriptor, obj, is_string, output)	\
+	__get_heap_obj(ctx, header, nbft->filename,		\
 		       stringify(descriptor), stringify(obj),	\
 		       descriptor->obj, is_string,		\
 		       output)
 
-static struct nbft_info_discovery *discovery_from_index(struct nbft_info *nbft, int i)
+static struct nbft_info_discovery *discovery_from_index(struct nbft_info *nbft,
+		int i)
 {
 	struct nbft_info_discovery **d;
 
@@ -143,7 +149,8 @@ static struct nbft_info_hfi *hfi_from_index(struct nbft_info *nbft, int i)
 	return NULL;
 }
 
-static struct nbft_info_security *security_from_index(struct nbft_info *nbft, int i)
+static struct nbft_info_security *security_from_index(struct nbft_info *nbft,
+		int i)
 {
 	struct nbft_info_security **s;
 
@@ -154,17 +161,17 @@ static struct nbft_info_security *security_from_index(struct nbft_info *nbft, in
 	return NULL;
 }
 
-static int read_ssns_exended_info(struct nbft_info *nbft,
-				  struct nbft_info_subsystem_ns *ssns,
-				  struct nbft_ssns_ext_info *raw_ssns_ei)
+static int read_ssns_exended_info(struct nvme_global_ctx *ctx,
+		struct nbft_info *nbft, struct nbft_info_subsystem_ns *ssns,
+		struct nbft_ssns_ext_info *raw_ssns_ei)
 {
 	struct nbft_header *header = (struct nbft_header *)nbft->raw_nbft;
 
-	verify(raw_ssns_ei->structure_id == NBFT_DESC_SSNS_EXT_INFO,
+	verify(ctx, raw_ssns_ei->structure_id == NBFT_DESC_SSNS_EXT_INFO,
 	       "invalid ID in SSNS extended info descriptor");
-	verify(raw_ssns_ei->version == 1,
+	verify(ctx, raw_ssns_ei->version == 1,
 	       "invalid version in SSNS extended info descriptor");
-	verify(le16_to_cpu(raw_ssns_ei->ssns_index) == ssns->index,
+	verify(ctx, le16_to_cpu(raw_ssns_ei->ssns_index) == ssns->index,
 	       "SSNS index doesn't match extended info descriptor index");
 
 	if (!(le32_to_cpu(raw_ssns_ei->flags) & NBFT_SSNS_EXT_INFO_VALID))
@@ -173,14 +180,15 @@ static int read_ssns_exended_info(struct nbft_info *nbft,
 	if (le32_to_cpu(raw_ssns_ei->flags) & NBFT_SSNS_EXT_INFO_ADMIN_ASQSZ)
 		ssns->asqsz = le16_to_cpu(raw_ssns_ei->asqsz);
 	ssns->controller_id = le16_to_cpu(raw_ssns_ei->cntlid);
-	get_heap_obj(raw_ssns_ei, dhcp_root_path_str_obj, 1, &ssns->dhcp_root_path_string);
+	get_heap_obj(ctx, raw_ssns_ei, dhcp_root_path_str_obj, 1,
+		&ssns->dhcp_root_path_string);
 
 	return 0;
 }
 
-static int read_ssns(struct nbft_info *nbft,
-		     struct nbft_ssns *raw_ssns,
-		     struct nbft_info_subsystem_ns **s)
+static int read_ssns(struct nvme_global_ctx *ctx,
+		struct nbft_info *nbft, struct nbft_ssns *raw_ssns,
+		struct nbft_info_subsystem_ns **s)
 {
 	struct nbft_header *header = (struct nbft_header *)nbft->raw_nbft;
 	struct nbft_info_subsystem_ns *ssns;
@@ -191,11 +199,11 @@ static int read_ssns(struct nbft_info *nbft,
 	if (!(le16_to_cpu(raw_ssns->flags) & NBFT_SSNS_VALID))
 		return -EINVAL;
 
-	verify(raw_ssns->structure_id == NBFT_DESC_SSNS,
+	verify(ctx, raw_ssns->structure_id == NBFT_DESC_SSNS,
 	       "invalid ID in SSNS descriptor");
 
 	/* verify transport type */
-	verify(raw_ssns->trtype == NBFT_TRTYPE_TCP,
+	verify(ctx, raw_ssns->trtype == NBFT_TRTYPE_TCP,
 	       "invalid transport type in SSNS descriptor");
 
 	ssns = calloc(1, sizeof(*ssns));
@@ -203,35 +211,39 @@ static int read_ssns(struct nbft_info *nbft,
 		return -ENOMEM;
 
 	ssns->index = le16_to_cpu(raw_ssns->index);
-	strncpy(ssns->transport, trtype_to_string(raw_ssns->trtype), sizeof(ssns->transport));
+	strncpy(ssns->transport, trtype_to_string(raw_ssns->trtype),
+		sizeof(ssns->transport));
 
 	/* transport specific flags */
 	if (raw_ssns->trtype == NBFT_TRTYPE_TCP) {
-		if (le16_to_cpu(raw_ssns->trflags) & NBFT_SSNS_PDU_HEADER_DIGEST)
+		if (le16_to_cpu(raw_ssns->trflags) &
+				NBFT_SSNS_PDU_HEADER_DIGEST)
 			ssns->pdu_header_digest_required = true;
-		if (le16_to_cpu(raw_ssns->trflags) & NBFT_SSNS_DATA_DIGEST)
+		if (le16_to_cpu(raw_ssns->trflags) &
+				NBFT_SSNS_DATA_DIGEST)
 			ssns->data_digest_required = true;
 	}
 
 	/* primary discovery controller */
 	if (raw_ssns->primary_discovery_ctrl_index) {
 		ssns->discovery = discovery_from_index(nbft,
-						       raw_ssns->primary_discovery_ctrl_index);
+			raw_ssns->primary_discovery_ctrl_index);
 		if (!ssns->discovery)
-			nvme_msg(NULL, LOG_DEBUG,
+			nvme_msg(ctx, LOG_DEBUG,
 				 "file %s: namespace %d discovery controller not found\n",
 				 nbft->filename, ssns->index);
 	}
 
 	/* subsystem transport address */
-	ret = get_heap_obj(raw_ssns, subsys_traddr_obj, 0, (char **)&tmp);
+	ret = get_heap_obj(ctx, raw_ssns, subsys_traddr_obj, 0, (char **)&tmp);
 	if (ret)
 		goto fail;
 
 	format_ip_addr(ssns->traddr, sizeof(ssns->traddr), tmp);
 
 	/* subsystem transport service identifier */
-	ret = get_heap_obj(raw_ssns, subsys_trsvcid_obj, 1, &ssns->trsvcid);
+	ret = get_heap_obj(ctx, raw_ssns, subsys_trsvcid_obj,
+		1, &ssns->trsvcid);
 	if (ret)
 		goto fail;
 
@@ -251,34 +263,39 @@ static int read_ssns(struct nbft_info *nbft,
 
 	/* security profile */
 	if (raw_ssns->security_desc_index) {
-		ssns->security = security_from_index(nbft, raw_ssns->security_desc_index);
+		ssns->security = security_from_index(nbft,
+			raw_ssns->security_desc_index);
 		if (!ssns->security)
-			nvme_msg(NULL, LOG_DEBUG,
+			nvme_msg(ctx, LOG_DEBUG,
 				 "file %s: namespace %d security controller not found\n",
 				 nbft->filename, ssns->index);
 	}
 
 	/* HFI descriptors */
-	ret = get_heap_obj(raw_ssns, secondary_hfi_assoc_obj, 0, (char **)&ss_hfi_indexes);
+	ret = get_heap_obj(ctx, raw_ssns, secondary_hfi_assoc_obj,
+		0, (char **)&ss_hfi_indexes);
 	if (ret)
 		goto fail;
 
-	ssns->hfis = calloc(le16_to_cpu(raw_ssns->secondary_hfi_assoc_obj.length) + 2,
-			    sizeof(*ssns->hfis));
+	ssns->hfis =
+		calloc(le16_to_cpu(raw_ssns->secondary_hfi_assoc_obj.length) +
+			2, sizeof(*ssns->hfis));
 	if (!ssns->hfis) {
 		ret = -ENOMEM;
 		goto fail;
 	}
 	ssns->hfis[0] = hfi_from_index(nbft, raw_ssns->primary_hfi_desc_index);
 	if (!ssns->hfis[0]) {
-		nvme_msg(NULL, LOG_DEBUG,
-			 "file %s: SSNS %d: HFI %d not found\n",
-			 nbft->filename, ssns->index, raw_ssns->primary_hfi_desc_index);
+		nvme_msg(ctx, LOG_DEBUG,
+			"file %s: SSNS %d: HFI %d not found\n",
+			nbft->filename, ssns->index,
+			raw_ssns->primary_hfi_desc_index);
 		ret = -EINVAL;
 		goto fail;
 	}
 	ssns->num_hfis = 1;
-	for (i = 0; i < le16_to_cpu(raw_ssns->secondary_hfi_assoc_obj.length); i++) {
+	for (i = 0; i < le16_to_cpu(raw_ssns->secondary_hfi_assoc_obj.length);
+			i++) {
 		bool duplicate = false;
 		int j;
 
@@ -294,23 +311,24 @@ static int read_ssns(struct nbft_info *nbft,
 			duplicate = true;
 
 		if (duplicate) {
-			nvme_msg(NULL, LOG_DEBUG,
-				 "file %s: SSNS %d skipping duplicate HFI index %d\n",
-				 nbft->filename, ssns->index, ss_hfi_indexes[i]);
+			nvme_msg(ctx, LOG_DEBUG,
+				"file %s: SSNS %d skipping duplicate HFI index %d\n",
+				nbft->filename, ssns->index, ss_hfi_indexes[i]);
 			continue;
 		}
 
 		ssns->hfis[i + 1] = hfi_from_index(nbft, ss_hfi_indexes[i]);
 		if (ss_hfi_indexes[i] && !ssns->hfis[i + 1])
-			nvme_msg(NULL, LOG_DEBUG,
-				 "file %s: SSNS %d HFI %d not found\n",
-				 nbft->filename, ssns->index, ss_hfi_indexes[i]);
+			nvme_msg(ctx, LOG_DEBUG,
+				"file %s: SSNS %d HFI %d not found\n",
+				nbft->filename, ssns->index, ss_hfi_indexes[i]);
 		else
 			ssns->num_hfis++;
 	}
 
 	/* SSNS NQN */
-	ret = get_heap_obj(raw_ssns, subsys_ns_nqn_obj, 1, &ssns->subsys_nqn);
+	ret = get_heap_obj(ctx, raw_ssns, subsys_ns_nqn_obj,
+		1, &ssns->subsys_nqn);
 	if (ret)
 		goto fail;
 
@@ -318,9 +336,11 @@ static int read_ssns(struct nbft_info *nbft,
 	if (le16_to_cpu(raw_ssns->flags) & NBFT_SSNS_EXTENDED_INFO_IN_USE) {
 		struct nbft_ssns_ext_info *ssns_extended_info;
 
-		if (!get_heap_obj(raw_ssns, ssns_extended_info_desc_obj, 0,
-				  (char **)&ssns_extended_info))
-			read_ssns_exended_info(nbft, ssns, ssns_extended_info);
+		if (!get_heap_obj(ctx, raw_ssns, ssns_extended_info_desc_obj,
+				0, (char **)&ssns_extended_info)) {
+			read_ssns_exended_info(ctx, nbft, ssns,
+				ssns_extended_info);
+		}
 	}
 
 	*s = ssns;
@@ -331,57 +351,59 @@ static int read_ssns(struct nbft_info *nbft,
 	return ret;
 }
 
-static int read_hfi_info_tcp(struct nbft_info *nbft,
-			     struct nbft_hfi_info_tcp *raw_hfi_info_tcp,
-			     struct nbft_info_hfi *hfi)
+static int read_hfi_info_tcp(struct nvme_global_ctx *ctx,
+		struct nbft_info *nbft,
+		struct nbft_hfi_info_tcp *raw_hfi_info_tcp,
+		struct nbft_info_hfi *hfi)
 {
 	struct nbft_header *header = (struct nbft_header *)nbft->raw_nbft;
 
 	if ((raw_hfi_info_tcp->flags & NBFT_HFI_INFO_TCP_VALID) == 0)
 		return -EINVAL;
 
-	verify(raw_hfi_info_tcp->structure_id == NBFT_DESC_HFI_TRINFO,
+	verify(ctx, raw_hfi_info_tcp->structure_id == NBFT_DESC_HFI_TRINFO,
 	       "invalid ID in HFI transport descriptor");
-	verify(raw_hfi_info_tcp->version == 1,
+	verify(ctx, raw_hfi_info_tcp->version == 1,
 	       "invalid version in HFI transport descriptor");
 	if (le16_to_cpu(raw_hfi_info_tcp->hfi_index) != hfi->index)
-		nvme_msg(NULL, LOG_DEBUG,
-			 "file %s: HFI descriptor index %d does not match index in HFI transport descriptor\n",
-			 nbft->filename, hfi->index);
+		nvme_msg(ctx, LOG_DEBUG,
+			"file %s: HFI descriptor index %d does not match index in HFI transport descriptor\n",
+			nbft->filename, hfi->index);
 
 	hfi->tcp_info.pci_sbdf = le32_to_cpu(raw_hfi_info_tcp->pci_sbdf);
 	memcpy(hfi->tcp_info.mac_addr, raw_hfi_info_tcp->mac_addr,
-	       sizeof(raw_hfi_info_tcp->mac_addr));
+		sizeof(raw_hfi_info_tcp->mac_addr));
 	hfi->tcp_info.vlan = le16_to_cpu(raw_hfi_info_tcp->vlan);
 	hfi->tcp_info.ip_origin = raw_hfi_info_tcp->ip_origin;
 	format_ip_addr(hfi->tcp_info.ipaddr, sizeof(hfi->tcp_info.ipaddr),
-		       raw_hfi_info_tcp->ip_address);
+		raw_hfi_info_tcp->ip_address);
 	hfi->tcp_info.subnet_mask_prefix = raw_hfi_info_tcp->subnet_mask_prefix;
-	format_ip_addr(hfi->tcp_info.gateway_ipaddr, sizeof(hfi->tcp_info.ipaddr),
-		       raw_hfi_info_tcp->ip_gateway);
-	hfi->tcp_info.route_metric = le16_to_cpu(raw_hfi_info_tcp->route_metric);
+	format_ip_addr(hfi->tcp_info.gateway_ipaddr,
+		sizeof(hfi->tcp_info.ipaddr), raw_hfi_info_tcp->ip_gateway);
+	hfi->tcp_info.route_metric =
+		le16_to_cpu(raw_hfi_info_tcp->route_metric);
 	format_ip_addr(hfi->tcp_info.primary_dns_ipaddr,
-		       sizeof(hfi->tcp_info.primary_dns_ipaddr),
-		       raw_hfi_info_tcp->primary_dns);
+		sizeof(hfi->tcp_info.primary_dns_ipaddr),
+		raw_hfi_info_tcp->primary_dns);
 	format_ip_addr(hfi->tcp_info.secondary_dns_ipaddr,
-		       sizeof(hfi->tcp_info.secondary_dns_ipaddr),
-		       raw_hfi_info_tcp->secondary_dns);
+		sizeof(hfi->tcp_info.secondary_dns_ipaddr),
+		raw_hfi_info_tcp->secondary_dns);
 	if (raw_hfi_info_tcp->flags & NBFT_HFI_INFO_TCP_DHCP_OVERRIDE) {
 		hfi->tcp_info.dhcp_override = true;
 		format_ip_addr(hfi->tcp_info.dhcp_server_ipaddr,
-			       sizeof(hfi->tcp_info.dhcp_server_ipaddr),
-			       raw_hfi_info_tcp->dhcp_server);
+			sizeof(hfi->tcp_info.dhcp_server_ipaddr),
+			raw_hfi_info_tcp->dhcp_server);
 	}
-	get_heap_obj(raw_hfi_info_tcp, host_name_obj, 1, &hfi->tcp_info.host_name);
+	get_heap_obj(ctx, raw_hfi_info_tcp, host_name_obj,
+		1, &hfi->tcp_info.host_name);
 	if (raw_hfi_info_tcp->flags & NBFT_HFI_INFO_TCP_GLOBAL_ROUTE)
 		hfi->tcp_info.this_hfi_is_default_route = true;
 
 	return 0;
 }
 
-static int read_hfi(struct nbft_info *nbft,
-		    struct nbft_hfi *raw_hfi,
-		    struct nbft_info_hfi **h)
+static int read_hfi(struct nvme_global_ctx *ctx, struct nbft_info *nbft,
+		struct nbft_hfi *raw_hfi, struct nbft_info_hfi **h)
 {
 	int ret;
 	struct nbft_info_hfi *hfi;
@@ -390,8 +412,8 @@ static int read_hfi(struct nbft_info *nbft,
 	if (!(raw_hfi->flags & NBFT_HFI_VALID))
 		return -EINVAL;
 
-	verify(raw_hfi->structure_id == NBFT_DESC_HFI,
-	       "invalid ID in HFI descriptor");
+	verify(ctx, raw_hfi->structure_id == NBFT_DESC_HFI,
+		"invalid ID in HFI descriptor");
 
 	hfi = calloc(1, sizeof(struct nbft_info_hfi));
 	if (!hfi)
@@ -409,15 +431,16 @@ static int read_hfi(struct nbft_info *nbft,
 		strncpy(hfi->transport, trtype_to_string(raw_hfi->trtype),
 			sizeof(hfi->transport));
 
-		ret = get_heap_obj(raw_hfi, trinfo_obj, 0, (char **)&raw_hfi_info_tcp);
+		ret = get_heap_obj(ctx, raw_hfi, trinfo_obj,
+			0, (char **)&raw_hfi_info_tcp);
 		if (ret)
 			goto fail;
 
-		ret = read_hfi_info_tcp(nbft, raw_hfi_info_tcp, hfi);
+		ret = read_hfi_info_tcp(ctx, nbft, raw_hfi_info_tcp, hfi);
 		if (ret)
 			goto fail;
 	} else {
-		nvme_msg(NULL, LOG_DEBUG,
+		nvme_msg(ctx, LOG_DEBUG,
 			 "file %s: invalid transport type %d\n",
 			 nbft->filename, raw_hfi->trtype);
 		ret = -EINVAL;
@@ -432,9 +455,10 @@ static int read_hfi(struct nbft_info *nbft,
 	return ret;
 }
 
-static int read_discovery(struct nbft_info *nbft,
-			  struct nbft_discovery *raw_discovery,
-			  struct nbft_info_discovery **d)
+static int read_discovery(struct nvme_global_ctx *ctx,
+		struct nbft_info *nbft,
+		struct nbft_discovery *raw_discovery,
+		struct nbft_info_discovery **d)
 {
 	struct nbft_info_discovery *discovery = NULL;
 	struct nbft_header *header = (struct nbft_header *)nbft->raw_nbft;
@@ -443,7 +467,7 @@ static int read_discovery(struct nbft_info *nbft,
 	if (!(raw_discovery->flags & NBFT_DISCOVERY_VALID))
 		goto error;
 
-	verify(raw_discovery->structure_id == NBFT_DESC_DISCOVERY,
+	verify(ctx, raw_discovery->structure_id == NBFT_DESC_DISCOVERY,
 	       "invalid ID in discovery descriptor");
 
 	discovery = calloc(1, sizeof(struct nbft_info_discovery));
@@ -454,21 +478,24 @@ static int read_discovery(struct nbft_info *nbft,
 
 	discovery->index = raw_discovery->index;
 
-	if (get_heap_obj(raw_discovery, discovery_ctrl_addr_obj, 1, &discovery->uri))
+	if (get_heap_obj(ctx, raw_discovery, discovery_ctrl_addr_obj,
+			1, &discovery->uri))
 		goto error;
 
-	if (get_heap_obj(raw_discovery, discovery_ctrl_nqn_obj, 1, &discovery->nqn))
+	if (get_heap_obj(ctx, raw_discovery, discovery_ctrl_nqn_obj,
+			1, &discovery->nqn))
 		goto error;
 
 	discovery->hfi = hfi_from_index(nbft, raw_discovery->hfi_index);
 	if (raw_discovery->hfi_index && !discovery->hfi)
-		nvme_msg(NULL, LOG_DEBUG,
+		nvme_msg(ctx, LOG_DEBUG,
 			 "file %s: discovery %d HFI not found\n",
 			 nbft->filename, discovery->index);
 
-	discovery->security = security_from_index(nbft, raw_discovery->sec_index);
+	discovery->security =
+		security_from_index(nbft, raw_discovery->sec_index);
 	if (raw_discovery->sec_index && !discovery->security)
-		nvme_msg(NULL, LOG_DEBUG,
+		nvme_msg(ctx, LOG_DEBUG,
 			 "file %s: discovery %d security descriptor not found\n",
 			 nbft->filename, discovery->index);
 
@@ -481,57 +508,68 @@ static int read_discovery(struct nbft_info *nbft,
 	return r;
 }
 
-static int read_security(struct nbft_info *nbft,
-			 struct nbft_security *raw_security,
-			 struct nbft_info_security **s)
+static int read_security(struct nvme_global_ctx *ctx, struct nbft_info *nbft,
+		struct nbft_security *raw_security,
+		struct nbft_info_security **s)
 {
 	return -EINVAL;
 }
 
-static void read_hfi_descriptors(struct nbft_info *nbft, int num_hfi,
-				 struct nbft_hfi *raw_hfi_array, int hfi_len)
+static void read_hfi_descriptors(struct nvme_global_ctx *ctx,
+		struct nbft_info *nbft, int num_hfi,
+		struct nbft_hfi *raw_hfi_array, int hfi_len)
 {
 	int i, cnt;
 
 	nbft->hfi_list = calloc(num_hfi + 1, sizeof(struct nbft_info_hfi));
 	for (i = 0, cnt = 0; i < num_hfi; i++) {
-		if (read_hfi(nbft, &raw_hfi_array[i], &nbft->hfi_list[cnt]) == 0)
+		if (read_hfi(ctx, nbft, &raw_hfi_array[i],
+				&nbft->hfi_list[cnt]) == 0)
 			cnt++;
 	}
 }
 
-static void read_security_descriptors(struct nbft_info *nbft, int num_sec,
-				      struct nbft_security *raw_sec_array, int sec_len)
+static void read_security_descriptors(struct nvme_global_ctx *ctx,
+		struct nbft_info *nbft, int num_sec,
+		struct nbft_security *raw_sec_array, int sec_len)
 {
 	int i, cnt;
 
-	nbft->security_list = calloc(num_sec + 1, sizeof(struct nbft_info_security));
+	nbft->security_list = calloc(num_sec + 1,
+		sizeof(struct nbft_info_security));
 	for (i = 0, cnt = 0; i < num_sec; i++) {
-		if (read_security(nbft, &raw_sec_array[i], &nbft->security_list[cnt]) == 0)
+		if (read_security(ctx, nbft, &raw_sec_array[i],
+				&nbft->security_list[cnt]) == 0)
 			cnt++;
 	}
 }
 
-static void read_discovery_descriptors(struct nbft_info *nbft, int num_disc,
-				       struct nbft_discovery *raw_disc_array, int disc_len)
+static void read_discovery_descriptors(struct nvme_global_ctx *ctx,
+		struct nbft_info *nbft, int num_disc,
+		struct nbft_discovery *raw_disc_array, int disc_len)
 {
 	int i, cnt;
 
-	nbft->discovery_list = calloc(num_disc + 1, sizeof(struct nbft_info_discovery));
+	nbft->discovery_list =
+		calloc(num_disc + 1, sizeof(struct nbft_info_discovery));
 	for (i = 0, cnt = 0; i < num_disc; i++) {
-		if (read_discovery(nbft, &raw_disc_array[i], &nbft->discovery_list[cnt]) == 0)
+		if (read_discovery(ctx, nbft, &raw_disc_array[i],
+				&nbft->discovery_list[cnt]) == 0)
 			cnt++;
 	}
 }
 
-static void read_ssns_descriptors(struct nbft_info *nbft, int num_ssns,
-				  struct nbft_ssns *raw_ssns_array, int ssns_len)
+static void read_ssns_descriptors(struct nvme_global_ctx *ctx,
+		struct nbft_info *nbft, int num_ssns,
+		struct nbft_ssns *raw_ssns_array, int ssns_len)
 {
 	int i, cnt;
 
-	nbft->subsystem_ns_list = calloc(num_ssns + 1, sizeof(struct nbft_info_subsystem_ns));
+	nbft->subsystem_ns_list =
+		 calloc(num_ssns + 1, sizeof(struct nbft_info_subsystem_ns));
 	for (i = 0, cnt = 0; i < num_ssns; i++) {
-		if (read_ssns(nbft, &raw_ssns_array[i], &nbft->subsystem_ns_list[cnt]) == 0)
+		if (read_ssns(ctx, nbft, &raw_ssns_array[i],
+				&nbft->subsystem_ns_list[cnt]) == 0)
 			cnt++;
 	}
 }
@@ -542,7 +580,7 @@ static void read_ssns_descriptors(struct nbft_info *nbft, int num_ssns,
  *
  * Returns 0 on success, errno otherwise.
  */
-static int parse_raw_nbft(struct nbft_info *nbft)
+static int parse_raw_nbft(struct nvme_global_ctx *ctx, struct nbft_info *nbft)
 {
 	__u8 *raw_nbft = nbft->raw_nbft;
 	int raw_nbft_size = nbft->raw_nbft_size;
@@ -551,48 +589,60 @@ static int parse_raw_nbft(struct nbft_info *nbft)
 	struct nbft_control *control;
 	struct nbft_host *host;
 
-	verify(raw_nbft_size >= sizeof(struct nbft_header) + sizeof(struct nbft_control),
+	verify(ctx, raw_nbft_size >=
+		sizeof(struct nbft_header) + sizeof(struct nbft_control),
 	       "table is too short");
-	verify(csum(raw_nbft, raw_nbft_size) == 0, "invalid checksum");
+	verify(ctx, csum(raw_nbft, raw_nbft_size) == 0, "invalid checksum");
 
 	/*
 	 * header
 	 */
 	header = (struct nbft_header *)raw_nbft;
 
-	verify(strncmp(header->signature, NBFT_HEADER_SIG, 4) == 0, "invalid signature");
-	verify(le32_to_cpu(header->length) <= raw_nbft_size, "length in header exceeds table length");
-	verify(header->major_revision == 1, "unsupported major revision");
-	verify(header->minor_revision == 0, "unsupported minor revision");
-	verify(le32_to_cpu(header->heap_length) + le32_to_cpu(header->heap_offset) <=
-	       le32_to_cpu(header->length), "heap exceeds table length");
+	verify(ctx, strncmp(header->signature, NBFT_HEADER_SIG, 4) == 0,
+		"invalid signature");
+	verify(ctx, le32_to_cpu(header->length) <= raw_nbft_size,
+		"length in header exceeds table length");
+	verify(ctx, header->major_revision == 1,
+		"unsupported major revision");
+	verify(ctx, header->minor_revision == 0,
+		"unsupported minor revision");
+	verify(ctx, le32_to_cpu(header->heap_length) +
+		le32_to_cpu(header->heap_offset) <= le32_to_cpu(header->length),
+		"heap exceeds table length");
 
 	/*
 	 * control
 	 */
-	control = (struct nbft_control *)(raw_nbft + sizeof(struct nbft_header));
+	control =
+		(struct nbft_control *)(raw_nbft + sizeof(struct nbft_header));
 
 	if ((control->flags & NBFT_CONTROL_VALID) == 0)
 		return 0;
-	verify(control->structure_id == NBFT_DESC_CONTROL,
+	verify(ctx, control->structure_id == NBFT_DESC_CONTROL,
 	       "invalid ID in control structure");
 
 	/*
 	 * host
 	 */
-	verify(le32_to_cpu(control->hdesc.offset) + sizeof(struct nbft_host) <=
-	       le32_to_cpu(header->length) &&
-	       le32_to_cpu(control->hdesc.offset) >= sizeof(struct nbft_host),
-	       "host descriptor offset/length is invalid");
-	host = (struct nbft_host *)(raw_nbft + le32_to_cpu(control->hdesc.offset));
-
-	verify(host->flags & NBFT_HOST_VALID, "host descriptor valid flag not set");
-	verify(host->structure_id == NBFT_DESC_HOST, "invalid ID in HOST descriptor");
+	verify(ctx, le32_to_cpu(control->hdesc.offset) +
+		sizeof(struct nbft_host) <= le32_to_cpu(header->length) &&
+		le32_to_cpu(control->hdesc.offset) >= sizeof(struct nbft_host),
+		"host descriptor offset/length is invalid");
+	host = (struct nbft_host *)(raw_nbft +
+		le32_to_cpu(control->hdesc.offset));
+
+	verify(ctx, host->flags & NBFT_HOST_VALID,
+		"host descriptor valid flag not set");
+	verify(ctx, host->structure_id == NBFT_DESC_HOST,
+		"invalid ID in HOST descriptor");
 	nbft->host.id = (unsigned char *) &(host->host_id);
-	if (get_heap_obj(host, host_nqn_obj, 1, &nbft->host.nqn) != 0)
+	if (get_heap_obj(ctx, host, host_nqn_obj, 1, &nbft->host.nqn) != 0)
 		return -EINVAL;
-	nbft->host.host_id_configured = host->flags & NBFT_HOST_HOSTID_CONFIGURED;
-	nbft->host.host_nqn_configured = host->flags & NBFT_HOST_HOSTNQN_CONFIGURED;
+	nbft->host.host_id_configured =
+		host->flags & NBFT_HOST_HOSTID_CONFIGURED;
+	nbft->host.host_nqn_configured =
+		host->flags & NBFT_HOST_HOSTNQN_CONFIGURED;
 
 	/*
 	 * HFI
@@ -600,11 +650,13 @@ static int parse_raw_nbft(struct nbft_info *nbft)
 	if (control->num_hfi > 0) {
 		struct nbft_hfi *raw_hfi_array;
 
-		verify(le32_to_cpu(control->hfio) + sizeof(struct nbft_hfi) *
-		       control->num_hfi <= le32_to_cpu(header->length),
+		verify(ctx, le32_to_cpu(control->hfio) +
+			sizeof(struct nbft_hfi) * control->num_hfi <=
+				le32_to_cpu(header->length),
 		       "invalid hfi descriptor list offset");
-		raw_hfi_array = (struct nbft_hfi *)(raw_nbft + le32_to_cpu(control->hfio));
-		read_hfi_descriptors(nbft, control->num_hfi, raw_hfi_array,
+		raw_hfi_array = (struct nbft_hfi *)(raw_nbft +
+			le32_to_cpu(control->hfio));
+		read_hfi_descriptors(ctx, nbft, control->num_hfi, raw_hfi_array,
 				     le16_to_cpu(control->hfil));
 	}
 
@@ -614,12 +666,13 @@ static int parse_raw_nbft(struct nbft_info *nbft)
 	if (control->num_sec > 0) {
 		struct nbft_security *raw_security_array;
 
-		verify(le32_to_cpu(control->seco) + le16_to_cpu(control->secl) *
-		       control->num_sec <= le32_to_cpu(header->length),
+		verify(ctx, le32_to_cpu(control->seco) +
+			le16_to_cpu(control->secl) * control->num_sec <=
+				le32_to_cpu(header->length),
 		       "invalid security profile desciptor list offset");
 		raw_security_array = (struct nbft_security *)(raw_nbft +
 				     le32_to_cpu(control->seco));
-		read_security_descriptors(nbft, control->num_sec,
+		read_security_descriptors(ctx, nbft, control->num_sec,
 					  raw_security_array,
 					  le16_to_cpu(control->secl));
 	}
@@ -630,13 +683,14 @@ static int parse_raw_nbft(struct nbft_info *nbft)
 	if (control->num_disc > 0) {
 		struct nbft_discovery *raw_discovery_array;
 
-		verify(le32_to_cpu(control->disco) + le16_to_cpu(control->discl) *
-		       control->num_disc <= le32_to_cpu(header->length),
+		verify(ctx, le32_to_cpu(control->disco) +
+			le16_to_cpu(control->discl) * control->num_disc <=
+				le32_to_cpu(header->length),
 		       "invalid discovery profile descriptor list offset");
 		raw_discovery_array = (struct nbft_discovery *)(raw_nbft +
-				      le32_to_cpu(control->disco));
-		read_discovery_descriptors(nbft, control->num_disc, raw_discovery_array,
-					   le16_to_cpu(control->discl));
+			le32_to_cpu(control->disco));
+		read_discovery_descriptors(ctx, nbft, control->num_disc,
+			raw_discovery_array, le16_to_cpu(control->discl));
 	}
 
 	/*
@@ -645,19 +699,20 @@ static int parse_raw_nbft(struct nbft_info *nbft)
 	if (control->num_ssns > 0) {
 		struct nbft_ssns *raw_ssns_array;
 
-		verify(le32_to_cpu(control->ssnso) + le16_to_cpu(control->ssnsl) *
-		       control->num_ssns <= le32_to_cpu(header->length),
+		verify(ctx, le32_to_cpu(control->ssnso) +
+			le16_to_cpu(control->ssnsl) * control->num_ssns <=
+				le32_to_cpu(header->length),
 		       "invalid subsystem namespace descriptor list offset");
 		raw_ssns_array = (struct nbft_ssns *)(raw_nbft +
-				 le32_to_cpu(control->ssnso));
-		read_ssns_descriptors(nbft, control->num_ssns, raw_ssns_array,
-				      le16_to_cpu(control->ssnsl));
+			le32_to_cpu(control->ssnso));
+		read_ssns_descriptors(ctx, nbft, control->num_ssns,
+			raw_ssns_array, le16_to_cpu(control->ssnsl));
 	}
 
 	return 0;
 }
 
-void nvme_nbft_free(struct nbft_info *nbft)
+void nvme_nbft_free(struct nvme_global_ctx *ctx, struct nbft_info *nbft)
 {
 	struct nbft_info_hfi **hfi;
 	struct nbft_info_security **sec;
@@ -683,7 +738,8 @@ void nvme_nbft_free(struct nbft_info *nbft)
 	free(nbft);
 }
 
-int nvme_nbft_read(struct nbft_info **nbft, const char *filename)
+int nvme_nbft_read(struct nvme_global_ctx *ctx, struct nbft_info **nbft,
+		const char *filename)
 {
 	__u8 *raw_nbft = NULL;
 	size_t raw_nbft_size;
@@ -695,14 +751,14 @@ int nvme_nbft_read(struct nbft_info **nbft, const char *filename)
 	 */
 	raw_nbft_fp = fopen(filename, "rb");
 	if (raw_nbft_fp == NULL) {
-		nvme_msg(NULL, LOG_ERR, "Failed to open %s: %s\n",
+		nvme_msg(ctx, LOG_ERR, "Failed to open %s: %s\n",
 			 filename, strerror(errno));
 		return -EINVAL;
 	}
 
 	i = fseek(raw_nbft_fp, 0L, SEEK_END);
 	if (i) {
-		nvme_msg(NULL, LOG_ERR, "Failed to read from %s: %s\n",
+		nvme_msg(ctx, LOG_ERR, "Failed to read from %s: %s\n",
 			 filename, strerror(errno));
 		fclose(raw_nbft_fp);
 		return -EINVAL;
@@ -713,14 +769,15 @@ int nvme_nbft_read(struct nbft_info **nbft, const char *filename)
 
 	raw_nbft = malloc(raw_nbft_size);
 	if (!raw_nbft) {
-		nvme_msg(NULL, LOG_ERR, "Failed to allocate memory for NBFT table");
+		nvme_msg(ctx, LOG_ERR,
+			"Failed to allocate memory for NBFT table");
 		fclose(raw_nbft_fp);
 		return -ENOMEM;
 	}
 
 	i = fread(raw_nbft, sizeof(*raw_nbft), raw_nbft_size, raw_nbft_fp);
 	if (i != raw_nbft_size) {
-		nvme_msg(NULL, LOG_ERR, "Failed to read from %s: %s\n",
+		nvme_msg(ctx, LOG_ERR, "Failed to read from %s: %s\n",
 			 filename, strerror(errno));
 		fclose(raw_nbft_fp);
 		free(raw_nbft);
@@ -729,11 +786,12 @@ int nvme_nbft_read(struct nbft_info **nbft, const char *filename)
 	fclose(raw_nbft_fp);
 
 	/*
-	 * alloc new struct nbft_info, add raw nbft & filename to it, and add it to the list
+	 * alloc new struct nbft_info, add raw nbft & filename to it,
+	 * and add it to the list
 	 */
 	*nbft = calloc(1, sizeof(struct nbft_info));
 	if (!*nbft) {
-		nvme_msg(NULL, LOG_ERR, "Could not allocate memory for NBFT\n");
+		nvme_msg(ctx, LOG_ERR, "Could not allocate memory for NBFT\n");
 		free(raw_nbft);
 		return -ENOMEM;
 	}
@@ -742,9 +800,9 @@ int nvme_nbft_read(struct nbft_info **nbft, const char *filename)
 	(*nbft)->raw_nbft = raw_nbft;
 	(*nbft)->raw_nbft_size = raw_nbft_size;
 
-	if (parse_raw_nbft(*nbft)) {
-		nvme_msg(NULL, LOG_ERR, "Failed to parse %s\n", filename);
-		nvme_nbft_free(*nbft);
+	if (parse_raw_nbft(ctx, *nbft)) {
+		nvme_msg(ctx, LOG_ERR, "Failed to parse %s\n", filename);
+		nvme_nbft_free(ctx, *nbft);
 		return -EINVAL;
 	}
 	return 0;
diff --git a/libnvme/src/nvme/nbft.h b/libnvme/src/nvme/nbft.h
index 424d6504e1..871c05ac59 100644
--- a/libnvme/src/nvme/nbft.h
+++ b/libnvme/src/nvme/nbft.h
@@ -1234,6 +1234,7 @@ struct nbft_info {
 /**
  * nvme_nbft_read() - Read and parse contents of an ACPI NBFT table
  *
+ * @ctx:      struct nvme_global_ctx object
  * @nbft:     Parsed NBFT table data.
  * @filename: Filename of the raw NBFT table to read.
  *
@@ -1242,12 +1243,14 @@ struct nbft_info {
  *
  * Return: 0 on success, errno otherwise.
  */
-int nvme_nbft_read(struct nbft_info **nbft, const char *filename);
+int nvme_nbft_read(struct nvme_global_ctx *ctx, struct nbft_info **nbft,
+		const char *filename);
 
 /**
  * nvme_nbft_free() - Free the struct nbft_info and its contents
+ * @ctx: struct nvme_global_ctx object
  * @nbft: Parsed NBFT table data.
  */
-void nvme_nbft_free(struct nbft_info *nbft);
+void nvme_nbft_free(struct nvme_global_ctx *ctx, struct nbft_info *nbft);
 
 #endif
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index 2897016a9b..c7b2558235 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -138,6 +138,7 @@ struct nvme_ns {
 	struct nvme_ctrl *c;
 	struct nvme_ns_head *head;
 
+	struct nvme_global_ctx *ctx;
 	struct nvme_transport_handle *hdl;
 	__u32 nsid;
 	char *name;
@@ -162,6 +163,7 @@ struct nvme_ctrl {
 	struct list_head namespaces;
 	struct nvme_subsystem *s;
 
+	struct nvme_global_ctx *ctx;
 	struct nvme_transport_handle *hdl;
 	char *name;
 	char *sysfs_dir;
@@ -265,7 +267,6 @@ struct nvme_global_ctx {
 	struct list_head endpoints; /* MI endpoints */
 	struct list_head hosts;
 	struct nvme_log log;
-	bool modified;
 	bool mi_probe_enabled;
 	bool create_only;
 	bool dry_run;
@@ -375,9 +376,9 @@ struct fabric_args {
 	const char *subsysnqn;
 	const char *transport;
 	const char *traddr;
+	const char *trsvcid;
 	const char *host_traddr;
 	const char *host_iface;
-	const char *trsvcid;
 };
 
 int nvme_set_attr(const char *dir, const char *attr, const char *value);
@@ -410,6 +411,20 @@ void *__nvme_alloc(size_t len);
 
 void *__nvme_realloc(void *p, size_t len);
 
+nvme_host_t nvme_lookup_host(struct nvme_global_ctx *ctx, const char *hostnqn,
+			     const char *hostid);
+nvme_subsystem_t nvme_lookup_subsystem(struct nvme_host *h,
+				       const char *name,
+				       const char *subsysnqn);
+nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport,
+			     const char *traddr, const char *host_traddr,
+			     const char *host_iface, const char *trsvcid,
+			     nvme_ctrl_t p);
+nvme_ctrl_t nvme_ctrl_find(nvme_subsystem_t s, const char *transport,
+			   const char *traddr, const char *trsvcid,
+			   const char *subsysnqn, const char *host_traddr,
+			   const char *host_iface);
+
 #if (LOG_FUNCNAME == 1)
 #define __nvme_log_func __func__
 #else
@@ -422,11 +437,6 @@ __nvme_msg(struct nvme_global_ctx *ctx, int level, const char *func, const char
 #define nvme_msg(ctx, level, format, ...)					\
 	__nvme_msg(ctx, level, __nvme_log_func, format, ##__VA_ARGS__)
 
-#define ctx_from_ctrl(c) ((c)->s && (c)->s->h ? (c)->s->h->ctx : NULL)
-#define ctx_from_ns(n) ((n)->s && (n)->s->h ? (n)->s->h->ctx : \
-			 (n)->c && (n)->c->s && (n)->c->s->h ? (n)->c->s->h->ctx : \
-			 NULL)
-
 /* mi internal headers */
 
 /* internal transport API */
@@ -531,7 +541,7 @@ void __nvme_mi_mctp_set_ops(const struct __mi_mctp_socket_ops *newops);
 #define SECTOR_SHIFT	9
 
 int __nvme_import_keys_from_config(nvme_host_t h, nvme_ctrl_t c,
-				   long *keyring_id, long *key_id);
+		long *keyring_id, long *key_id);
 
 static inline char *xstrdup(const char *s)
 {
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index b1345ad9e4..9303a44036 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -56,8 +56,6 @@ struct candidate_args {
 };
 typedef bool (*ctrl_match_t)(struct nvme_ctrl *c, struct candidate_args *candidate);
 
-static struct nvme_host *default_host;
-
 static void __nvme_free_host(nvme_host_t h);
 static void __nvme_free_ctrl(nvme_ctrl_t c);
 static int nvme_subsystem_scan_namespace(struct nvme_global_ctx *ctx,
@@ -191,23 +189,25 @@ int nvme_host_get_ids(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-int nvme_default_host(struct nvme_global_ctx *ctx, nvme_host_t *hp)
+int nvme_host_get(struct nvme_global_ctx *ctx, const char *hostnqn,
+		const char *hostid, nvme_host_t *host)
 {
-	_cleanup_free_ char *hostnqn = NULL;
-	_cleanup_free_ char *hostid = NULL;
+	_cleanup_free_ char *hnqn = NULL;
+	_cleanup_free_ char *hid = NULL;
 	struct nvme_host *h;
 	int err;
 
-	err = nvme_host_get_ids(ctx, NULL, NULL, &hostnqn, &hostid);
+	err = nvme_host_get_ids(ctx, hostnqn, hostid, &hnqn, &hid);
 	if (err)
 		return err;
 
-	h = nvme_lookup_host(ctx, hostnqn, hostid);
+	h = nvme_lookup_host(ctx, hnqn, hid);
+	if (!h)
+		return -ENOMEM;
 
 	nvme_host_set_hostsymname(h, NULL);
 
-	default_host = h;
-	*hp = h;
+	*host = h;
 	return 0;
 }
 
@@ -399,17 +399,9 @@ int nvme_scan(const char *config_file, struct nvme_global_ctx **ctxp)
 	return ret;
 }
 
-int nvme_update_config(struct nvme_global_ctx *ctx)
+int nvme_dump_config(struct nvme_global_ctx *ctx, const char *config_file)
 {
-	if (!ctx->modified || !ctx->config_file)
-		return 0;
-
-	return json_update_config(ctx, ctx->config_file);
-}
-
-int nvme_dump_config(struct nvme_global_ctx *ctx)
-{
-	return json_update_config(ctx, NULL);
+	return json_update_config(ctx, config_file);
 }
 
 int nvme_dump_tree(struct nvme_global_ctx *ctx)
@@ -712,7 +704,6 @@ struct nvme_subsystem *nvme_alloc_subsystem(struct nvme_host *h,
 	list_head_init(&s->namespaces);
 	list_node_init(&s->entry);
 	list_add_tail(&h->subsystems, &s->entry);
-	h->ctx->modified = true;
 	return s;
 }
 
@@ -740,6 +731,21 @@ struct nvme_subsystem *nvme_lookup_subsystem(struct nvme_host *h,
 	return nvme_alloc_subsystem(h, name, subsysnqn);
 }
 
+int nvme_subsystem_get(struct nvme_global_ctx *ctx,
+		struct nvme_host *h, const char *name,
+		const char *subsysnqn, struct nvme_subsystem **subsys)
+{
+	struct nvme_subsystem *s;
+
+	s = nvme_lookup_subsystem(h, name, subsysnqn);
+	if (!s)
+		return -ENOMEM;
+
+	*subsys = s;
+
+	return 0;
+}
+
 static void __nvme_free_host(struct nvme_host *h)
 {
 	struct nvme_subsystem *s, *_s;
@@ -751,7 +757,6 @@ static void __nvme_free_host(struct nvme_host *h)
 	free(h->hostid);
 	free(h->dhchap_key);
 	nvme_host_set_hostsymname(h, NULL);
-	h->ctx->modified = true;
 	free(h);
 }
 
@@ -769,13 +774,37 @@ void nvme_free_host(struct nvme_host *h)
 	__nvme_free_host(h);
 }
 
-struct nvme_host *nvme_lookup_host(struct nvme_global_ctx *ctx, const char *hostnqn,
-				   const char *hostid)
+static int nvme_create_host(struct nvme_global_ctx *ctx, const char *hostnqn,
+		const char *hostid, struct nvme_host **host)
+{
+	struct nvme_host *h;
+
+	h = calloc(1, sizeof(*h));
+	if (!h)
+		return -ENOMEM;
+
+	h->hostnqn = strdup(hostnqn);
+	if (hostid)
+		h->hostid = strdup(hostid);
+	list_head_init(&h->subsystems);
+	list_node_init(&h->entry);
+	h->ctx = ctx;
+
+	list_add_tail(&ctx->hosts, &h->entry);
+
+	*host = h;
+
+	return 0;
+}
+
+struct nvme_host *nvme_lookup_host(struct nvme_global_ctx *ctx,
+		const char *hostnqn, const char *hostid)
 {
 	struct nvme_host *h;
 
 	if (!hostnqn)
 		return NULL;
+
 	nvme_for_each_host(ctx, h) {
 		if (strcmp(h->hostnqn, hostnqn))
 			continue;
@@ -784,17 +813,9 @@ struct nvme_host *nvme_lookup_host(struct nvme_global_ctx *ctx, const char *host
 			continue;
 		return h;
 	}
-	h = calloc(1,sizeof(*h));
-	if (!h)
+
+	if (nvme_create_host(ctx, hostnqn, hostid, &h))
 		return NULL;
-	h->hostnqn = strdup(hostnqn);
-	if (hostid)
-		h->hostid = strdup(hostid);
-	list_head_init(&h->subsystems);
-	list_node_init(&h->entry);
-	h->ctx = ctx;
-	list_add_tail(&ctx->hosts, &h->entry);
-	ctx->modified = true;
 
 	return h;
 }
@@ -897,7 +918,7 @@ static int nvme_scan_subsystem(struct nvme_global_ctx *ctx, const char *name)
 		 */
 		nvme_msg(ctx, LOG_DEBUG, "creating detached subsystem '%s'\n",
 			 name);
-		ret = nvme_default_host(ctx, &h);
+		ret = nvme_host_get(ctx, NULL, NULL, &h);
 		if (ret)
 			return ret;
 		s = nvme_alloc_subsystem(h, name, subsysnqn);
@@ -1017,12 +1038,11 @@ static int nvme_ctrl_scan_path(struct nvme_global_ctx *ctx, struct nvme_ctrl *c,
 struct nvme_transport_handle *nvme_ctrl_get_transport_handle(nvme_ctrl_t c)
 {
 	if (!c->hdl) {
-		struct nvme_global_ctx *ctx = ctx_from_ctrl(c);
 		int err;
 
-		err = nvme_open(ctx, c->name, &c->hdl);
+		err = nvme_open(c->ctx, c->name, &c->hdl);
 		if (err)
-			nvme_msg(ctx, LOG_ERR,
+			nvme_msg(c->ctx, LOG_ERR,
 				 "Failed to open ctrl %s, errno %d\n",
 				 c->name, err);
 	}
@@ -1078,7 +1098,7 @@ char *nvme_ctrl_get_src_addr(nvme_ctrl_t c, char *src_addr, size_t src_addr_len)
 	p += strlen("src_addr=");
 	l = strcspn(p, ",%"); /* % to eliminate IPv6 scope (if present) */
 	if (l >= src_addr_len) {
-		nvme_msg(ctx_from_ctrl(c), LOG_ERR,
+		nvme_msg(c->ctx, LOG_ERR,
 			 "Buffer for src_addr is too small (%zu must be > %zu)\n",
 			 src_addr_len, l);
 		return NULL;
@@ -1429,6 +1449,7 @@ int nvme_create_ctrl(struct nvme_global_ctx *ctx,
 	if (!c)
 		return -ENOMEM;
 
+	c->ctx = ctx;
 	c->hdl = NULL;
 	nvmf_default_config(&c->cfg);
 	list_head_init(&c->namespaces);
@@ -1487,7 +1508,7 @@ static bool _tcp_ctrl_match_host_traddr_no_src_addr(struct nvme_ctrl *c, struct
 	 * 100% positive match. Regardless, let's be optimistic
 	 * and assume that we have a match.
 	 */
-	nvme_msg(ctx_from_ctrl(c), LOG_DEBUG,
+	nvme_msg(c->ctx, LOG_DEBUG,
 		 "Not enough data, but assume %s matches candidate's host_traddr: %s\n",
 		 nvme_ctrl_get_name(c), candidate->host_traddr);
 
@@ -1527,7 +1548,7 @@ static bool _tcp_ctrl_match_host_iface_no_src_addr(struct nvme_ctrl *c, struct c
 	 * 100% positive match. Regardless, let's be optimistic
 	 * and assume that we have a match.
 	 */
-	nvme_msg(ctx_from_ctrl(c), LOG_DEBUG,
+	nvme_msg(c->ctx, LOG_DEBUG,
 		 "Not enough data, but assume %s matches candidate's host_iface: %s\n",
 		 nvme_ctrl_get_name(c), candidate->host_iface);
 
@@ -1865,7 +1886,6 @@ nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport,
 
 	c->s = s;
 	list_add_tail(&s->ctrls, &c->entry);
-	s->h->ctx->modified = true;
 
 	return c;
 }
@@ -2265,21 +2285,17 @@ int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name,
 
 	hostnqn = nvme_get_attr(path, "hostnqn");
 	hostid = nvme_get_attr(path, "hostid");
-	h = nvme_lookup_host(ctx, hostnqn, hostid);
-	if (h) {
-		host_key = nvme_get_attr(path, "dhchap_secret");
-		if (host_key && strcmp(host_key, "none")) {
-			free(h->dhchap_key);
-			h->dhchap_key = host_key;
-			host_key = NULL;
-		}
-		free(host_key);
-	}
-	if (!h) {
-		ret = nvme_default_host(ctx, &h);
-		if (ret)
-			return ret;
+	ret = nvme_host_get(ctx, hostnqn, hostid, &h);
+	if (ret)
+		return ret;
+
+	host_key = nvme_get_attr(path, "dhchap_secret");
+	if (host_key && strcmp(host_key, "none")) {
+		free(h->dhchap_key);
+		h->dhchap_key = host_key;
+		host_key = NULL;
 	}
+	free(host_key);
 
 	subsysnqn = nvme_get_attr(path, "subsysnqn");
 	if (!subsysnqn)
@@ -2336,12 +2352,11 @@ static int nvme_bytes_to_lba(nvme_ns_t n, off_t offset, size_t count,
 struct nvme_transport_handle *nvme_ns_get_transport_handle(nvme_ns_t n)
 {
 	if (!n->hdl) {
-		struct nvme_global_ctx *ctx = ctx_from_ns(n);
 		int err;
 
-		err = nvme_open(ctx, n->name, &n->hdl);
+		err = nvme_open(n->ctx, n->name, &n->hdl);
 		if (err)
-			nvme_msg(ctx, LOG_ERR,
+			nvme_msg(n->ctx, LOG_ERR,
 				 "Failed to open ns %s, error %d\n",
 				 n->name, err);
 	}
@@ -2750,7 +2765,8 @@ static void nvme_ns_set_generic_name(struct nvme_ns *n, const char *name)
 	n->generic_name = strdup(generic_name);
 }
 
-int nvme_ns_open(const char *sys_path, const char *name, nvme_ns_t *ns)
+static int nvme_ns_open(struct nvme_global_ctx *ctx, const char *sys_path,
+		const char *name, nvme_ns_t *ns)
 {
 	int ret;
 	struct nvme_ns *n;
@@ -2787,6 +2803,7 @@ int nvme_ns_open(const char *sys_path, const char *name, nvme_ns_t *ns)
 	} else
 		head->sysfs_dir = NULL;
 
+	n->ctx = ctx;
 	n->head = head;
 	n->hdl = NULL;
 	n->name = strdup(name);
@@ -2837,7 +2854,8 @@ static char *nvme_ns_generic_to_blkdev(const char *generic)
 	return strdup(blkdev);
 }
 
-static int __nvme_scan_namespace(const char *sysfs_dir, const char *name, nvme_ns_t *ns)
+static int __nvme_scan_namespace(struct nvme_global_ctx *ctx,
+		const char *sysfs_dir, const char *name, nvme_ns_t *ns)
 {
 	_cleanup_free_ char *blkdev = NULL;
 	_cleanup_free_ char *path = NULL;
@@ -2852,7 +2870,7 @@ static int __nvme_scan_namespace(const char *sysfs_dir, const char *name, nvme_n
 	if (ret < 0)
 		return -ENOMEM;
 
-	ret = nvme_ns_open(path, blkdev, &n);
+	ret = nvme_ns_open(ctx, path, blkdev, &n);
 	if (ret)
 		return ret;
 
@@ -2863,9 +2881,10 @@ static int __nvme_scan_namespace(const char *sysfs_dir, const char *name, nvme_n
 	return 0;
 }
 
-int nvme_scan_namespace(const char *name, nvme_ns_t *ns)
+int nvme_scan_namespace(struct nvme_global_ctx *ctx, const char *name,
+		nvme_ns_t *ns)
 {
-	return __nvme_scan_namespace(nvme_ns_sysfs_dir(), name, ns);
+	return __nvme_scan_namespace(ctx, nvme_ns_sysfs_dir(), name, ns);
 }
 
 
@@ -2945,7 +2964,7 @@ static int nvme_ctrl_scan_namespace(struct nvme_global_ctx *ctx, struct nvme_ctr
 		nvme_msg(ctx, LOG_DEBUG, "no subsystem for %s\n", name);
 		return -EINVAL;
 	}
-	ret = __nvme_scan_namespace(c->sysfs_dir, name, &n);
+	ret = __nvme_scan_namespace(ctx, c->sysfs_dir, name, &n);
 	if (ret) {
 		nvme_msg(ctx, LOG_DEBUG, "failed to scan namespace %s\n", name);
 		return ret;
@@ -2971,7 +2990,7 @@ static int nvme_subsystem_scan_namespace(struct nvme_global_ctx *ctx, nvme_subsy
 
 	nvme_msg(ctx, LOG_DEBUG, "scan subsystem %s namespace %s\n",
 		 s->name, name);
-	ret = __nvme_scan_namespace(s->sysfs_dir, name, &n);
+	ret = __nvme_scan_namespace(ctx, s->sysfs_dir, name, &n);
 	if (ret) {
 		nvme_msg(ctx, LOG_DEBUG, "failed to scan namespace %s\n", name);
 		return ret;
diff --git a/libnvme/src/nvme/tree.h b/libnvme/src/nvme/tree.h
index 7b90b22d6d..a102ca2df0 100644
--- a/libnvme/src/nvme/tree.h
+++ b/libnvme/src/nvme/tree.h
@@ -96,20 +96,6 @@ nvme_host_t nvme_next_host(struct nvme_global_ctx *ctx, nvme_host_t h);
  */
 struct nvme_global_ctx *nvme_host_get_global_ctx(nvme_host_t h);
 
-/**
- * nvme_lookup_host() - Lookup nvme_host_t object
- * @ctx:	struct nvme_global_ctx object
- * @hostnqn:	Host NQN
- * @hostid:	Host ID
- *
- * Lookup a nvme_host_t object based on @hostnqn and @hostid
- * or create one if not found.
- *
- * Return: &nvme_host_t object
- */
-nvme_host_t nvme_lookup_host(struct nvme_global_ctx *ctx, const char *hostnqn,
-			     const char *hostid);
-
 /**
  * nvme_host_get_dhchap_key() - Return host key
  * @h:	Host for which the key should be returned
@@ -148,16 +134,19 @@ void nvme_host_set_pdc_enabled(nvme_host_t h, bool enabled);
 bool nvme_host_is_pdc_enabled(nvme_host_t h, bool fallback);
 
 /**
- * nvme_default_host() - Initializes the default host
+ * nvme_host_get() - Returns a host object
  * @ctx:	struct nvme_global_ctx object
- * @h:  &nvme_host_t object to return
+ * @hostnqn:	Host NQN (optional)
+ * @hostid:	Host ID (optional)
+ * @h:		&nvme_host_t object to return
  *
- * Initializes the default host object based on the hostnqn/hostid
- * values returned by nvme_host_get_ids() and attaches it to @r.
+ * Returns a host object based on the hostnqn/hostid values or the default if
+ * hostnqn/hostid are NULL.
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_default_host(struct nvme_global_ctx *ctx, nvme_host_t *h);
+int nvme_host_get(struct nvme_global_ctx *ctx, const char *hostnqn,
+		const char *hostid, nvme_host_t *h);
 
 /**
  * nvme_host_get_ids - Retrieve host ids from various sources
@@ -212,19 +201,20 @@ nvme_subsystem_t nvme_first_subsystem(nvme_host_t h);
 nvme_subsystem_t nvme_next_subsystem(nvme_host_t h, nvme_subsystem_t s);
 
 /**
- * nvme_lookup_subsystem() - Lookup nvme_subsystem_t object
+ * nvme_subsystem_get() - Returns nvme_subsystem_t object
+ * @ctx:	struct nvme_global_ctx object
  * @h:		&nvme_host_t object
  * @name:	Name of the subsystem (may be NULL)
  * @subsysnqn:	Subsystem NQN
+ * @s: 		nvme_subsystem_t object
  *
- * Lookup a &nvme_subsystem_t object in @h base on @name (if present)
+ * Returns an &nvme_subsystem_t object in @h base on @name (if present)
  * and @subsysnqn or create one if not found.
  *
- * Return: nvme_subsystem_t object
  */
-nvme_subsystem_t nvme_lookup_subsystem(struct nvme_host *h,
-				       const char *name,
-				       const char *subsysnqn);
+int nvme_subsystem_get(struct nvme_global_ctx *ctx,
+		struct nvme_host *h, const char *name,
+		const char *subsysnqn, struct nvme_subsystem **s);
 
 /**
  * nvme_free_subsystem() - Free a subsystem
@@ -310,54 +300,6 @@ nvme_path_t nvme_namespace_first_path(nvme_ns_t ns);
  */
 nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p);
 
-/**
- * nvme_lookup_ctrl() - Lookup nvme_ctrl_t object
- * @s:			&nvme_subsystem_t object
- * @transport:		Transport name
- * @traddr:		Transport address
- * @host_traddr:	Host transport address
- * @host_iface:		Host interface name
- * @trsvcid:		Transport service identifier
- * @p:			Previous controller instance
- *
- * Lookup a controller in @s based on @transport, @traddr,
- * @host_traddr, @host_iface, and @trsvcid. @transport must be specified,
- * other fields may be required depending on the transport. A new
- * object is created if none is found. If @p is specified the lookup
- * will start at @p instead of the first controller.
- *
- * Return: Controller instance
- */
-nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport,
-			     const char *traddr, const char *host_traddr,
-			     const char *host_iface, const char *trsvcid,
-			     nvme_ctrl_t p);
-
-/**
- * nvme_ctrl_find() - Locate an existing controller
- * @s:			&nvme_subsystem_t object
- * @transport:		Transport name
- * @traddr:		Transport address
- * @trsvcid:		Transport service identifier
- * @subsysnqn:		Subsystem NQN
- * @host_traddr:	Host transport address
- * @host_iface:		Host interface name
- *
- * Lookup a controller in @s based on @transport, @traddr, @trsvcid,
- * @subsysnqn, @host_traddr, and @host_iface. @transport must be specified,
- * other fields may be required depending on the transport. Parameters set
- * to NULL will be ignored.
- *
- * Unlike nvme_lookup_ctrl(), this function does not create a new object if
- * an existing controller cannot be found.
- *
- * Return: Controller instance on success, NULL otherwise.
- */
-nvme_ctrl_t nvme_ctrl_find(nvme_subsystem_t s, const char *transport,
-			   const char *traddr, const char *trsvcid,
-			   const char *subsysnqn, const char *host_traddr,
-			   const char *host_iface);
-
 /**
  * nvme_ctrl_config_match() - Check if ctrl @c matches config params
  * @c:			An existing controller instance
@@ -1453,26 +1395,18 @@ int nvme_read_config(struct nvme_global_ctx *ctx, const char *config_file);
  */
 void nvme_refresh_topology(struct nvme_global_ctx *ctx);
 
-/**
- * nvme_update_config() - Update JSON configuration
- * @ctx:		&struct nvme_global_ctx object
- *
- * Updates the JSON configuration file with the contents of @r.
- *
- * Return: 0 on success, -1 on failure.
- */
-int nvme_update_config(struct nvme_global_ctx *ctx);
-
 /**
  * nvme_dump_config() - Print the JSON configuration
  * @ctx:		&struct nvme_global_ctx object
+ * @config_file:	JSON configuration file.
  *
  * Prints the current contents of the JSON configuration
- * file to stdout.
+ * file to the config_file. If connfig_file is not provided it prints
+ * to stdout.
  *
  * Return: 0 on success, or negative error code otherwise.
  */
-int nvme_dump_config(struct nvme_global_ctx *ctx);
+int nvme_dump_config(struct nvme_global_ctx *ctx, const char *config_file);
 
 /**
  * nvme_dump_tree() - Dump internal object tree
@@ -1559,12 +1493,14 @@ char *nvme_get_path_attr(nvme_path_t p, const char *attr);
 
 /**
  * nvme_scan_namespace() - scan namespace based on sysfs name
+ * @ctx:	&struct nvme_global_ctx object
  * @name:	sysfs name of the namespace to scan
  * @ns:		&nvme_ns_t object to return
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_scan_namespace(const char *name, nvme_ns_t *ns);
+int nvme_scan_namespace(struct nvme_global_ctx *ctx, const char *name,
+		nvme_ns_t *ns);
 
 /**
  * nvme_host_get_hostsymname() - Get the host's symbolic name
diff --git a/libnvme/test/config/config-diff.sh b/libnvme/test/config/config-diff.sh
index abec20e15a..920ffb3aad 100755
--- a/libnvme/test/config/config-diff.sh
+++ b/libnvme/test/config/config-diff.sh
@@ -40,9 +40,23 @@ fi
 
 output="${build_dir}"/$(basename "${expected_output}")
 
-LIBNVME_SYSFS_PATH="${sysfs_path}" \
-LIBNVME_HOSTNQN=nqn.2014-08.org.nvmexpress:uuid:ce4fee3e-c02c-11ee-8442-830d068a36c6 \
-LIBNVME_HOSTID=ce4fee3e-c02c-11ee-8442-830d068a36c6 \
-"${test_binary}" "${config_json}" > "${output}" || echo "test failed"
+cmd=(
+  env
+  LIBNVME_SYSFS_PATH="$sysfs_path"
+  LIBNVME_HOSTNQN="nqn.2014-08.org.nvmexpress:uuid:ce4fee3e-c02c-11ee-8442-830d068a36c6"
+  LIBNVME_HOSTID="ce4fee3e-c02c-11ee-8442-830d068a36c6"
+  "$test_binary"
+  "$config_json"
+)
+
+echo "Running command:"
+printf '%q ' "${cmd[@]}"
+printf '> %q\n' "$output"
+
+if ! "${cmd[@]}" > "$output"; then
+    rc=$?
+    echo "test failed (exit code $rc)"
+    exit $rc
+fi
 
 diff -u "${expected_output}" "${output}"
diff --git a/libnvme/test/config/config-dump.c b/libnvme/test/config/config-dump.c
index bf8318ee77..d9e8d27032 100644
--- a/libnvme/test/config/config-dump.c
+++ b/libnvme/test/config/config-dump.c
@@ -29,7 +29,7 @@ static bool config_dump(const char *file)
 	if (err)
 		goto out;
 
-	err = nvme_dump_config(ctx);
+	err = nvme_dump_config(ctx, NULL);
 	if (err)
 		goto out;
 
diff --git a/libnvme/test/config/psk-json.c b/libnvme/test/config/psk-json.c
index 1469dac520..65801397c6 100644
--- a/libnvme/test/config/psk-json.c
+++ b/libnvme/test/config/psk-json.c
@@ -13,14 +13,14 @@
 
 #include <libnvme.h>
 
-static bool import_export_key(nvme_ctrl_t c)
+static bool import_export_key(struct nvme_global_ctx *ctx, nvme_ctrl_t c)
 {
 	unsigned char version, hmac, *key;
 	char *encoded_key;
 	size_t len;
 	int ret;
 
-	ret = nvme_import_tls_key_versioned(nvme_ctrl_get_tls_key(c),
+	ret = nvme_import_tls_key_versioned(ctx, nvme_ctrl_get_tls_key(c),
 					    &version, &hmac, &len, &key);
 	if (ret) {
 		printf("ERROR: nvme_import_tls_key_versioned failed with %d\n",
@@ -29,7 +29,7 @@ static bool import_export_key(nvme_ctrl_t c)
 
 	}
 
-	ret = nvme_export_tls_key_versioned(version, hmac, key, len,
+	ret = nvme_export_tls_key_versioned(ctx, version, hmac, key, len,
 					    &encoded_key);
 	free(key);
 	if (ret) {
@@ -66,10 +66,10 @@ static bool psk_json_test(char *file)
 	nvme_for_each_host(ctx, h)
 		nvme_for_each_subsystem(h, s)
 			nvme_subsystem_for_each_ctrl(s, c)
-				if (!import_export_key(c))
+				if (!import_export_key(ctx, c))
 					goto out;
 
-	err = nvme_dump_config(ctx);
+	err = nvme_dump_config(ctx, NULL);
 	if (err)
 		goto out;
 
diff --git a/libnvme/test/ioctl/discovery.c b/libnvme/test/ioctl/discovery.c
index b49fe5e8df..a39621d8b3 100644
--- a/libnvme/test/ioctl/discovery.c
+++ b/libnvme/test/ioctl/discovery.c
@@ -401,9 +401,10 @@ static void test_genctr_error(nvme_ctrl_t c)
 	check(!log, "unexpected log page returned");
 }
 
-static void run_test(const char *test_name, void (*test_fn)(nvme_ctrl_t))
+static void run_test(struct nvme_global_ctx *ctx, const char *test_name,
+		void (*test_fn)(nvme_ctrl_t))
 {
-	struct nvme_ctrl c = { .hdl = test_hdl };
+	struct nvme_ctrl c = { .ctx = ctx, .hdl = test_hdl };
 
 	printf("Running test %s...", test_name);
 	fflush(stdout);
@@ -413,7 +414,7 @@ static void run_test(const char *test_name, void (*test_fn)(nvme_ctrl_t))
 	puts(" OK");
 }
 
-#define RUN_TEST(name) run_test(#name, test_ ## name)
+#define RUN_TEST(name) run_test(ctx, #name, test_ ## name)
 
 int main(void)
 {
diff --git a/libnvme/test/ioctl/mock.c b/libnvme/test/ioctl/mock.c
index 8fb32d08c9..d6ff12ee7e 100644
--- a/libnvme/test/ioctl/mock.c
+++ b/libnvme/test/ioctl/mock.c
@@ -157,7 +157,8 @@ int ioctl(int fd, int request, ...)
 		if (!real_ioctl)
 			fail("Error: dlsym failed to find original ioctl\n");
 #else
-		fail("Error: unhandled ioctl\n");
+		fprintf(stderr, "Warning: unhandled ioctl %lx\n", request);
+		return -ENOTTY;
 #endif
 	}
 
diff --git a/libnvme/test/meson.build b/libnvme/test/meson.build
index 66e04ce608..7c28527644 100644
--- a/libnvme/test/meson.build
+++ b/libnvme/test/meson.build
@@ -131,7 +131,7 @@ if not is_windows
             dependencies: [
                 config_dep,
                 ccan_dep,
-                libnvme_dep,
+                libnvme_test_dep,
             ],
             link_with: mock_ifaddrs,
         )
diff --git a/libnvme/test/nbft/nbft-dump.c b/libnvme/test/nbft/nbft-dump.c
index 5fb2f2e9bf..1d6cc124fb 100644
--- a/libnvme/test/nbft/nbft-dump.c
+++ b/libnvme/test/nbft/nbft-dump.c
@@ -104,20 +104,29 @@ static void print_nbft(struct nbft_info *table)
 int main(int argc, char **argv)
 {
 	struct nbft_info *table = NULL;
-	
+	struct nvme_global_ctx *ctx;
+
 	if (argc < 2) {
 		fprintf(stderr, "Usage: %s TABLE\n", argv[0]);
 		return 1;
 	}
 
-	if (nvme_nbft_read(&table, argv[1]) != 0) {
+	ctx = nvme_create_global_ctx(stderr, false);
+	if (!ctx) {
+		fprintf(stderr, "Failed to create global context");
+		return 1;
+	}
+
+	if (nvme_nbft_read(ctx, &table, argv[1]) != 0) {
 		fprintf(stderr, "Error parsing the NBFT table %s: %m\n",
 			argv[1]);
+		nvme_free_global_ctx(ctx);
 		return 2;
 	}
 
 	print_nbft(table);
 
-	nvme_nbft_free(table);
+	nvme_nbft_free(ctx, table);
+	nvme_free_global_ctx(ctx);
 	return 0;
 }
diff --git a/libnvme/test/psk.c b/libnvme/test/psk.c
index 3efa141607..125a7cc9a3 100644
--- a/libnvme/test/psk.c
+++ b/libnvme/test/psk.c
@@ -137,7 +137,8 @@ static void check_str(const char *exp, const char *res)
 	test_rc = 1;
 }
 
-static void export_test(struct test_data_psk *test)
+static void export_test(struct nvme_global_ctx *ctx,
+		struct test_data_psk *test)
 {
 	char *psk;
 	int ret;
@@ -150,7 +151,8 @@ static void export_test(struct test_data_psk *test)
 	printf("test nvme_export_tls_key hmac %d %s\n",
 	       test->hmac, test->exported_psk);
 
-	ret = nvme_export_tls_key(test->configured_psk, test->psk_length, &psk);
+	ret = nvme_export_tls_key(ctx, test->configured_psk,
+		test->psk_length, &psk);
 	if (ret) {
 		test_rc = 1;
 		printf("ERROR: nvme_export_tls_key() failed with %d\n", ret);
@@ -160,7 +162,8 @@ static void export_test(struct test_data_psk *test)
 	free(psk);
 }
 
-static void import_test(struct test_data_psk *test)
+static void import_test(struct nvme_global_ctx *ctx,
+		struct test_data_psk *test)
 {
 	unsigned char *psk;
 	int psk_length;
@@ -175,7 +178,8 @@ static void import_test(struct test_data_psk *test)
 	printf("test nvme_import_tls_key hmac %d %s\n",
 	       test->hmac, test->exported_psk);
 
-	ret = nvme_import_tls_key(test->exported_psk, &psk_length, &hmac, &psk);
+	ret = nvme_import_tls_key(ctx, test->exported_psk, &psk_length,
+		&hmac, &psk);
 	if (ret) {
 		test_rc = 1;
 		printf("ERROR: nvme_import_tls_key() failed with %d\n", ret);
@@ -202,7 +206,8 @@ static void import_test(struct test_data_psk *test)
 	free(psk);
 }
 
-static void export_versioned_test(struct test_data_psk *test)
+static void export_versioned_test(struct nvme_global_ctx *ctx,
+		struct test_data_psk *test)
 {
 	char *psk;
 	int ret;
@@ -213,7 +218,7 @@ static void export_versioned_test(struct test_data_psk *test)
 	printf("test nvme_export_tls_key_versioned hmac %d %s\n",
 	       test->hmac, test->exported_psk);
 
-	ret = nvme_export_tls_key_versioned(test->version, test->hmac,
+	ret = nvme_export_tls_key_versioned(ctx, test->version, test->hmac,
 					    test->configured_psk,
 					    test->psk_length, &psk);
 	if (ret) {
@@ -228,7 +233,8 @@ static void export_versioned_test(struct test_data_psk *test)
 	free(psk);
 }
 
-static void import_versioned_test(struct test_data_psk *test)
+static void import_versioned_test(struct nvme_global_ctx *ctx,
+		struct test_data_psk *test)
 {
 	unsigned char *psk;
 	unsigned char version;
@@ -242,7 +248,7 @@ static void import_versioned_test(struct test_data_psk *test)
 	printf("test nvme_import_tls_key_versioned hmac %d %s\n",
 	       test->hmac, test->exported_psk);
 
-	ret = nvme_import_tls_key_versioned(test->exported_psk, &version,
+	ret = nvme_import_tls_key_versioned(ctx, test->exported_psk, &version,
 					    &hmac, &psk_length, &psk);
 	if (ret) {
 		test_rc = 1;
@@ -278,7 +284,8 @@ static void import_versioned_test(struct test_data_psk *test)
 	free(psk);
 }
 
-static void identity_test(struct test_data_identity *test)
+static void identity_test(struct nvme_global_ctx *ctx,
+		struct test_data_identity *test)
 {
 	char *id;
 	int ret;
@@ -291,10 +298,10 @@ static void identity_test(struct test_data_identity *test)
 	printf("test nvme_generate_tls_key_identity host %s subsys %s hmac %d %s\n",
 	       test->hostnqn, test->subsysnqn, test->hmac, test->identity);
 
-	ret = nvme_generate_tls_key_identity(test->hostnqn, test->subsysnqn,
-					     test->version, test->hmac,
-					     (unsigned char *)test->configured_psk,
-					     test->psk_length, &id);
+	ret = nvme_generate_tls_key_identity(ctx, test->hostnqn,
+		test->subsysnqn, test->version, test->hmac,
+		(unsigned char *)test->configured_psk,
+		test->psk_length, &id);
 	if (ret) {
 		if (ret == -ENOTSUP)
 			return;
@@ -306,7 +313,8 @@ static void identity_test(struct test_data_identity *test)
 	free(id);
 }
 
-static void identity_test_compat(struct test_data_identity *test)
+static void identity_test_compat(struct nvme_global_ctx *ctx,
+		struct test_data_identity *test)
 {
 	char *id;
 	int ret;
@@ -319,11 +327,10 @@ static void identity_test_compat(struct test_data_identity *test)
 	printf("test nvme_generate_tls_key_identity_compat host %s subsys %s hmac %d %s\n",
 	       test->hostnqn, test->subsysnqn, test->hmac, test->identity);
 
-	ret = nvme_generate_tls_key_identity_compat(test->hostnqn,
-						    test->subsysnqn,
-						    test->version, test->hmac,
-						    (unsigned char *)test->configured_psk,
-						    test->psk_length, &id);
+	ret = nvme_generate_tls_key_identity_compat(ctx, test->hostnqn,
+		test->subsysnqn, test->version, test->hmac,
+		(unsigned char *)test->configured_psk,
+		test->psk_length, &id);
 	if (ret) {
 		if (ret == -ENOTSUP)
 			return;
@@ -337,23 +344,28 @@ static void identity_test_compat(struct test_data_identity *test)
 
 int main(void)
 {
+	struct nvme_global_ctx *ctx =
+		nvme_create_global_ctx(stdout, DEFAULT_LOGLEVEL);
+
 	for (int i = 0; i < ARRAY_SIZE(test_data_psk); i++)
-		export_test(&test_data_psk[i]);
+		export_test(ctx, &test_data_psk[i]);
 
 	for (int i = 0; i < ARRAY_SIZE(test_data_psk); i++)
-		import_test(&test_data_psk[i]);
+		import_test(ctx, &test_data_psk[i]);
 
 	for (int i = 0; i < ARRAY_SIZE(test_data_psk); i++)
-		export_versioned_test(&test_data_psk[i]);
+		export_versioned_test(ctx, &test_data_psk[i]);
 
 	for (int i = 0; i < ARRAY_SIZE(test_data_psk); i++)
-		import_versioned_test(&test_data_psk[i]);
+		import_versioned_test(ctx, &test_data_psk[i]);
 
 	for (int i = 0; i < ARRAY_SIZE(test_data_identity); i++)
-		identity_test(&test_data_identity[i]);
+		identity_test(ctx, &test_data_identity[i]);
 
 	for (int i = 0; i < ARRAY_SIZE(test_data_identity_compat); i++)
-		identity_test_compat(&test_data_identity_compat[i]);
+		identity_test_compat(ctx, &test_data_identity_compat[i]);
+
+	nvme_free_global_ctx(ctx);
 
 	return test_rc ? EXIT_FAILURE : EXIT_SUCCESS;
 }
diff --git a/libnvme/test/sysfs/meson.build b/libnvme/test/sysfs/meson.build
index 91cfb5cce9..933f8a2ee9 100644
--- a/libnvme/test/sysfs/meson.build
+++ b/libnvme/test/sysfs/meson.build
@@ -8,7 +8,7 @@
 diff = find_program('diff', required : false)
 if diff.found()
     tree_dump = executable(
-        'libnvme - test-tree-dump',
+        'test-tree-dump',
         ['tree-dump.c'],
         dependencies: libnvme_dep,
     )
diff --git a/libnvme/test/sysfs/tree-diff.sh b/libnvme/test/sysfs/tree-diff.sh
index 39b8d0d405..6ee7bc7420 100644
--- a/libnvme/test/sysfs/tree-diff.sh
+++ b/libnvme/test/sysfs/tree-diff.sh
@@ -14,9 +14,22 @@ rm -rf "${TEST_DIR}"
 mkdir "${TEST_DIR}"
 tar -x -f "${SYSFS_INPUT}" -C "${TEST_DIR}"
 
-LIBNVME_SYSFS_PATH="${TEST_DIR}" \
-LIBNVME_HOSTNQN=nqn.2014-08.org.nvmexpress:uuid:ce4fee3e-c02c-11ee-8442-830d068a36c6 \
-LIBNVME_HOSTID=ce4fee3e-c02c-11ee-8442-830d068a36c6 \
-"${TREE_DUMP}" > "${ACTUAL_OUTPUT}" || echo "test failed"
+cmd=(
+  env
+  LIBNVME_SYSFS_PATH="$TEST_DIR"
+  LIBNVME_HOSTNQN="nqn.2014-08.org.nvmexpress:uuid:ce4fee3e-c02c-11ee-8442-830d068a36c6"
+  LIBNVME_HOSTID="ce4fee3e-c02c-11ee-8442-830d068a36c6"
+  "$TREE_DUMP"
+)
+
+echo "Running command:"
+printf '%q ' "${cmd[@]}"
+printf '> %q\n' "$ACTUAL_OUTPUT"
+
+if ! "${cmd[@]}" > "$ACTUAL_OUTPUT"; then
+    rc=$?
+    echo "test failed (exit code $rc)"
+    exit $rc
+fi
 
 diff -u "${EXPECTED_OUTPUT}" "${ACTUAL_OUTPUT}"
diff --git a/libnvme/test/tree.c b/libnvme/test/tree.c
index a8191e8124..a0ad0a5ad7 100644
--- a/libnvme/test/tree.c
+++ b/libnvme/test/tree.c
@@ -17,6 +17,8 @@
 
 struct test_data {
 	/* input data */
+	const char *hostnqn;
+	const char *hostid;
 	const char *subsysname;
 	const char *subsysnqn;
 	const char *transport;
@@ -31,23 +33,27 @@ struct test_data {
 	int ctrl_id;
 };
 
+#define DEFAULT_HOSTID "9ba1651a-ed36-11f0-9858-6c1ff71ba506"
+#define DEFAULT_HOSTNQN "nqn.2014-08.org.nvmexpress:uuid:9ba1651a-ed36-11f0-9858-6c1ff71ba506"
 #define DEFAULT_SUBSYSNAME "subsysname"
 #define DEFAULT_SUBSYSNQN "subsysnqn"
 #define SRC_ADDR4 "192.168.56.100"
 #define SRC_ADDR6 "1234:5678:abcd:EF01:1234:5678:abcd:EF01"
 
+#define DEFAULTS DEFAULT_HOSTNQN, DEFAULT_HOSTNQN, DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN
+
 struct test_data test_data[] = {
-	{ DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, "tcp", "192.168.1.1", "192.168.1.20", NULL, "4420" },
-	{ DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, "tcp", "192.168.1.1", "192.168.1.20", NULL, "4421" },
-	{ DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, "tcp", "192.168.1.2", "192.168.1.20", "eth1", "4420" },
-	{ DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, "tcp", "192.168.1.2", "192.168.1.20", "eth1", "4421" },
-	{ DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, "rdma", "192.168.1.3", "192.168.1.20", NULL, NULL },
-	{ DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, "rdma", "192.168.1.4", "192.168.1.20", NULL, NULL },
-	{ DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, "fc",
+	{ DEFAULTS, "tcp", "192.168.1.1", "192.168.1.20", NULL, "4420" },
+	{ DEFAULTS, "tcp", "192.168.1.1", "192.168.1.20", NULL, "4421" },
+	{ DEFAULTS, "tcp", "192.168.1.2", "192.168.1.20", "eth1", "4420" },
+	{ DEFAULTS, "tcp", "192.168.1.2", "192.168.1.20", "eth1", "4421" },
+	{ DEFAULTS, "rdma", "192.168.1.3", "192.168.1.20", NULL, NULL },
+	{ DEFAULTS, "rdma", "192.168.1.4", "192.168.1.20", NULL, NULL },
+	{ DEFAULTS, "fc",
 	  "nn-0x201700a09890f5bf:pn-0x201900a09890f5bf",
 	  "nn-0x200000109b579ef3:pn-0x100000109b579ef3"
 	},
-	{ DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, "fc",
+	{ DEFAULTS, "fc",
 	  "nn-0x201700a09890f5bf:pn-0x201900a09890f5bf",
 	  "nn-0x200000109b579ef6:pn-0x100000109b579ef6",
 	},
@@ -125,14 +131,15 @@ static struct nvme_global_ctx *create_tree()
 
 	ctx = nvme_create_global_ctx(stdout, LOG_DEBUG);
 	assert(ctx);
-	nvme_default_host(ctx, &h);
+	nvme_host_get(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
 	assert(h);
 
 	printf("  ctrls created:\n");
 	for (int i = 0; i < ARRAY_SIZE(test_data); i++) {
 		struct test_data *d = &test_data[i];
 
-		d->s = nvme_lookup_subsystem(h, d->subsysname, d->subsysnqn);
+		assert(!nvme_subsystem_get(ctx, h, d->subsysname,
+			d->subsysnqn, &d->s));
 		assert(d->s);
 		d->c = nvme_lookup_ctrl(d->s, d->transport, d->traddr,
 					d->host_traddr, d->host_iface,
@@ -229,7 +236,7 @@ static bool ctrl_lookups(struct nvme_global_ctx *ctx)
 	bool pass = true;
 
 	h = nvme_first_host(ctx);
-	s = nvme_lookup_subsystem(h, DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN);
+	nvme_subsystem_get(ctx, h, DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, &s);
 
 	printf("  lookup controller:\n");
 	for (int i = 0; i < ARRAY_SIZE(test_data); i++) {
@@ -281,10 +288,10 @@ static bool test_src_addr()
 	ctx = nvme_create_global_ctx(stdout, LOG_DEBUG);
 	assert(ctx);
 
-	nvme_default_host(ctx, &h);
+	nvme_host_get(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
 	assert(h);
 
-	s = nvme_lookup_subsystem(h, DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN);
+	nvme_subsystem_get(ctx, h, DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, &s);
 	assert(s);
 
 	c = nvme_lookup_ctrl(s, "tcp", "192.168.56.1", NULL, NULL, "8009", NULL);
@@ -457,10 +464,13 @@ static bool ctrl_match(const char *tag,
 	ctx = nvme_create_global_ctx(stdout, LOG_INFO);
 	assert(ctx);
 
-	nvme_default_host(ctx, &h);
+	nvme_host_get(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
 	assert(h);
 
-	s = nvme_lookup_subsystem(h, DEFAULT_SUBSYSNAME, reference->subsysnqn ? reference->subsysnqn : DEFAULT_SUBSYSNQN);
+	assert(!nvme_subsystem_get(ctx, h, DEFAULT_SUBSYSNAME,
+		 reference->subsysnqn ?
+			reference->subsysnqn : DEFAULT_SUBSYSNQN,
+		&s));
 	assert(s);
 
 	reference_ctrl = nvme_lookup_ctrl(s, reference->transport, reference->traddr,
@@ -1070,10 +1080,13 @@ static bool ctrl_config_match(const char *tag,
 	ctx = nvme_create_global_ctx(stdout, LOG_INFO);
 	assert(ctx);
 
-	nvme_default_host(ctx, &h);
+	nvme_host_get(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
 	assert(h);
 
-	s = nvme_lookup_subsystem(h, DEFAULT_SUBSYSNAME, reference->subsysnqn ? reference->subsysnqn : DEFAULT_SUBSYSNQN);
+	assert(!nvme_subsystem_get(ctx, h, DEFAULT_SUBSYSNAME,
+		reference->subsysnqn ?
+			reference->subsysnqn : DEFAULT_SUBSYSNQN,
+		&s));
 	assert(s);
 
 	reference_ctrl = nvme_lookup_ctrl(s, reference->transport, reference->traddr,
diff --git a/meson.build b/meson.build
index bc1ee82e2d..e5aaab2f34 100644
--- a/meson.build
+++ b/meson.build
@@ -88,6 +88,12 @@ else
     libnvme_so_version = ver_digits + '.0'
 endif
 
+# For PyPI builds, use only the major version (e.g., '3' instead of '3.0.0').
+# This avoids the need for symbolic links which pip/wheel doesn't preserve.
+if get_option('pypi')
+    libnvme_so_version = libnvme_so_version.split('.')[0]
+endif
+
 ################################################################################
 prefixdir      = get_option('prefix')
 bindir         = join_paths(prefixdir, get_option('bindir'))
@@ -495,70 +501,6 @@ substs.set('PREFIX', prefixdir)
 substs.set('URL', 'https://github.com/linux-nvme/nvme-cli/')
 substs.set('VERSION_MAJOR', libnvme_so_version.split('.')[0])
 
-configure_file(
-    input:         'nvme.spec.in',
-    output:        'nvme.spec',
-    configuration: substs,
-)
-
-disc = configure_file(
-    input: 'etc/discovery.conf.in',
-    output: 'discovery.conf',
-    configuration: substs,
-    install: true,
-    install_dir: join_paths(sysconfdir, 'nvme'),
-)
-
-dracut_files = [
-    '70-nvmf-autoconnect.conf',
-]
-
-foreach file : dracut_files
-    configure_file(
-        input: 'nvmf-autoconnect/dracut-conf/' + file + '.in',
-        output: file,
-        configuration: substs,
-        install: true,
-        install_dir: dracutrulesdir,
-    )
-endforeach
-
-systemd_files = [
-    'nvmefc-boot-connections.service',
-    'nvmf-autoconnect.service',
-    'nvmf-connect-nbft.service',
-    'nvmf-connect.target',
-    'nvmf-connect@.service',
-]
-
-foreach file : systemd_files
-    configure_file(
-        input: 'nvmf-autoconnect/systemd/' + file + '.in',
-        output: file,
-        configuration: substs,
-        install: true,
-        install_dir: systemddir,
-    )
-endforeach
-
-udev_files = [
-    '65-persistent-net-nbft.rules',
-    '70-nvmf-autoconnect.rules',
-    '70-nvmf-keys.rules',
-    '71-nvmf-hpe.rules',
-    '71-nvmf-netapp.rules',
-    '71-nvmf-vastdata.rules',
-]
-
-foreach file : udev_files
-    configure_file(
-        input: 'nvmf-autoconnect/udev-rules/' + file + '.in',
-        output: file,
-        configuration: substs,
-        install: true,
-        install_dir: udevrulesdir
-    )
-endforeach
 
 ################################################################################
 subdir('ccan')      # declares: ccan_dep
@@ -606,22 +548,86 @@ if want_nvme
     if get_option('nvme-tests')
         subdir('tests')
     endif
+
+    configure_file(
+        input:         'nvme.spec.in',
+        output:        'nvme.spec',
+        configuration: substs,
+    )
+
+    disc = configure_file(
+        input: 'etc/discovery.conf.in',
+        output: 'discovery.conf',
+        configuration: substs,
+        install: true,
+        install_dir: join_paths(sysconfdir, 'nvme'),
+    )
+
+    dracut_files = [
+        '70-nvmf-autoconnect.conf',
+    ]
+
+    foreach file : dracut_files
+        configure_file(
+            input: 'nvmf-autoconnect/dracut-conf/' + file + '.in',
+            output: file,
+            configuration: substs,
+            install: true,
+            install_dir: dracutrulesdir,
+        )
+    endforeach
+
+    systemd_files = [
+        'nvmefc-boot-connections.service',
+        'nvmf-autoconnect.service',
+        'nvmf-connect-nbft.service',
+        'nvmf-connect.target',
+        'nvmf-connect@.service',
+    ]
+
+    foreach file : systemd_files
+        configure_file(
+            input: 'nvmf-autoconnect/systemd/' + file + '.in',
+            output: file,
+            configuration: substs,
+            install: true,
+            install_dir: systemddir,
+        )
+    endforeach
+
+    udev_files = [
+        '65-persistent-net-nbft.rules',
+        '70-nvmf-autoconnect.rules',
+        '70-nvmf-keys.rules',
+        '71-nvmf-hpe.rules',
+        '71-nvmf-netapp.rules',
+        '71-nvmf-vastdata.rules',
+    ]
+
+    foreach file : udev_files
+        configure_file(
+            input: 'nvmf-autoconnect/udev-rules/' + file + '.in',
+            output: file,
+            configuration: substs,
+            install: true,
+            install_dir: udevrulesdir
+        )
+    endforeach
+
+    install_data(
+        'completions/bash-nvme-completion.sh',
+        rename: 'nvme',
+        install_dir: datadir / 'bash-completion/completions',
+    )
+    install_data(
+        'completions/_nvme',
+        install_dir: datadir / 'zsh/site-functions',
+    )
 endif
 
 subdir('Documentation')
 
 
-################################################################################
-install_data(
-    'completions/bash-nvme-completion.sh',
-    rename: 'nvme',
-    install_dir: datadir / 'bash-completion/completions',
-)
-install_data(
-    'completions/_nvme',
-    install_dir: datadir / 'zsh/site-functions',
-)
-
 ################################################################################
 path_dict = {
     'prefixdir':        prefixdir,
diff --git a/meson_options.txt b/meson_options.txt
index d31fbcdece..4d2fe78309 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -130,3 +130,9 @@ option(
   value: 'disabled',
   description : 'liburing support'
 )
+option(
+  'pypi',
+  type : 'boolean',
+  value : false,
+  description : 'building for PyPI (use short soversion, e.g. libnvme.so.3)'
+)
diff --git a/nvme-print-json.c b/nvme-print-json.c
index ca5d774830..72d17ca60a 100644
--- a/nvme-print-json.c
+++ b/nvme-print-json.c
@@ -4851,6 +4851,8 @@ static void json_simple_topology(struct nvme_global_ctx *ctx)
 			subsystem_attrs = json_create_object();
 			obj_add_str(subsystem_attrs, "Name", nvme_subsystem_get_name(s));
 			obj_add_str(subsystem_attrs, "NQN", nvme_subsystem_get_nqn(s));
+			obj_add_str(subsystem_attrs, "IOPolicy",
+					nvme_subsystem_get_iopolicy(s));
 
 			if (verbose_mode()) {
 				obj_add_str(subsystem_attrs, "Model",
@@ -4859,8 +4861,6 @@ static void json_simple_topology(struct nvme_global_ctx *ctx)
 						nvme_subsystem_get_serial(s));
 				obj_add_str(subsystem_attrs, "Firmware",
 						nvme_subsystem_get_fw_rev(s));
-				obj_add_str(subsystem_attrs, "IOPolicy",
-						nvme_subsystem_get_iopolicy(s));
 				obj_add_str(subsystem_attrs, "Type",
 						nvme_subsystem_get_type(s));
 			}
diff --git a/nvme-print-stdout.c b/nvme-print-stdout.c
index 7995052a3e..09ee8fecee 100644
--- a/nvme-print-stdout.c
+++ b/nvme-print-stdout.c
@@ -1135,7 +1135,7 @@ static void stdout_subsystem_ctrls(nvme_subsystem_t s)
 	}
 }
 
-static void stdout_subsys_config(nvme_subsystem_t s)
+static void stdout_subsys_config(nvme_subsystem_t s, bool show_iopolicy)
 {
 	int len = strlen(nvme_subsystem_get_name(s));
 
@@ -1143,8 +1143,9 @@ static void stdout_subsys_config(nvme_subsystem_t s)
 	       nvme_subsystem_get_nqn(s));
 	printf("%*s   hostnqn=%s\n", len, " ",
 	       nvme_host_get_hostnqn(nvme_subsystem_get_host(s)));
-	printf("%*s   iopolicy=%s\n", len, " ",
-		nvme_subsystem_get_iopolicy(s));
+	if (show_iopolicy)
+		printf("%*s   iopolicy=%s\n", len, " ",
+				nvme_subsystem_get_iopolicy(s));
 
 	if (stdout_print_ops.flags & VERBOSE) {
 		printf("%*s   model=%s\n", len, " ",
@@ -1179,7 +1180,8 @@ static void stdout_subsystem(struct nvme_global_ctx *ctx, bool show_ana)
 				printf("\n");
 			first = false;
 
-			stdout_subsys_config(s);
+			stdout_subsys_config(s,
+					stdout_print_ops.flags & VERBOSE);
 			printf("\\\n");
 
 			if (!show_ana || !stdout_subsystem_multipath(s))
@@ -4901,10 +4903,19 @@ static void stdout_lba_status_info(__u64 result)
 	       (__u32)NVME_FEAT_LBAS_LSIRI(result));
 }
 
+static bool line_equal(unsigned char *buf, int len, int width, int offset)
+{
+	if (!offset || len < offset + width || log_level >= LOG_DEBUG)
+		return false;
+
+	return !memcmp(buf + offset - width, buf + offset, width);
+}
+
 void stdout_d(unsigned char *buf, int len, int width, int group)
 {
 	int i, offset = 0;
 	char ascii[32 + 1] = { 0 };
+	bool omitting = false;
 
 	assert(width < sizeof(ascii));
 
@@ -4914,8 +4925,21 @@ void stdout_d(unsigned char *buf, int len, int width, int group)
 		printf("%3x", i);
 
 	for (i = 0; i < len; i++) {
-		if (!(i % width))
+		if (!(i % width)) {
+			if (line_equal(buf, len, width, offset)) {
+				if (!omitting) {
+					omitting = true;
+					printf("\n*");
+				}
+				offset += width;
+				continue;
+			} else if (omitting) {
+				omitting = false;
+			}
 			printf("\n%04x:", offset);
+		}
+		if (omitting)
+			continue;
 		if (i % group)
 			printf("%02x", buf[i]);
 		else
@@ -4927,6 +4951,8 @@ void stdout_d(unsigned char *buf, int len, int width, int group)
 			memset(ascii, 0, sizeof(ascii));
 		}
 	}
+	if (omitting)
+		printf("\n%04x:\n", offset);
 
 	if (strlen(ascii)) {
 		unsigned int b = width - (i % width);
@@ -6057,7 +6083,7 @@ static void stdout_topology_tabular(struct nvme_global_ctx *ctx)
 				printf("\n");
 			first = false;
 
-			stdout_subsys_config(s);
+			stdout_subsys_config(s, true);
 			printf("\n");
 
 			if (nvme_is_multipath(s))
@@ -6090,7 +6116,7 @@ static void stdout_simple_topology(struct nvme_global_ctx *ctx,
 				printf("\n");
 			first = false;
 
-			stdout_subsys_config(s);
+			stdout_subsys_config(s, true);
 			printf("\\\n");
 
 			if (nvme_is_multipath(s))
diff --git a/nvme-print.c b/nvme-print.c
index 02323b5a04..069fe18cd0 100644
--- a/nvme-print.c
+++ b/nvme-print.c
@@ -520,6 +520,36 @@ void nvme_show_status(int status)
 		ops->show_status(status);
 }
 
+static void nvme_show_cmd_err(const char *msg, bool admin,
+			      struct nvme_passthru_cmd *cmd, int err)
+{
+	if (!err)
+		return;
+	else if (err < 0)
+		nvme_show_error("%s: %s", msg, nvme_strerror(-err));
+	else if (cmd)
+		nvme_show_opcode_status(err, false, cmd->opcode);
+	else
+		nvme_show_status(err);
+}
+
+void nvme_show_err(const char *msg, int err)
+{
+	nvme_show_cmd_err(msg, false, NULL, err);
+}
+
+void nvme_show_io_cmd_err(const char *msg, struct nvme_passthru_cmd *cmd,
+			  int err)
+{
+	nvme_show_cmd_err(msg, false, cmd, err);
+}
+
+void nvme_show_admin_cmd_err(const char *msg, struct nvme_passthru_cmd *cmd,
+			     int err)
+{
+	nvme_show_cmd_err(msg, true, cmd, err);
+}
+
 void nvme_show_opcode_status(int status, bool admin, __u8 opcode)
 {
 	struct print_ops *ops = nvme_print_ops(NORMAL);
diff --git a/nvme-print.h b/nvme-print.h
index 139302808d..0f371d8502 100644
--- a/nvme-print.h
+++ b/nvme-print.h
@@ -159,6 +159,11 @@ struct print_ops *nvme_get_stdout_print_ops(nvme_print_flags_t flags);
 struct print_ops *nvme_get_binary_print_ops(nvme_print_flags_t flags);
 
 void nvme_show_status(int status);
+void nvme_show_err(const char *msg, int err);
+void nvme_show_io_cmd_err(const char *msg, struct nvme_passthru_cmd *cmd,
+			  int err);
+void nvme_show_admin_cmd_err(const char *msg, struct nvme_passthru_cmd *cmd,
+			     int err);
 void nvme_show_opcode_status(int status, bool admin, __u8 opcode);
 void nvme_show_lba_status_info(__u64 result);
 void nvme_show_relatives(struct nvme_global_ctx *ctx, const char *name, nvme_print_flags_t flags);
diff --git a/nvme.c b/nvme.c
index 0592088dfa..4331db36a1 100644
--- a/nvme.c
+++ b/nvme.c
@@ -372,7 +372,6 @@ static int parse_args(int argc, char *argv[], const char *desc,
 		return ret;
 
 	log_level = map_log_level(nvme_cfg.verbose, false);
-	nvme_init_default_logging(stderr, log_level, false, false);
 
 	return 0;
 }
@@ -559,13 +558,13 @@ static int get_smart_log(int argc, char **argv, struct command *acmd, struct plu
 		return -ENOMEM;
 
 	err = nvme_get_log_smart(hdl, cfg.namespace_id, smart_log);
-	if (!err)
-		nvme_show_smart_log(smart_log, cfg.namespace_id,
-				    nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("smart log: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("smart log", err);
+		return err;
+	}
+
+	nvme_show_smart_log(smart_log, cfg.namespace_id,
+			    nvme_transport_handle_get_name(hdl), flags);
 
 	return err;
 }
@@ -631,12 +630,13 @@ static int get_ana_log(int argc, char **argv, struct command *acmd,
 		return -ENOMEM;
 
 	err = nvme_get_ana_log_atomic(hdl, true, cfg.groups, ana_log, &ana_log_len, 10);
-	if (!err)
-		nvme_show_ana_log(ana_log, nvme_transport_handle_get_name(hdl), ana_log_len, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("ana-log: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("ana-log", err);
+		return err;
+	}
+
+	nvme_show_ana_log(ana_log, nvme_transport_handle_get_name(hdl),
+			  ana_log_len, flags);
 
 	return err;
 }
@@ -949,12 +949,11 @@ static int get_telemetry_log(int argc, char **argv, struct command *acmd,
 		err = __get_telemetry_log_host(hdl, cfg.data_area,
 					       &total_size, &log, da4_support);
 
-	if (err < 0) {
-		nvme_show_error("get-telemetry-log: %s", nvme_strerror(err));
-		return err;
-	} else if (err > 0) {
-		nvme_show_status(err);
-		fprintf(stderr, "Failed to acquire telemetry log %d!\n", err);
+	if (err) {
+		nvme_show_err("get-telemetry-log", err);
+		if (err > 0)
+			fprintf(stderr, "Failed to acquire telemetry log %d!\n",
+				err);
 		return err;
 	}
 
@@ -1035,15 +1034,14 @@ static int get_endurance_log(int argc, char **argv, struct command *acmd, struct
 	if (!endurance_log)
 		return -ENOMEM;
 
-	err = nvme_get_log_endurance_group(hdl, cfg.group_id,
-					   endurance_log);
-	if (!err)
-		nvme_show_endurance_log(endurance_log, cfg.group_id,
-					nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("endurance log: %s", nvme_strerror(err));
+	err = nvme_get_log_endurance_group(hdl, cfg.group_id, endurance_log);
+	if (err) {
+		nvme_show_err("endurance log", err);
+		return err;
+	}
+
+	nvme_show_endurance_log(endurance_log, cfg.group_id,
+				nvme_transport_handle_get_name(hdl), flags);
 
 	return err;
 }
@@ -1150,12 +1148,12 @@ static int get_effects_log(int argc, char **argv, struct command *acmd, struct p
 		err = collect_effects_log(hdl, cfg.csi, &log_pages, flags);
 	}
 
-	if (!err)
-		nvme_print_effects_log_pages(&log_pages, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("effects log page");
+	if (err) {
+		nvme_show_err("effects log page", err);
+		goto cleanup_list;
+	}
+
+	nvme_print_effects_log_pages(&log_pages, flags);
 
 cleanup_list:
 	while ((node = list_pop(&log_pages, nvme_effects_log_node_t, node)))
@@ -1195,12 +1193,13 @@ static int get_supported_log_pages(int argc, char **argv, struct command *acmd,
 		return -ENOMEM;
 
 	err = nvme_get_log_supported_log_pages(hdl, supports);
-	if (!err)
-		nvme_show_supported_log(supports, nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("supported log pages: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("supported log pages", err);
+		return err;
+	}
+
+	nvme_show_supported_log(supports, nvme_transport_handle_get_name(hdl),
+				flags);
 
 	return err;
 }
@@ -1267,13 +1266,13 @@ static int get_error_log(int argc, char **argv, struct command *acmd, struct plu
 		return -ENOMEM;
 
 	err = nvme_get_log_error(hdl, NVME_NSID_ALL, cfg.log_entries, err_log);
-	if (!err)
-		nvme_show_error_log(err_log, cfg.log_entries,
-				    nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("error log");
+	if (err) {
+		nvme_show_err("error log", err);
+		return err;
+	}
+
+	nvme_show_error_log(err_log, cfg.log_entries,
+			    nvme_transport_handle_get_name(hdl), flags);
 
 	return err;
 }
@@ -1318,12 +1317,12 @@ static int get_fw_log(int argc, char **argv, struct command *acmd, struct plugin
 		return -ENOMEM;
 
 	err = nvme_get_log_fw_slot(hdl, false, fw_log);
-	if (!err)
-		nvme_show_fw_log(fw_log, nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("fw log: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("fw log", err);
+		return err;
+	}
+
+	nvme_show_fw_log(fw_log, nvme_transport_handle_get_name(hdl), flags);
 
 	return err;
 }
@@ -1376,14 +1375,15 @@ static int get_changed_ns_list_log(int argc, char **argv, bool alloc)
 	else
 		err = nvme_get_log_changed_ns_list(hdl, NVME_NSID_NONE,
 			changed_ns_list_log);
-	if (!err)
-		nvme_show_changed_ns_list_log(changed_ns_list_log, nvme_transport_handle_get_name(hdl),
-					      flags, alloc);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("changed %s ns list log: %s", alloc ? "allocated" : "attached",
-				nvme_strerror(err));
+	if (err) {
+		nvme_show_err(alloc ? "changed allocated ns list log" :
+				     "changed attached ns list log", err);
+		return err;
+	}
+
+	nvme_show_changed_ns_list_log(changed_ns_list_log,
+				      nvme_transport_handle_get_name(hdl),
+				      flags, alloc);
 
 	return err;
 }
@@ -1447,14 +1447,13 @@ static int get_pred_lat_per_nvmset_log(int argc, char **argv,
 
 	err = nvme_get_log_predictable_lat_nvmset(hdl, cfg.nvmset_id,
 						  plpns_log);
-	if (!err)
-		nvme_show_predictable_latency_per_nvmset(plpns_log, cfg.nvmset_id,
-							 nvme_transport_handle_get_name(hdl),
-							 flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("predictable latency per nvm set: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("predictable latency per nvm set", err);
+		return err;
+	}
+
+	nvme_show_predictable_latency_per_nvmset(plpns_log, cfg.nvmset_id,
+	    nvme_transport_handle_get_name(hdl), flags);
 
 	return err;
 }
@@ -1515,11 +1514,8 @@ static int get_pred_lat_event_agg_log(int argc, char **argv,
 		return -ENOMEM;
 
 	err = nvme_identify_ctrl(hdl, ctrl);
-	if (err < 0) {
-		nvme_show_error("identify controller: %s", nvme_strerror(err));
-		return err;
-	} else if (err) {
-		nvme_show_status(err);
+	if (err) {
+		nvme_show_err("identify controller", err);
 		return err;
 	}
 
@@ -1530,16 +1526,16 @@ static int get_pred_lat_event_agg_log(int argc, char **argv,
 	if (!pea_log)
 		return -ENOMEM;
 
-	err = nvme_get_log_predictable_lat_event(hdl, cfg.rae, 0,
-						 pea_log, log_size);
-	if (!err)
-		nvme_show_predictable_latency_event_agg_log(pea_log, cfg.log_entries, log_size,
-							    nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("predictable latency event aggregate log page: %s",
-				nvme_strerror(err));
+	err = nvme_get_log_predictable_lat_event(hdl, cfg.rae, 0, pea_log,
+						 log_size);
+	if (err) {
+		nvme_show_err(
+		    "predictable latency event aggregate log page", err);
+		return err;
+	}
+
+	nvme_show_predictable_latency_event_agg_log(pea_log, cfg.log_entries,
+	    log_size, nvme_transport_handle_get_name(hdl), flags);
 
 	return err;
 }
@@ -1596,13 +1592,10 @@ static int get_persistent_event_log(int argc, char **argv,
 	if (!pevent)
 		return -ENOMEM;
 
-	err = nvme_get_log_persistent_event(hdl, cfg.action,
-					    pevent, sizeof(*pevent));
-	if (err < 0) {
-		nvme_show_error("persistent event log: %s", nvme_strerror(err));
-		return err;
-	} else if (err) {
-		nvme_show_status(err);
+	err = nvme_get_log_persistent_event(hdl, cfg.action, pevent,
+					    sizeof(*pevent));
+	if (err) {
+		nvme_show_err("persistent event log", err);
 		return err;
 	}
 
@@ -1636,32 +1629,28 @@ static int get_persistent_event_log(int argc, char **argv,
 
 	err = nvme_get_log_persistent_event(hdl, cfg.action,
 					    pevent_log_info, cfg.log_len);
-	if (!err) {
-		err = nvme_get_log_persistent_event(hdl, cfg.action,
-							pevent,
-							sizeof(*pevent));
-		if (err < 0) {
-			nvme_show_error("persistent event log: %s", nvme_strerror(err));
-			return err;
-		} else if (err) {
-			nvme_show_status(err);
-			return err;
-		}
-		pevent_collected = pevent_log_info;
-		if (pevent_collected->gen_number != pevent->gen_number) {
-			printf("Collected Persistent Event Log may be invalid,\n"
-			       "Re-read the log is required\n");
-			return -EINVAL;
-		}
+	if (err) {
+		nvme_show_err("persistent event log", err);
+		return err;
+	}
 
-		nvme_show_persistent_event_log(pevent_log_info, cfg.action,
-			cfg.log_len, nvme_transport_handle_get_name(hdl), flags);
-	} else if (err > 0) {
-		nvme_show_status(err);
-	} else {
-		nvme_show_error("persistent event log: %s", nvme_strerror(err));
+	err = nvme_get_log_persistent_event(hdl, cfg.action, pevent,
+					    sizeof(*pevent));
+	if (err) {
+		nvme_show_err("persistent event log", err);
+		return err;
+	}
+
+	pevent_collected = pevent_log_info;
+	if (pevent_collected->gen_number != pevent->gen_number) {
+		printf("Collected Persistent Event Log may be invalid,\n"
+		       "Re-read the log is required\n");
+		return -EINVAL;
 	}
 
+	nvme_show_persistent_event_log(pevent_log_info, cfg.action,
+		cfg.log_len, nvme_transport_handle_get_name(hdl), flags);
+
 	return err;
 }
 
@@ -1736,16 +1725,16 @@ static int get_endurance_event_agg_log(int argc, char **argv,
 	if (!endurance_log)
 		return -ENOMEM;
 
-	err = nvme_get_log_endurance_grp_evt(hdl, cfg.rae, 0,
-					     endurance_log, log_size);
-	if (!err)
-		nvme_show_endurance_group_event_agg_log(endurance_log, cfg.log_entries, log_size,
-							nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("endurance group event aggregate log page: %s",
-				nvme_strerror(err));
+	err = nvme_get_log_endurance_grp_evt(hdl, cfg.rae, 0, endurance_log,
+					     log_size);
+	if (err) {
+		nvme_show_err("endurance group event aggregate log page",
+				     err);
+		return err;
+	}
+
+	nvme_show_endurance_group_event_agg_log(endurance_log, cfg.log_entries,
+	    log_size, nvme_transport_handle_get_name(hdl), flags);
 
 	return err;
 }
@@ -1785,11 +1774,8 @@ static int get_lba_status_log(int argc, char **argv,
 	}
 
 	err = nvme_get_log_lba_status(hdl, false, 0, &lslplen, sizeof(__u32));
-	if (err < 0) {
-		nvme_show_error("lba status log page: %s", nvme_strerror(err));
-		return err;
-	} else if (err) {
-		nvme_show_status(err);
+	if (err) {
+		nvme_show_err("lba status log page", err);
 		return err;
 	}
 
@@ -1798,12 +1784,13 @@ static int get_lba_status_log(int argc, char **argv,
 		return -ENOMEM;
 
 	err = nvme_get_log_lba_status(hdl, cfg.rae, 0, lba_status, lslplen);
-	if (!err)
-		nvme_show_lba_status_log(lba_status, lslplen, nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("lba status log page: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("lba status log page", err);
+		return err;
+	}
+
+	nvme_show_lba_status_log(lba_status, lslplen,
+				 nvme_transport_handle_get_name(hdl), flags);
 
 	return err;
 }
@@ -1839,12 +1826,13 @@ static int get_resv_notif_log(int argc, char **argv,
 		return -ENOMEM;
 
 	err = nvme_get_log_reservation(hdl, resv);
-	if (!err)
-		nvme_show_resv_notif_log(resv, nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("resv notifi log: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("resv notifi log", err);
+		return err;
+	}
+
+	nvme_show_resv_notif_log(resv, nvme_transport_handle_get_name(hdl),
+				 flags);
 
 	return err;
 
@@ -1912,11 +1900,8 @@ static int get_boot_part_log(int argc, char **argv, struct command *acmd, struct
 		return -ENOMEM;
 
 	err = nvme_get_log_boot_partition(hdl, cfg.lsp, boot, sizeof(*boot));
-	if (err < 0) {
-		nvme_show_error("boot partition log: %s", nvme_strerror(err));
-		return err;
-	} else if (err) {
-		nvme_show_status(err);
+	if (err) {
+		nvme_show_err("boot partition log", err);
 		return err;
 	}
 
@@ -1928,22 +1913,20 @@ static int get_boot_part_log(int argc, char **argv, struct command *acmd, struct
 	err = nvme_get_log_boot_partition(hdl, cfg.lsp,
 					  (struct nvme_boot_partition *)bp_log,
 					  sizeof(*boot) + bpsz);
-	if (!err)
-		nvme_show_boot_part_log(&bp_log, nvme_transport_handle_get_name(hdl),
-					sizeof(*boot) + bpsz, flags);
-	else if (err > 0)
-		nvme_show_status(err);
+	if (err)
+		nvme_show_err("boot partition log", err);
 	else
-		nvme_show_error("boot partition log: %s", nvme_strerror(err));
+		nvme_show_boot_part_log(&bp_log,
+					nvme_transport_handle_get_name(hdl),
+					sizeof(*boot) + bpsz, flags);
 
 	err = write(output, (void *) bp_log + sizeof(*boot), bpsz);
 	if (err != bpsz)
 		fprintf(stderr, "Failed to flush all data to file!\n");
 	else
 		printf("Data flushed into file %s\n", cfg.file_name);
-	err = 0;
 
-	return err;
+	return 0;
 }
 
 static int get_phy_rx_eom_log(int argc, char **argv, struct command *acmd,
@@ -2005,14 +1988,10 @@ static int get_phy_rx_eom_log(int argc, char **argv, struct command *acmd,
 	/* Just read measurement, take given action when fetching full log */
 	lsp_tmp = cfg.lsp & 0xf3;
 
-	err = nvme_get_log_phy_rx_eom(hdl, lsp_tmp, cfg.controller, phy_rx_eom_log,
-								  phy_rx_eom_log_len);
+	err = nvme_get_log_phy_rx_eom(hdl, lsp_tmp, cfg.controller,
+				      phy_rx_eom_log, phy_rx_eom_log_len);
 	if (err) {
-		if (err > 0)
-			nvme_show_status(err);
-		else
-			nvme_show_error("phy-rx-eom-log: %s", nvme_strerror(err));
-
+		nvme_show_err("phy-rx-eom-log", err);
 		return err;
 	}
 
@@ -2027,14 +2006,14 @@ static int get_phy_rx_eom_log(int argc, char **argv, struct command *acmd,
 	if (!phy_rx_eom_log)
 		return -ENOMEM;
 
-	err = nvme_get_log_phy_rx_eom(hdl, cfg.lsp, cfg.controller, phy_rx_eom_log,
-								  phy_rx_eom_log_len);
-	if (!err)
-		nvme_show_phy_rx_eom_log(phy_rx_eom_log, cfg.controller, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("phy-rx-eom-log: %s", nvme_strerror(err));
+	err = nvme_get_log_phy_rx_eom(hdl, cfg.lsp, cfg.controller,
+				      phy_rx_eom_log, phy_rx_eom_log_len);
+	if (err) {
+		nvme_show_err("phy-rx-eom-log", err);
+		return err;
+	}
+
+	nvme_show_phy_rx_eom_log(phy_rx_eom_log, cfg.controller, flags);
 
 	return err;
 }
@@ -2082,12 +2061,12 @@ static int get_media_unit_stat_log(int argc, char **argv, struct command *acmd,
 		return -ENOMEM;
 
 	err = nvme_get_log_media_unit_stat(hdl, cfg.domainid, mus);
-	if (!err)
-		nvme_show_media_unit_stat_log(mus, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("media unit status log: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("media unit status log", err);
+		return err;
+	}
+
+	nvme_show_media_unit_stat_log(mus, flags);
 
 	return err;
 }
@@ -2134,14 +2113,14 @@ static int get_supp_cap_config_log(int argc, char **argv, struct command *acmd,
 	if (!cap_log)
 		return -ENOMEM;
 
-	err = nvme_get_log_support_cap_config_list(hdl, cfg.domainid,
-						   cap_log);
-	if (!err)
-		nvme_show_supported_cap_config_log(cap_log, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("supported capacity configuration list log");
+	err = nvme_get_log_support_cap_config_list(hdl, cfg.domainid, cap_log);
+	if (err) {
+		nvme_show_err(
+		    "supported capacity configuration list log", err);
+		return err;
+	}
+
+	nvme_show_supported_cap_config_log(cap_log, flags);
 
 	return err;
 }
@@ -2211,13 +2190,13 @@ static int io_mgmt_send(int argc, char **argv, struct command *acmd, struct plug
 
 	nvme_init_io_mgmt_send(&cmd, cfg.nsid, cfg.mo, cfg.mos, buf, cfg.data_len);
 	err = nvme_submit_io_passthru(hdl, &cmd);
-	if (!err)
-		printf("io-mgmt-send: Success, mos:%u mo:%u nsid:%d\n",
-			cfg.mos, cfg.mo, cfg.nsid);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("io-mgmt-send");
+	if (err) {
+		nvme_show_err("io-mgmt-send", err);
+		return err;
+	}
+
+	printf("io-mgmt-send: Success, mos:%u mo:%u nsid:%d\n", cfg.mos, cfg.mo,
+	       cfg.nsid);
 
 	return err;
 }
@@ -2274,29 +2253,28 @@ static int io_mgmt_recv(int argc, char **argv, struct command *acmd, struct plug
 	nvme_init_io_mgmt_recv(&cmd, cfg.nsid, cfg.mo, cfg.mos, buf,
 		cfg.data_len);
 	err = nvme_submit_io_passthru(hdl, &cmd);
-	if (!err) {
-		printf("io-mgmt-recv: Success, mos:%u mo:%u nsid:%d\n",
-			cfg.mos, cfg.mo, cfg.nsid);
+	if (err) {
+		nvme_show_err("io-mgmt-recv", err);
+		return err;
+	}
 
-		if (cfg.file) {
-			dfd = open(cfg.file, O_WRONLY | O_CREAT, 0644);
-			if (dfd < 0) {
-				nvme_show_perror(cfg.file);
-				return -errno;
-			}
+	printf("io-mgmt-recv: Success, mos:%u mo:%u nsid:%d\n", cfg.mos, cfg.mo,
+	       cfg.nsid);
 
-			err = write(dfd, buf, cfg.data_len);
-			if (err < 0) {
-				nvme_show_perror("write");
-				return -errno;
-			}
-		} else {
-			d((unsigned char *)buf, cfg.data_len, 16, 1);
+	if (cfg.file) {
+		dfd = open(cfg.file, O_WRONLY | O_CREAT, 0644);
+		if (dfd < 0) {
+			nvme_show_perror(cfg.file);
+			return -errno;
+		}
+
+		err = write(dfd, buf, cfg.data_len);
+		if (err < 0) {
+			nvme_show_perror("write");
+			return -errno;
 		}
-	} else if (err > 0) {
-		nvme_show_status(err);
 	} else {
-		nvme_show_perror("io-mgmt-recv");
+		d((unsigned char *)buf, cfg.data_len, 16, 1);
 	}
 
 	return err;
@@ -2487,20 +2465,21 @@ static int get_log(int argc, char **argv, struct command *acmd, struct plugin *p
 			NVME_LOG_CDW14_OT_MASK);
 
 	err = nvme_get_log(hdl, &cmd, cfg.rae, NVME_LOG_PAGE_PDU_SIZE);
-	if (!err) {
-		if (!cfg.raw_binary) {
-			printf("Device:%s log-id:%d namespace-id:%#x\n", nvme_transport_handle_get_name(hdl),
-			       cfg.log_id, cfg.namespace_id);
-			d(log, cfg.log_len, 16, 1);
-			if (argconfig_parse_seen(opts, "verbose"))
-				nvme_show_log(nvme_transport_handle_get_name(hdl), &args, VERBOSE);
-		} else {
-			d_raw((unsigned char *)log, cfg.log_len);
-		}
-	} else if (err > 0) {
-		nvme_show_status(err);
+	if (err) {
+		nvme_show_err("log page", err);
+		return err;
+	}
+
+	if (!cfg.raw_binary) {
+		printf("Device:%s log-id:%d namespace-id:%#x\n",
+		       nvme_transport_handle_get_name(hdl), cfg.log_id,
+		       cfg.namespace_id);
+		d(log, cfg.log_len, 16, 1);
+		if (argconfig_parse_seen(opts, "verbose"))
+			nvme_show_log(nvme_transport_handle_get_name(hdl),
+				      &args, VERBOSE);
 	} else {
-		nvme_show_error("log page: %s", nvme_strerror(err));
+		d_raw((unsigned char *)log, cfg.log_len);
 	}
 
 	return err;
@@ -2554,12 +2533,13 @@ static int sanitize_log(int argc, char **argv, struct command *acmd, struct plug
 		return -ENOMEM;
 
 	err = nvme_get_log_sanitize(hdl, cfg.rae, sanitize_log);
-	if (!err)
-		nvme_show_sanitize_log(sanitize_log, nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("sanitize status log: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("sanitize status log", err);
+		return err;
+	}
+
+	nvme_show_sanitize_log(sanitize_log,
+			       nvme_transport_handle_get_name(hdl), flags);
 
 	return err;
 }
@@ -2604,12 +2584,14 @@ static int get_fid_support_effects_log(int argc, char **argv, struct command *ac
 		return -ENOMEM;
 
 	err = nvme_get_log_fid_supported_effects(hdl, false, fid_support_log);
-	if (!err)
-		nvme_show_fid_support_effects_log(fid_support_log, nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("fid support effects log: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("fid support effects log", err);
+		return err;
+	}
+
+	nvme_show_fid_support_effects_log(fid_support_log,
+					  nvme_transport_handle_get_name(hdl),
+					  flags);
 
 	return err;
 }
@@ -2654,12 +2636,13 @@ static int get_mi_cmd_support_effects_log(int argc, char **argv, struct command
 		return -ENOMEM;
 
 	err = nvme_get_log_mi_cmd_supported_effects(hdl, mi_cmd_support_log);
-	if (!err)
-		nvme_show_mi_cmd_support_effects_log(mi_cmd_support_log, nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("mi command support effects log: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("mi command support effects log", err);
+		return err;
+	}
+
+	nvme_show_mi_cmd_support_effects_log(mi_cmd_support_log,
+	    nvme_transport_handle_get_name(hdl), flags);
 
 	return err;
 }
@@ -2712,12 +2695,12 @@ static int list_ctrl(int argc, char **argv, struct command *acmd, struct plugin
 						cfg.cntid, cntlist);
 
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err)
-		nvme_show_list_ctrl(cntlist, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("id controller list: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("id controller list", err);
+		return err;
+	}
+
+	nvme_show_list_ctrl(cntlist, flags);
 
 	return err;
 }
@@ -2787,12 +2770,12 @@ static int list_ns(int argc, char **argv, struct command *acmd, struct plugin *p
 
 	err = nvme_identify(hdl, cfg.namespace_id - 1, cfg.csi, cns, ns_list,
 			    sizeof(*ns_list));
-	if (!err)
-		nvme_show_list_ns(ns_list, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("id namespace list: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("id namespace list", err);
+		return err;
+	}
+
+	nvme_show_list_ns(ns_list, flags);
 
 	return err;
 }
@@ -2843,12 +2826,13 @@ static int id_ns_lba_format(int argc, char **argv, struct command *acmd, struct
 	err = nvme_identify_csi_ns_user_data_format(hdl, NVME_CSI_NVM,
 						    cfg.lba_format_index,
 						    cfg.uuid_index, ns);
-	if (!err)
-		nvme_show_id_ns(ns, 0, cfg.lba_format_index, true, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("identify namespace for specific LBA format");
+	if (err) {
+		nvme_show_err(
+		    "identify namespace for specific LBA format", err);
+		return err;
+	}
+
+	nvme_show_id_ns(ns, 0, cfg.lba_format_index, true, flags);
 
 	return err;
 }
@@ -2894,12 +2878,12 @@ static int id_endurance_grp_list(int argc, char **argv, struct command *acmd,
 	nvme_init_identify_endurance_group_id(&cmd, cfg.endgrp_id,
 					      endgrp_list);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err)
-		nvme_show_endurance_group_list(endgrp_list, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("Id endurance group list: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("Id endurance group list", err);
+		return err;
+	}
+
+	nvme_show_endurance_group_list(endgrp_list, flags);
 
 	return err;
 }
@@ -3128,10 +3112,7 @@ static int parse_lba_num_si(struct nvme_transport_handle *hdl, const char *opt,
 
 	err = nvme_identify_ctrl(hdl, ctrl);
 	if (err) {
-		if (err < 0)
-			nvme_show_error("identify controller: %s", nvme_strerror(err));
-		else
-			nvme_show_status(err);
+		nvme_show_err("identify controller", err);
 		return err;
 	}
 
@@ -3144,11 +3125,7 @@ static int parse_lba_num_si(struct nvme_transport_handle *hdl, const char *opt,
 	} else {
 		err = nvme_identify_active_ns_list(hdl, nsid - 1, ns_list);
 		if (err) {
-			if (err < 0)
-				nvme_show_error("identify namespace list: %s",
-						nvme_strerror(err));
-			else
-				nvme_show_status(err);
+			nvme_show_err("identify namespace list", err);
 			return err;
 		}
 		nsid = le32_to_cpu(ns_list->ns[0]);
@@ -3160,10 +3137,7 @@ static int parse_lba_num_si(struct nvme_transport_handle *hdl, const char *opt,
 
 	err = nvme_identify_ns(hdl, nsid, ns);
 	if (err) {
-		if (err < 0)
-			nvme_show_error("identify namespace: %s", nvme_strerror(err));
-		else
-			nvme_show_status(err);
+		nvme_show_err("identify namespace", err);
 		return err;
 	}
 
@@ -3327,12 +3301,9 @@ static int create_ns(int argc, char **argv, struct command *acmd, struct plugin
 
 		err = nvme_identify_ns(hdl, NVME_NSID_ALL, ns);
 		if (err) {
-			if (err < 0) {
-				nvme_show_error("identify-namespace: %s", nvme_strerror(err));
-			} else {
+			if (err > 0)
 				fprintf(stderr, "identify failed\n");
-				nvme_show_status(err);
-			}
+			nvme_show_err("identify-namespace", err);
 			return err;
 		}
 		for (i = 0; i <= ns->nlbaf; ++i) {
@@ -3357,12 +3328,9 @@ static int create_ns(int argc, char **argv, struct command *acmd, struct plugin
 
 	err = nvme_identify_ctrl(hdl, id);
 	if (err) {
-		if (err < 0) {
-			nvme_show_error("identify-controller: %s", nvme_strerror(err));
-		} else {
+		if (err > 0)
 			fprintf(stderr, "identify controller failed\n");
-			nvme_show_status(err);
-		}
+		nvme_show_err("identify-controller", err);
 		return err;
 	}
 
@@ -3634,12 +3602,12 @@ int __id_ctrl(int argc, char **argv, struct command *acmd, struct plugin *plugin
 		return -ENOMEM;
 
 	err = nvme_identify_ctrl(hdl, ctrl);
-	if (!err)
-		nvme_show_id_ctrl(ctrl, flags, vs);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("identify controller: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("identify controller", err);
+		return err;
+	}
+
+	nvme_show_id_ctrl(ctrl, flags, vs);
 
 	return err;
 }
@@ -3684,12 +3652,12 @@ static int nvm_id_ctrl(int argc, char **argv, struct command *acmd,
 
 	nvme_init_identify_csi_ctrl(&cmd, NVME_CSI_NVM, ctrl_nvm);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err)
-		nvme_show_id_ctrl_nvm(ctrl_nvm, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("nvm identify controller: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("nvm identify controller", err);
+		return err;
+	}
+
+	nvme_show_id_ctrl_nvm(ctrl_nvm, flags);
 
 	return err;
 }
@@ -3749,7 +3717,7 @@ static int nvm_id_ns(int argc, char **argv, struct command *acmd,
 
 	err = nvme_identify_ns(hdl, cfg.namespace_id, ns);
 	if (err) {
-		nvme_show_status(err);
+		nvme_show_err("nvm identify namespace", err);
 		return err;
 	}
 
@@ -3759,12 +3727,12 @@ static int nvm_id_ns(int argc, char **argv, struct command *acmd,
 
 	err = nvme_identify_csi_ns(hdl, cfg.namespace_id, NVME_CSI_NVM,
 				   cfg.uuid_index, id_ns);
-	if (!err)
-		nvme_show_nvm_id_ns(id_ns, cfg.namespace_id, ns, 0, false, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("nvm identify namespace");
+	if (err) {
+		nvme_show_err("nvm identify csi namespace", err);
+		return err;
+	}
+
+	nvme_show_nvm_id_ns(id_ns, cfg.namespace_id, ns, 0, false, flags);
 
 	return err;
 }
@@ -3826,12 +3794,13 @@ static int nvm_id_ns_lba_format(int argc, char **argv, struct command *acmd, str
 	err = nvme_identify_csi_ns_user_data_format(hdl, NVME_CSI_NVM,
 						    cfg.lba_format_index,
 						    cfg.uuid_index, nvm_ns);
-	if (!err)
-		nvme_show_nvm_id_ns(nvm_ns, 0, ns, cfg.lba_format_index, true, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("NVM identify namespace for specific LBA format");
+	if (err) {
+		nvme_show_err(
+		    "NVM identify namespace for specific LBA format", err);
+		return err;
+	}
+
+	nvme_show_nvm_id_ns(nvm_ns, 0, ns, cfg.lba_format_index, true, flags);
 
 	return err;
 }
@@ -3892,12 +3861,12 @@ static int ns_descs(int argc, char **argv, struct command *acmd, struct plugin *
 		return -ENOMEM;
 
 	err = nvme_identify_ns_descs_list(hdl, cfg.namespace_id, nsdescs);
-	if (!err)
-		nvme_show_id_ns_descs(nsdescs, cfg.namespace_id, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("identify namespace: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("identify namespace", err);
+		return err;
+	}
+
+	nvme_show_id_ns_descs(nsdescs, cfg.namespace_id, flags);
 
 	return err;
 }
@@ -3979,12 +3948,12 @@ static int id_ns(int argc, char **argv, struct command *acmd, struct plugin *plu
 		err = nvme_identify_ns(hdl, cfg.namespace_id, ns);
 	}
 
-	if (!err)
-		nvme_show_id_ns(ns, cfg.namespace_id, 0, false, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("identify namespace: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("identify namespace", err);
+		return err;
+	}
+
+	nvme_show_id_ns(ns, cfg.namespace_id, 0, false, flags);
 
 	return err;
 }
@@ -4051,13 +4020,13 @@ static int cmd_set_independent_id_ns(int argc, char **argv, struct command *acmd
 	nvme_init_identify_csi_independent_identify_id_ns(&cmd,
 							  cfg.namespace_id, ns);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err)
-		nvme_show_cmd_set_independent_id_ns(ns, cfg.namespace_id, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("I/O command set independent identify namespace: %s",
-				nvme_strerror(err));
+	if (err) {
+		nvme_show_err(
+		    "I/O command set independent identify namespace", err);
+		return err;
+	}
+
+	nvme_show_cmd_set_independent_id_ns(ns, cfg.namespace_id, flags);
 
 	return err;
 }
@@ -4091,12 +4060,12 @@ static int id_ns_granularity(int argc, char **argv, struct command *acmd, struct
 		return -ENOMEM;
 
 	err = nvme_identify_ns_granularity(hdl, granularity_list);
-	if (!err)
-		nvme_show_id_ns_granularity_list(granularity_list, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("identify namespace granularity: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("identify namespace granularity", err);
+		return err;
+	}
+
+	nvme_show_id_ns_granularity_list(granularity_list, flags);
 
 	return err;
 }
@@ -4144,12 +4113,12 @@ static int id_nvmset(int argc, char **argv, struct command *acmd, struct plugin
 	nvme_init_identify_nvmset_list(&cmd, NVME_NSID_NONE,
 				       cfg.nvmset_id, nvmset);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err)
-		nvme_show_id_nvmset(nvmset, cfg.nvmset_id, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("identify nvm set list: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("identify nvm set list", err);
+		return err;
+	}
+
+	nvme_show_id_nvmset(nvmset, cfg.nvmset_id, flags);
 
 	return err;
 }
@@ -4203,12 +4172,12 @@ static int id_uuid(int argc, char **argv, struct command *acmd, struct plugin *p
 		return -ENOMEM;
 
 	err = nvme_identify_uuid_list(hdl, uuid_list);
-	if (!err)
-		nvme_show_id_uuid_list(uuid_list, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("identify UUID list: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("identify UUID list", err);
+		return err;
+	}
+
+	nvme_show_id_uuid_list(uuid_list, flags);
 
 	return err;
 }
@@ -4257,15 +4226,14 @@ static int id_iocs(int argc, char **argv, struct command *acmd, struct plugin *p
 
 	nvme_init_identify_command_set_structure(&cmd, cfg.cntid, iocs);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err) {
-		printf("NVMe Identify I/O Command Set:\n");
-		nvme_show_id_iocs(iocs, flags);
-	} else if (err > 0) {
-		nvme_show_status(err);
-	} else {
-		nvme_show_error("NVMe Identify I/O Command Set: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("NVMe Identify I/O Command Set", err);
+		return err;
 	}
 
+	printf("NVMe Identify I/O Command Set:\n");
+	nvme_show_id_iocs(iocs, flags);
+
 	return err;
 }
 
@@ -4310,16 +4278,15 @@ static int id_domain(int argc, char **argv, struct command *acmd, struct plugin
 
 	nvme_init_identify_domain_list(&cmd, cfg.dom_id, id_domain);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err) {
-		printf("NVMe Identify command for Domain List is successful:\n");
-		printf("NVMe Identify Domain List:\n");
-		nvme_show_id_domain_list(id_domain, flags);
-	} else if (err > 0) {
-		nvme_show_status(err);
-	} else {
-		nvme_show_error("NVMe Identify Domain List: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("NVMe Identify Domain List", err);
+		return err;
 	}
 
+	printf("NVMe Identify command for Domain List is successful:\n");
+	printf("NVMe Identify Domain List:\n");
+	nvme_show_id_domain_list(id_domain, flags);
+
 	return err;
 }
 
@@ -4405,13 +4372,13 @@ static int virtual_mgmt(int argc, char **argv, struct command *acmd, struct plug
 
 	nvme_init_virtual_mgmt(&cmd, cfg.act, cfg.rt, cfg.cntlid, cfg.nr);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err)
-		printf("success, Number of Controller Resources Modified (NRM):%" PRIu64"\n",
-			(uint64_t)cmd.result);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("virt-mgmt: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("virt-mgmt", err);
+		return err;
+	}
+
+	printf("success, Number of Controller Resources Modified (NRM):%"
+	       PRIu64 "\n", (uint64_t)cmd.result);
 
 	return err;
 }
@@ -4463,13 +4430,13 @@ static int primary_ctrl_caps(int argc, char **argv, struct command *acmd, struct
 
 	nvme_init_identify_primary_ctrl_cap(&cmd, cfg.cntlid, caps);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err)
-		nvme_show_primary_ctrl_cap(caps, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("identify primary controller capabilities: %s",
-				nvme_strerror(err));
+	if (err) {
+		nvme_show_err("identify primary controller capabilities",
+				     err);
+		return err;
+	}
+
+	nvme_show_primary_ctrl_cap(caps, flags);
 
 	return err;
 }
@@ -4523,12 +4490,12 @@ static int list_secondary_ctrl(int argc, char **argv, struct command *acmd, stru
 
 	nvme_init_identify_secondary_ctrl_list(&cmd, cfg.cntid, sc_list);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err)
-		nvme_show_list_secondary_ctrl(sc_list, cfg.num_entries, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("id secondary controller list: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("id secondary controller list", err);
+		return err;
+	}
+
+	nvme_show_list_secondary_ctrl(sc_list, cfg.num_entries, flags);
 
 	return err;
 }
@@ -4582,10 +4549,7 @@ static int wait_self_test(struct nvme_transport_handle *hdl)
 		err = nvme_get_log_device_self_test(hdl, log);
 		if (err) {
 			printf("\n");
-			if (err < 0)
-				perror("self test log\n");
-			else
-				nvme_show_status(err);
+			nvme_show_err("self test log\n", err);
 			return err;
 		}
 
@@ -4621,12 +4585,12 @@ static void abort_self_test(struct nvme_transport_handle *hdl, __u32 nsid)
 
 	nvme_init_dev_self_test(&cmd, nsid, NVME_DST_STC_ABORT);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err)
-		printf("Aborting device self-test operation\n");
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("Device self-test: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("Device self-test", err);
+		return;
+	}
+
+	printf("Aborting device self-test operation\n");
 }
 
 static int device_self_test(int argc, char **argv, struct command *acmd, struct plugin *plugin)
@@ -4688,10 +4652,7 @@ static int device_self_test(int argc, char **argv, struct command *acmd, struct
 		err = nvme_get_log_device_self_test(hdl, log);
 		if (err) {
 			printf("\n");
-			if (err < 0)
-				perror("self test log\n");
-			else
-				nvme_show_status(err);
+			nvme_show_err("self test log\n", err);
 		}
 
 		if (log->completion == 0) {
@@ -4708,24 +4669,23 @@ static int device_self_test(int argc, char **argv, struct command *acmd, struct
 
 	nvme_init_dev_self_test(&cmd, cfg.namespace_id, cfg.stc);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err) {
-		if (cfg.stc == NVME_ST_CODE_ABORT)
-			printf("Aborting device self-test operation\n");
-		else if (cfg.stc == NVME_ST_CODE_EXTENDED)
-			printf("Extended Device self-test started\n");
-		else if (cfg.stc == NVME_ST_CODE_SHORT)
-			printf("Short Device self-test started\n");
-		else if (cfg.stc == NVME_ST_CODE_HOST_INIT)
-			printf("Host-Initiated Refresh started\n");
-
-		if (cfg.wait && cfg.stc != NVME_ST_CODE_ABORT)
-			err = wait_self_test(hdl);
-	} else if (err > 0) {
-		nvme_show_status(err);
-	} else {
-		nvme_show_error("Device self-test: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("Device self-test", err);
+		goto check_abort;
 	}
 
+	if (cfg.stc == NVME_ST_CODE_ABORT)
+		printf("Aborting device self-test operation\n");
+	else if (cfg.stc == NVME_ST_CODE_EXTENDED)
+		printf("Extended Device self-test started\n");
+	else if (cfg.stc == NVME_ST_CODE_SHORT)
+		printf("Short Device self-test started\n");
+	else if (cfg.stc == NVME_ST_CODE_HOST_INIT)
+		printf("Host-Initiated Refresh started\n");
+
+	if (cfg.wait && cfg.stc != NVME_ST_CODE_ABORT)
+		err = wait_self_test(hdl);
+
 check_abort:
 	if (err == -EINTR)
 		abort_self_test(hdl, cfg.namespace_id);
@@ -4775,12 +4735,13 @@ static int self_test_log(int argc, char **argv, struct command *acmd, struct plu
 		return -ENOMEM;
 
 	err = nvme_get_log_device_self_test(hdl, log);
-	if (!err)
-		nvme_show_self_test_log(log, cfg.dst_entries, 0, nvme_transport_handle_get_name(hdl), flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("self test log: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("self test log", err);
+		return err;
+	}
+
+	nvme_show_self_test_log(log, cfg.dst_entries, 0,
+				nvme_transport_handle_get_name(hdl), flags);
 
 	return err;
 }
@@ -5073,25 +5034,21 @@ static int fw_download_single(struct nvme_transport_handle *hdl, void *fw_buf,
 		fprintf(stderr, "fw-download: error on offset 0x%08x/0x%08x\n",
 			offset, fw_len);
 
-		if (err < 0) {
-			fprintf(stderr, "fw-download: %s\n", nvme_strerror(err));
-		} else {
-			nvme_show_status(err);
-			if (ovr) {
-				/*
-				 * non-ignored ovr error: print a little extra info
-				 * about recovering
-				 */
-				fprintf(stderr,
-					"Use --ignore-ovr to ignore overwrite errors\n");
-
-				/*
-				 * We'll just be attempting more overwrites if
-				 * we retry. DNR will likely be set, but force
-				 * an exit anyway.
-				 */
-				retryable = false;
-			}
+		nvme_show_err("fw-download", err);
+		if (err > 0 && ovr) {
+			/*
+			 * non-ignored ovr error: print a little extra info
+			 * about recovering
+			 */
+			fprintf(stderr,
+				"Use --ignore-ovr to ignore overwrite errors\n");
+
+			/*
+			 * We'll just be attempting more overwrites if
+			 * we retry. DNR will likely be set, but force
+			 * an exit anyway.
+			 */
+			retryable = false;
 		}
 
 		if (!retryable)
@@ -5279,6 +5236,31 @@ static void fw_commit_print_mud(struct nvme_transport_handle *hdl, __u64 result)
 		       "sequence due to processing a command from a Management Endpoint\n");
 }
 
+static void fw_commit_err(int err, __u8 action, __u8 slot, __u8 bpid)
+{
+	__u32 val;
+
+	if (err > 0 && nvme_status_get_type(err) == NVME_STATUS_TYPE_NVME) {
+		val = nvme_status_get_value(err);
+		switch (val & 0x7ff) {
+		case NVME_SC_FW_NEEDS_CONV_RESET:
+		case NVME_SC_FW_NEEDS_SUBSYS_RESET:
+		case NVME_SC_FW_NEEDS_RESET:
+			printf("Success activating firmware action:%d slot:%d",
+			       action, slot);
+			if (action == 6 || action == 7)
+				printf(" bpid:%d", bpid);
+			printf(", but firmware requires %s reset\n",
+			       nvme_fw_status_reset_type(val));
+			return;
+		default:
+			break;
+		}
+	}
+
+	nvme_show_err("fw-commit", err);
+}
+
 static int fw_commit(int argc, char **argv, struct command *acmd, struct plugin *plugin)
 {
 	const char *desc = "Verify downloaded firmware image and "
@@ -5338,40 +5320,18 @@ static int fw_commit(int argc, char **argv, struct command *acmd, struct plugin
 
 	nvme_init_fw_commit(&cmd, cfg.slot, cfg.action, cfg.bpid);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (err < 0) {
-		nvme_show_error("fw-commit: %s", nvme_strerror(err));
-	} else if (err > 0) {
-		__u32 val = nvme_status_get_value(err);
-		int type = nvme_status_get_type(err);
-
-		if (type == NVME_STATUS_TYPE_NVME) {
-			switch (val & 0x7ff) {
-			case NVME_SC_FW_NEEDS_CONV_RESET:
-			case NVME_SC_FW_NEEDS_SUBSYS_RESET:
-			case NVME_SC_FW_NEEDS_RESET:
-				printf("Success activating firmware action:%d slot:%d",
-				       cfg.action, cfg.slot);
-				if (cfg.action == 6 || cfg.action == 7)
-					printf(" bpid:%d", cfg.bpid);
-				printf(", but firmware requires %s reset\n",
-				       nvme_fw_status_reset_type(val));
-				break;
-			default:
-				nvme_show_status(err);
-				break;
-			}
-		} else {
-			nvme_show_status(err);
-		}
-	} else {
-		printf("Success committing firmware action:%d slot:%d",
-		       cfg.action, cfg.slot);
-		if (cfg.action == 6 || cfg.action == 7)
-			printf(" bpid:%d", cfg.bpid);
-		printf("\n");
-		fw_commit_print_mud(hdl, cmd.result);
+	if (err) {
+		fw_commit_err(err, cfg.action, cfg.slot, cfg.bpid);
+		return err;
 	}
 
+	printf("Success committing firmware action:%d slot:%d",
+	       cfg.action, cfg.slot);
+	if (cfg.action == 6 || cfg.action == 7)
+		printf(" bpid:%d", cfg.bpid);
+	printf("\n");
+	fw_commit_print_mud(hdl, cmd.result);
+
 	return err;
 }
 
@@ -5557,10 +5517,10 @@ static int sanitize_cmd(int argc, char **argv, struct command *acmd, struct plug
 	nvme_init_sanitize_nvm(&cmd, cfg.sanact, cfg.ause, cfg.owpass,
 			       cfg.oipbp, cfg.no_dealloc, cfg.emvs, cfg.ovrpat);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("sanitize: %s", nvme_strerror(err));
-	else if (err > 0)
-		nvme_show_status(err);
+	if (err) {
+		nvme_show_err("sanitize", err);
+		return err;
+	}
 
 	return err;
 }
@@ -5643,15 +5603,16 @@ static int sanitize_ns_cmd(int argc, char **argv, struct command *acmd,
 
 	nvme_init_sanitize_ns(&cmd, cfg.sanact, cfg.ause, cfg.emvs);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("sanitize ns: %s", nvme_strerror(err));
-	else if (err > 0)
-		nvme_show_status(err);
+	if (err) {
+		nvme_show_admin_cmd_err("sanitize ns", &cmd, err);
+		return err;
+	}
 
 	return err;
 }
 
-static int nvme_get_single_property(struct nvme_transport_handle *hdl, struct get_reg_config *cfg, __u64 *value)
+static int nvme_get_single_property(struct nvme_transport_handle *hdl,
+				    struct get_reg_config *cfg, __u64 *value)
 {
 	struct nvme_passthru_cmd cmd;
 	int err;
@@ -5669,20 +5630,18 @@ static int nvme_get_single_property(struct nvme_transport_handle *hdl, struct ge
 	}
 
 	if (!cfg->fabrics &&
-	    nvme_status_equals(err, NVME_STATUS_TYPE_NVME, NVME_SC_INVALID_FIELD)) {
+	    nvme_status_equals(err, NVME_STATUS_TYPE_NVME,
+			       NVME_SC_INVALID_FIELD)) {
 		*value = -1;
 		return 0;
 	}
 
-	if (cfg->fabrics && err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("get-property: %s", nvme_strerror(err));
-
+	nvme_show_err("get-property", err);
 	return err;
 }
 
-static int nvme_get_properties(struct nvme_transport_handle *hdl, void **pbar, struct get_reg_config *cfg)
+static int nvme_get_properties(struct nvme_transport_handle *hdl, void **pbar,
+			       struct get_reg_config *cfg)
 {
 	int err, size = getpagesize();
 	bool is_64bit = false;
@@ -6103,13 +6062,13 @@ static int nvme_set_single_property(struct nvme_transport_handle *hdl, int offse
 
 	nvme_init_set_property(&cmd, offset, value);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("set-property: %s", nvme_strerror(err));
-	else if (!err)
-		printf("set-property: %#02x (%s), value: %#"PRIx64"\n", offset,
-		       nvme_register_to_string(offset), value);
-	else if (err > 0)
-		nvme_show_status(err);
+	if (err) {
+		nvme_show_err("set-property", err);
+		return err;
+	}
+
+	printf("set-property: %#02x (%s), value: %#"PRIx64"\n", offset,
+	       nvme_register_to_string(offset), value);
 
 	return err;
 }
@@ -6632,14 +6591,12 @@ static int format_cmd(int argc, char **argv, struct command *acmd, struct plugin
 
 		err = nvme_identify_ns(hdl, cfg.namespace_id, ns);
 		if (err) {
-			if (err < 0) {
-				nvme_show_error("identify-namespace: %s", nvme_strerror(err));
-			} else {
+			if (err > 0)
 				fprintf(stderr, "identify failed\n");
-				nvme_show_status(err);
-			}
+			nvme_show_err("identify-namespace", err);
 			return err;
 		}
+
 		nvme_id_ns_flbas_to_lbaf_inuse(ns->flbas, &prev_lbaf);
 
 		if (cfg.bs) {
@@ -6704,44 +6661,48 @@ static int format_cmd(int argc, char **argv, struct command *acmd, struct plugin
 		cfg.pi, cfg.pil, cfg.ses);
 	cmd.timeout_ms = timeout_ms;
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (err < 0) {
-		nvme_show_error("format: %s", nvme_strerror(err));
-	} else if (err != 0) {
-		nvme_show_status(err);
-	} else {
-		printf("Success formatting namespace:%x\n", cfg.namespace_id);
-		if (nvme_transport_handle_is_direct(hdl) && cfg.lbaf != prev_lbaf) {
-			if (nvme_transport_handle_is_chardev(hdl)) {
-				if (ioctl(nvme_transport_handle_get_fd(hdl), NVME_IOCTL_RESCAN) < 0) {
-					nvme_show_error("failed to rescan namespaces");
-					return -errno;
-				}
-			} else if (cfg.namespace_id != NVME_NSID_ALL) {
-				block_size = 1 << ns->lbaf[cfg.lbaf].ds;
+	if (err) {
+		nvme_show_err("format", err);
+		return err;
+	}
 
-				/*
-				 * If block size has been changed by the format
-				 * command up there, we should notify it to
-				 * kernel blkdev to update its own block size
-				 * to the given one because blkdev will not
-				 * update by itself without re-opening fd.
-				 */
-				if (ioctl(nvme_transport_handle_get_fd(hdl), BLKBSZSET, &block_size) < 0) {
-					nvme_show_error("failed to set block size to %d",
-							block_size);
-					return -errno;
-				}
+	printf("Success formatting namespace:%x\n", cfg.namespace_id);
+	if (nvme_transport_handle_is_direct(hdl) && cfg.lbaf != prev_lbaf) {
+		if (nvme_transport_handle_is_chardev(hdl)) {
+			if (ioctl(nvme_transport_handle_get_fd(hdl),
+				  NVME_IOCTL_RESCAN) < 0) {
+				nvme_show_error("failed to rescan namespaces");
+				return -errno;
+			}
+		} else if (cfg.namespace_id != NVME_NSID_ALL) {
+			block_size = 1 << ns->lbaf[cfg.lbaf].ds;
+
+			/*
+			 * If block size has been changed by the format
+			 * command up there, we should notify it to
+			 * kernel blkdev to update its own block size
+			 * to the given one because blkdev will not
+			 * update by itself without re-opening fd.
+			 */
+			if (ioctl(nvme_transport_handle_get_fd(hdl), BLKBSZSET,
+				  &block_size) < 0) {
+				nvme_show_error(
+				    "failed to set block size to %d",
+				    block_size);
+				return -errno;
+			}
 
-				if (ioctl(nvme_transport_handle_get_fd(hdl), BLKRRPART) < 0) {
-					nvme_show_error("failed to re-read partition table");
-					return -errno;
-				}
+			if (ioctl(nvme_transport_handle_get_fd(hdl),
+				  BLKRRPART) < 0) {
+				nvme_show_error(
+				    "failed to re-read partition table");
+				return -errno;
 			}
 		}
-		if (nvme_transport_handle_is_direct(hdl) && cfg.reset &&
-		    nvme_transport_handle_is_chardev(hdl))
-			nvme_ctrl_reset(hdl);
 	}
+	if (nvme_transport_handle_is_direct(hdl) && cfg.reset &&
+	    nvme_transport_handle_is_chardev(hdl))
+		nvme_ctrl_reset(hdl);
 
 	return err;
 }
@@ -6878,24 +6839,23 @@ static int set_feature(int argc, char **argv, struct command *acmd, struct plugi
 
 	err = nvme_set_features(hdl, cfg.nsid, cfg.fid, cfg.sv, cfg.value, cfg.cdw12,
 			0, cfg.uidx, 0, buf, cfg.data_len, &result);
-	if (err < 0) {
-		nvme_show_error("set-feature: %s", nvme_strerror(err));
-	} else if (!err) {
-		printf("set-feature:%#0*x (%s), value:%#0*"PRIx64", cdw12:%#0*x, save:%#x\n",
-		       cfg.fid ? 4 : 2, cfg.fid,
-		       nvme_feature_to_string(cfg.fid),
-		       cfg.value ? 10 : 8, (uint64_t)cfg.value,
-		       cfg.cdw12 ? 10 : 8, cfg.cdw12, cfg.sv);
-		if (cfg.fid == NVME_FEAT_FID_LBA_STS_INTERVAL)
-			nvme_show_lba_status_info(result);
-		if (buf) {
-			if (cfg.fid == NVME_FEAT_FID_LBA_RANGE)
-				nvme_show_lba_range((struct nvme_lba_range_type *)buf, result, 0);
-			else
-				d(buf, cfg.data_len, 16, 1);
-		}
-	} else if (err > 0) {
-		nvme_show_status(err);
+	if (err) {
+		nvme_show_err("set-feature", err);
+		return err;
+	}
+
+	printf("set-feature:%#0*x (%s), value:%#0*" PRIx64
+	       ", cdw12:%#0*x, save:%#x\n", cfg.fid ? 4 : 2, cfg.fid,
+	       nvme_feature_to_string(cfg.fid), cfg.value ? 10 : 8,
+	       (uint64_t)cfg.value, cfg.cdw12 ? 10 : 8, cfg.cdw12, cfg.sv);
+	if (cfg.fid == NVME_FEAT_FID_LBA_STS_INTERVAL)
+		nvme_show_lba_status_info(result);
+	if (buf) {
+		if (cfg.fid == NVME_FEAT_FID_LBA_RANGE)
+			nvme_show_lba_range((struct nvme_lba_range_type *)buf,
+					    result, 0);
+		else
+			d(buf, cfg.data_len, 16, 1);
 	}
 
 	return err;
@@ -6997,12 +6957,12 @@ static int sec_send(int argc, char **argv, struct command *acmd, struct plugin *
 	nvme_init_security_send(&cmd, cfg.namespace_id, cfg.nssf, cfg.spsp,
 				cfg.secp, cfg.tl, sec_buf, cfg.tl);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("security-send: %s", nvme_strerror(err));
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		printf("NVME Security Send Command Success\n");
+	if (err) {
+		nvme_show_err("security-send", err);
+		return err;
+	}
+
+	printf("NVME Security Send Command Success\n");
 
 	return err;
 }
@@ -7111,8 +7071,9 @@ static int dir_send(int argc, char **argv, struct command *acmd, struct plugin *
 		}
 		err = read(ffd, (void *)buf, cfg.data_len);
 		if (err < 0) {
-			nvme_show_error("failed to read data buffer from input file %s",
-					strerror(errno));
+			nvme_show_error(
+			    "failed to read data buffer from input file %s",
+			    strerror(errno));
 			return -errno;
 		}
 	}
@@ -7121,22 +7082,21 @@ static int dir_send(int argc, char **argv, struct command *acmd, struct plugin *
 		cfg.dspec, buf, cfg.data_len);
 	cmd.cdw12 = dw12;
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (err < 0) {
-		nvme_show_error("dir-send: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("dir-send", err);
 		return err;
 	}
-	if (!err) {
-		printf("dir-send: type %#x, operation %#x, spec_val %#x, nsid %#x, result %#" PRIx64 "\n",
-		       cfg.dtype, cfg.doper, cfg.dspec, cfg.namespace_id,
-		       (uint64_t)cmd.result);
-		if (buf) {
-			if (!cfg.raw_binary)
-				d(buf, cfg.data_len, 16, 1);
-			else
-				d_raw(buf, cfg.data_len);
-		}
-	} else if (err > 0) {
-		nvme_show_status(err);
+
+	printf(
+	    "%s: type %#x, operation %#x, spec_val %#x, nsid %#x, result %#"
+	    PRIx64 "\n", __func__, cfg.dtype, cfg.doper, cfg.dspec,
+	    cfg.namespace_id, (uint64_t)cmd.result);
+
+	if (buf) {
+		if (!cfg.raw_binary)
+			d(buf, cfg.data_len, 16, 1);
+		else
+			d_raw(buf, cfg.data_len);
 	}
 
 	return err;
@@ -7195,12 +7155,12 @@ static int write_uncor(int argc, char **argv, struct command *acmd, struct plugi
 	nvme_init_write_uncorrectable(&cmd, cfg.namespace_id, cfg.start_block,
 		cfg.block_count, cfg.dtype << 4, cfg.dspec);
 	err = nvme_submit_io_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("write uncorrectable: %s", nvme_strerror(err));
-	else if (err != 0)
-		nvme_show_status(err);
-	else
-		printf("NVME Write Uncorrectable Success\n");
+	if (err) {
+		nvme_show_err("write uncorrectable", err);
+		return err;
+	}
+
+	printf("NVME Write Uncorrectable Success\n");
 
 	return err;
 }
@@ -7271,11 +7231,8 @@ static int get_pi_info(struct nvme_transport_handle *hdl,
 		return -ENOMEM;
 
 	err = nvme_identify_ns(hdl, nsid, ns);
-	if (err > 0) {
-		nvme_show_status(err);
-		return err;
-	} else if (err < 0) {
-		nvme_show_error("identify namespace: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("identify namespace", err);
 		return err;
 	}
 
@@ -7287,12 +7244,18 @@ static int get_pi_info(struct nvme_transport_handle *hdl,
 	if (!nvm_ns)
 		return -ENOMEM;
 
-	err = nvme_identify_csi_ns(hdl, nsid, NVME_CSI_NVM, 0,
-			   nvm_ns);
-	if (err)
+	err = nvme_identify_csi_ns(hdl, nsid, NVME_CSI_NVM, 0, nvm_ns);
+	if (!err)
+		get_pif_sts(ns, nvm_ns, &pif, &sts);
+	else if (!nvme_status_equals(err, NVME_STATUS_TYPE_NVME,
+				     NVME_SC_INVALID_FIELD))
+		/*
+		 * Ignore the invalid field error and skip get_pif_sts().
+		 * Keep the I/O commands behavior same as before.
+		 * Since the error returned by drives unsupported.
+		 */
 		return -ENAVAIL;
 
-	get_pif_sts(ns, nvm_ns, &pif, &sts);
 	pi_size = (pif == NVME_NVM_PIF_16B_GUARD) ? 8 : 16;
 	if (NVME_FLBAS_META_EXT(ns->flbas)) {
 		/*
@@ -7301,7 +7264,7 @@ static int get_pi_info(struct nvme_transport_handle *hdl,
 		 *   5.2.2.2 Protection Information and Read Commands
 		 */
 		if (!((prinfo & 0x8) != 0 && ms == pi_size))
-			logical_block_size += ms;
+			lbs += ms;
 	}
 
 	if (invalid_tags(lbst, ilbrt, sts, pif))
@@ -7327,11 +7290,8 @@ static int init_pi_tags(struct nvme_transport_handle *hdl,
 		return -ENOMEM;
 
 	err = nvme_identify_ns(hdl, nsid, ns);
-	if (err < 0) {
-		nvme_show_error("identify namespace: %s", nvme_strerror(err));
-		return err;
-	} else if (err) {
-		nvme_show_status(err);
+	if (err) {
+		nvme_show_err("identify namespace", err);
 		return err;
 	}
 
@@ -7340,18 +7300,24 @@ static int init_pi_tags(struct nvme_transport_handle *hdl,
 		return -ENOMEM;
 
 	err = nvme_identify_csi_ns(hdl, nsid, NVME_CSI_NVM, 0, nvm_ns);
-	if (err)
+	if (!err)
+		get_pif_sts(ns, nvm_ns, &pif, &sts);
+	else if (!nvme_status_equals(err, NVME_STATUS_TYPE_NVME,
+				     NVME_SC_INVALID_FIELD))
+		/*
+		 * Ignore the invalid field error and skip get_pif_sts().
+		 * Keep the I/O commands behavior same as before.
+		 * Since the error returned by drives unsupported.
+		 */
 		return -ENAVAIL;
 
-	get_pif_sts(ns, nvm_ns, &pif, &sts);
-
 	if (invalid_tags(lbst, ilbrt, sts, pif))
 		return -EINVAL;
 
 	nvme_init_var_size_tags(cmd, pif, sts, ilbrt, lbst);
 	nvme_init_app_tag(cmd, lbat, lbatm);
 
-	return err;
+	return 0;
 }
 
 static int write_zeroes(int argc, char **argv,
@@ -7454,27 +7420,31 @@ static int write_zeroes(int argc, char **argv,
 		}
 	}
 
-	nvme_init_write_zeros(&cmd, cfg.nsid, cfg.start_block,
-		cfg.block_count, control, cfg.dspec, 0, 0);
-	err = init_pi_tags(hdl, &cmd, cfg.nsid, cfg.ilbrt, cfg.lbst,
-		cfg.lbat, cfg.lbatm);
-	if (err != 0 && err != -ENAVAIL)
+	nvme_init_write_zeros(&cmd, cfg.nsid, cfg.start_block, cfg.block_count,
+			      control, cfg.dspec, 0, 0);
+
+	err = init_pi_tags(hdl, &cmd, cfg.nsid, cfg.ilbrt, cfg.lbst, cfg.lbat,
+			   cfg.lbatm);
+	if (err && err != -ENAVAIL)
 		return err;
+
 	err = nvme_submit_io_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("write-zeroes: %s", nvme_strerror(err));
-	else if (err != 0)
-		nvme_show_status(err);
-	else {
-		printf("NVME Write Zeroes Success\n");
-		if (cfg.nsz && argconfig_parse_seen(opts, "verbose")) {
-			if (cmd.result & 0x1)
-				printf("All logical blocks in the entire namespace cleared to zero\n");
-			else
-				printf("%d logical blocks cleared to zero\n", cfg.block_count);
-		}
+	if (err) {
+		nvme_show_err("write-zeroes", err);
+		return err;
 	}
 
+	printf("NVME Write Zeroes Success\n");
+
+	if (!cfg.nsz || !argconfig_parse_seen(opts, "verbose"))
+		return err;
+
+	if (cmd.result & 0x1)
+		printf(
+		    "All logical blocks in the entire namespace cleared to zero\n");
+	else
+		printf("%d logical blocks cleared to zero\n", cfg.block_count);
+
 	return err;
 }
 
@@ -7583,12 +7553,12 @@ static int dsm(int argc, char **argv, struct command *acmd, struct plugin *plugi
 	nvme_init_dsm(&cmd, cfg.namespace_id, nb, cfg.idr, cfg.idw, cfg.ad, dsm,
 		      sizeof(*dsm) * nb);
 	err = nvme_submit_io_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("data-set management: %s", nvme_strerror(err));
-	else if (err != 0)
-		nvme_show_status(err);
-	else
-		printf("NVMe DSM: success\n");
+	if (err) {
+		nvme_show_err("data-set management", err);
+		return err;
+	}
+
+	printf("NVMe DSM: success\n");
 
 	return err;
 }
@@ -7801,12 +7771,12 @@ static int copy_cmd(int argc, char **argv, struct command *acmd, struct plugin *
 	if (err != 0 && err != -ENAVAIL)
 		return err;
 	err = nvme_submit_io_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("NVMe Copy: %s", nvme_strerror(err));
-	else if (err != 0)
-		nvme_show_status(err);
-	else
-		nvme_show_key_value("NVMe Copy", "success");
+	if (err) {
+		nvme_show_err("NVMe Copy", err);
+		return err;
+	}
+
+	nvme_show_key_value("NVMe Copy", "success");
 
 	return err;
 }
@@ -7851,12 +7821,12 @@ static int flush_cmd(int argc, char **argv, struct command *acmd, struct plugin
 	}
 
 	err = nvme_flush(hdl, cfg.namespace_id);
-	if (err < 0)
-		nvme_show_error("flush: %s", nvme_strerror(err));
-	else if (err != 0)
-		nvme_show_status(err);
-	else
-		printf("NVMe Flush: success\n");
+	if (err) {
+		nvme_show_err("flush", err);
+		return err;
+	}
+
+	printf("NVMe Flush: success\n");
 
 	return err;
 }
@@ -7929,12 +7899,12 @@ static int resv_acquire(int argc, char **argv, struct command *acmd, struct plug
 	nvme_init_resv_acquire(&cmd, cfg.namespace_id, cfg.racqa, cfg.iekey,
 			       false, cfg.rtype, cfg.crkey, cfg.prkey, payload);
 	err = nvme_submit_io_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("reservation acquire: %s", nvme_strerror(err));
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		printf("NVME Reservation Acquire success\n");
+	if (err) {
+		nvme_show_err("reservation acquire", err);
+		return err;
+	}
+
+	printf("NVME Reservation Acquire success\n");
 
 	return err;
 }
@@ -8011,12 +7981,12 @@ static int resv_register(int argc, char **argv, struct command *acmd, struct plu
 				false, cfg.cptpl, cfg.crkey, cfg.nrkey,
 				payload);
 	err = nvme_submit_io_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("reservation register: %s", nvme_strerror(err));
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		printf("NVME Reservation  success\n");
+	if (err) {
+		nvme_show_err("reservation register", err);
+		return err;
+	}
+
+	printf("NVME Reservation  success\n");
 
 	return err;
 }
@@ -8088,12 +8058,12 @@ static int resv_release(int argc, char **argv, struct command *acmd, struct plug
 	nvme_init_resv_release(&cmd, cfg.nsid, cfg.rrela, cfg.iekey, false,
 		cfg.rtype, cfg.crkey, payload);
 	err = nvme_submit_io_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("reservation release: %s", nvme_strerror(err));
-	else if (err != 0)
-		nvme_show_status(err);
-	else
-		printf("NVME Reservation Release success\n");
+	if (err) {
+		nvme_show_err("reservation release", err);
+		return err;
+	}
+
+	printf("NVME Reservation Release success\n");
 
 	return err;
 }
@@ -8182,12 +8152,12 @@ static int resv_report(int argc, char **argv, struct command *acmd, struct plugi
 
 	nvme_init_resv_report(&cmd, cfg.nsid, cfg.eds, false, status, size);
 	err = nvme_submit_io_passthru(hdl, &cmd);
-	if (!err)
-		nvme_show_resv_report(status, size, cfg.eds, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("reservation report: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("reservation report", err);
+		return err;
+	}
+
+	nvme_show_resv_report(status, size, cfg.eds, flags);
 
 	return err;
 }
@@ -8509,24 +8479,24 @@ static int submit_io(int opcode, char *command, const char *desc, int argc, char
 	gettimeofday(&end_time, NULL);
 	if (cfg.latency)
 		printf(" latency: %s: %llu us\n", command, elapsed_utime(start_time, end_time));
-	if (err < 0) {
-		nvme_show_error("submit-io: %s", nvme_strerror(err));
-	} else if (err) {
-		nvme_show_status(err);
+	if (err) {
+		nvme_show_err("submit-io", err);
+		return err;
+	}
+
+	if (!(opcode & 1) && write(dfd, (void *)buffer, buffer_size) < 0) {
+		nvme_show_error(
+		    "write: %s: failed to write buffer to output file",
+		    strerror(errno));
+		err = -EINVAL;
+	} else if (!(opcode & 1) && cfg.metadata_size &&
+		   write(mfd, (void *)mbuffer, mbuffer_size) < 0) {
+		nvme_show_error(
+		    "write: %s: failed to write meta-data buffer to output file",
+		    strerror(errno));
+		err = -EINVAL;
 	} else {
-		if (!(opcode & 1) && write(dfd, (void *)buffer, buffer_size) < 0) {
-			nvme_show_error("write: %s: failed to write buffer to output file",
-				strerror(errno));
-			err = -EINVAL;
-		} else if (!(opcode & 1) && cfg.metadata_size &&
-			   write(mfd, (void *)mbuffer, mbuffer_size) < 0) {
-			nvme_show_error(
-			    "write: %s: failed to write meta-data buffer to output file",
-			    strerror(errno));
-			err = -EINVAL;
-		} else {
-			fprintf(stderr, "%s: Success\n", command);
-		}
+		fprintf(stderr, "%s: Success\n", command);
 	}
 
 	return err;
@@ -8647,12 +8617,12 @@ static int verify_cmd(int argc, char **argv, struct command *acmd, struct plugin
 	if (err != 0 && err != -ENAVAIL)
 		return err;
 	err = nvme_submit_io_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("verify: %s", nvme_strerror(err));
-	else if (err != 0)
-		nvme_show_status(err);
-	else
-		printf("NVME Verify Success\n");
+	if (err) {
+		nvme_show_err("verify", err);
+		return err;
+	}
+
+	printf("NVME Verify Success\n");
 
 	return err;
 }
@@ -8723,18 +8693,17 @@ static int sec_recv(int argc, char **argv, struct command *acmd, struct plugin *
 	nvme_init_security_receive(&cmd, cfg.namespace_id, cfg.nssf, cfg.spsp,
 				   cfg.secp, cfg.al, sec_buf, cfg.size);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (err < 0) {
-		nvme_show_error("security receive: %s", nvme_strerror(err));
-	} else if (err > 0) {
-		nvme_show_status(err);
-	} else {
-		printf("NVME Security Receive Command Success\n");
-		if (!cfg.raw_binary)
-			d(sec_buf, cfg.size, 16, 1);
-		else if (cfg.size)
-			d_raw((unsigned char *)sec_buf, cfg.size);
+	if (err) {
+		nvme_show_err("security receive", err);
+		return err;
 	}
 
+	printf("NVME Security Receive Command Success\n");
+	if (!cfg.raw_binary)
+		d(sec_buf, cfg.size, 16, 1);
+	else if (cfg.size)
+		d_raw((unsigned char *)sec_buf, cfg.size);
+
 	return err;
 }
 
@@ -8805,12 +8774,12 @@ static int get_lba_status(int argc, char **argv, struct command *acmd,
 	nvme_init_get_lba_status(&cmd, cfg.namespace_id, cfg.slba, cfg.mndw,
 				 cfg.atype, cfg.rl, buf);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err)
-		nvme_show_lba_status(buf, buf_len, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_error("get lba status: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("get lba status", err);
+		return err;
+	}
+
+	nvme_show_lba_status(buf, buf_len, flags);
 
 	return err;
 }
@@ -8873,20 +8842,21 @@ static int capacity_mgmt(int argc, char **argv, struct command *acmd, struct plu
 	nvme_init_capacity_mgmt(&cmd, cfg.operation, cfg.element_id,
 		(__u64)cfg.dw12 << 32 | cfg.dw11);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err) {
-		printf("Capacity Management Command is Success\n");
-		if (cfg.operation == 1)
-			printf("Created Element Identifier for Endurance Group is: %" PRIu64 "\n",
-			       (uint64_t)cmd.result);
-		else if (cfg.operation == 3)
-			printf("Created Element Identifier for NVM Set is: %" PRIu64 "\n",
-			       (uint64_t)cmd.result);
-	} else if (err > 0) {
-		nvme_show_status(err);
-	} else if (err < 0) {
-		nvme_show_error("capacity management: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("capacity management", err);
+		return err;
 	}
 
+	printf("Capacity Management Command is Success\n");
+
+	if (cfg.operation == 1)
+		printf("Created Element Identifier for Endurance Group is: %"
+		       PRIu64 "\n", (uint64_t)cmd.result);
+	else if (cfg.operation == 3)
+		printf(
+		    "Created Element Identifier for NVM Set is: %" PRIu64 "\n",
+		    (uint64_t)cmd.result);
+
 	return err;
 }
 
@@ -8989,13 +8959,13 @@ static int dir_receive(int argc, char **argv, struct command *acmd, struct plugi
 		cfg.dspec, buf, cfg.data_len);
 	cmd.cdw12 = dw12;
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (!err)
-		nvme_directive_show(cfg.dtype, cfg.doper, cfg.dspec, cfg.namespace_id,
-				    cmd.result, buf, cfg.data_len, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else if (err < 0)
-		nvme_show_error("dir-receive: %s", nvme_strerror(err));
+	if (err) {
+		nvme_show_err("dir-receive", err);
+		return err;
+	}
+
+	nvme_directive_show(cfg.dtype, cfg.doper, cfg.dspec, cfg.namespace_id,
+			    cmd.result, buf, cfg.data_len, flags);
 
 	return err;
 }
@@ -9081,12 +9051,12 @@ static int lockdown_cmd(int argc, char **argv, struct command *acmd, struct plug
 	nvme_init_lockdown(&cmd, cfg.scp, cfg.prhbt, cfg.ifc, cfg.ofi,
 			   cfg.uuid);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (err < 0)
-		nvme_show_error("lockdown: %s", nvme_strerror(err));
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		printf("Lockdown Command is Successful\n");
+	if (err) {
+		nvme_show_err("lockdown", err);
+		return err;
+	}
+
+	printf("Lockdown Command is Successful\n");
 
 	return err;
 }
@@ -9335,19 +9305,18 @@ static int passthru(int argc, char **argv, bool admin,
 		       strcmp(cmd_name, "Unknown") ? cmd_name : "Vendor Specific",
 		       elapsed_utime(start_time, end_time));
 
-	if (err < 0) {
-		nvme_show_error("%s: %s", __func__, nvme_strerror(err));
-	} else if (err) {
-		nvme_show_status(err);
-	} else  {
-		fprintf(stderr, "%s Command %s is Success and result: 0x%" PRIx64 "\n",
-			admin ? "Admin" : "IO",
-			strcmp(cmd_name, "Unknown") ?
-			cmd_name : "Vendor Specific", (uint64_t)cmd.result);
-		if (cfg.read)
-			passthru_print_read_output(cfg, data, dfd, mdata, mfd, err);
+	if (err) {
+		nvme_show_err(__func__, err);
+		return err;
 	}
 
+	fprintf(stderr, "%s Command %s is Success and result: 0x%" PRIx64 "\n",
+		admin ? "Admin" : "IO",
+		strcmp(cmd_name, "Unknown") ?
+		cmd_name : "Vendor Specific", (uint64_t)cmd.result);
+	if (cfg.read)
+		passthru_print_read_output(cfg, data, dfd, mdata, mfd, err);
+
 	return err;
 }
 
@@ -9413,6 +9382,7 @@ static int gen_dhchap_key(int argc, char **argv, struct command *acmd, struct pl
 	    "HMAC function to use for key transformation (0 = none, 1 = SHA-256, 2 = SHA-384, 3 = SHA-512).";
 	const char *nqn = "Host NQN to use for key transformation.";
 
+	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_free_ unsigned char *raw_secret = NULL;
 	_cleanup_free_ char *hnqn = NULL;
 	unsigned char key[68];
@@ -9444,6 +9414,12 @@ static int gen_dhchap_key(int argc, char **argv, struct command *acmd, struct pl
 	if (err)
 		return err;
 
+	ctx = nvme_create_global_ctx(stderr, log_level);
+	if (!ctx) {
+		nvme_show_error("Failed to create global context");
+		return -ENOMEM;
+	}
+
 	if (cfg.hmac > 3) {
 		nvme_show_error("Invalid HMAC identifier %u", cfg.hmac);
 		return -EINVAL;
@@ -9516,7 +9492,8 @@ static int gen_dhchap_key(int argc, char **argv, struct command *acmd, struct pl
 		}
 	}
 
-	err = nvme_gen_dhchap_key(cfg.nqn, cfg.hmac, cfg.key_len, raw_secret, key);
+	err = nvme_gen_dhchap_key(ctx, cfg.nqn, cfg.hmac,
+		cfg.key_len, raw_secret, key);
 	if (err)
 		return err;
 
@@ -9622,7 +9599,8 @@ static int check_dhchap_key(int argc, char **argv, struct command *acmd, struct
 	return 0;
 }
 
-static int append_keyfile(const char *keyring, long id, const char *keyfile)
+static int append_keyfile(struct nvme_global_ctx *ctx, const char *keyring,
+		long id, const char *keyfile)
 {
 	_cleanup_free_ unsigned char *key_data = NULL;
 	_cleanup_free_ char *exported_key = NULL;
@@ -9633,14 +9611,14 @@ static int append_keyfile(const char *keyring, long id, const char *keyfile)
 	long kr_id;
 	char type;
 
-	err = nvme_lookup_keyring(keyring, &kr_id);
+	err = nvme_lookup_keyring(ctx, keyring, &kr_id);
 	if (err) {
 		nvme_show_error("Failed to lookup keyring '%s', %s",
 				keyring, strerror(-err));
 		return err;
 	}
 
-	identity = nvme_describe_key_serial(id);
+	identity = nvme_describe_key_serial(ctx, id);
 	if (!identity) {
 		nvme_show_error("Failed to get identity info");
 		return -EINVAL;
@@ -9651,14 +9629,14 @@ static int append_keyfile(const char *keyring, long id, const char *keyfile)
 		return -EINVAL;
 	}
 
-	err = nvme_read_key(kr_id, id, &key_len, &key_data);
+	err = nvme_read_key(ctx, kr_id, id, &key_len, &key_data);
 	if (err) {
 		nvme_show_error("Failed to read back derive TLS PSK, %s",
 			strerror(-err));
 		return err;
 	}
 
-	err = nvme_export_tls_key_versioned(ver, hmac, key_data,
+	err = nvme_export_tls_key_versioned(ctx, ver, hmac, key_data,
 					    key_len, &exported_key);
 	if (err) {
 		nvme_show_error("Failed to export key, %s",
@@ -9707,6 +9685,7 @@ static int gen_tls_key(int argc, char **argv, struct command *acmd, struct plugi
 	const char *keyfile = "Update key file with the derive TLS PSK.";
 	const char *compat = "Use non-RFC 8446 compliant algorithm for deriving TLS PSK for older implementations";
 
+	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_free_ unsigned char *raw_secret = NULL;
 	_cleanup_free_ char *encoded_key = NULL;
 	_cleanup_free_ char *hnqn = NULL;
@@ -9780,6 +9759,12 @@ static int gen_tls_key(int argc, char **argv, struct command *acmd, struct plugi
 	if (cfg.hmac == 2)
 		key_len = 48;
 
+	ctx = nvme_create_global_ctx(stderr, log_level);
+	if (!ctx) {
+		nvme_show_error("Failed to create global context");
+		return -ENOMEM;
+	}
+
 	raw_secret = malloc(key_len + 4);
 	if (!raw_secret)
 		return -ENOMEM;
@@ -9807,7 +9792,7 @@ static int gen_tls_key(int argc, char **argv, struct command *acmd, struct plugi
 		}
 	}
 
-	err = nvme_export_tls_key(raw_secret, key_len, &encoded_key);
+	err = nvme_export_tls_key(ctx, raw_secret, key_len, &encoded_key);
 	if (err) {
 		nvme_show_error("Failed to export key, %s", strerror(-err));
 		return err;
@@ -9816,15 +9801,15 @@ static int gen_tls_key(int argc, char **argv, struct command *acmd, struct plugi
 
 	if (cfg.insert) {
 		if (cfg.compat)
-			err = nvme_insert_tls_key_compat(cfg.keyring,
-					cfg.keytype, cfg.hostnqn,
-					cfg.subsysnqn, cfg.version,
-					cfg.hmac, raw_secret, key_len, &tls_key);
+			err = nvme_insert_tls_key_compat(ctx, cfg.keyring,
+				cfg.keytype, cfg.hostnqn,
+				cfg.subsysnqn, cfg.version,
+				cfg.hmac, raw_secret, key_len, &tls_key);
 		else
-			err = nvme_insert_tls_key_versioned(cfg.keyring,
-					cfg.keytype, cfg.hostnqn,
-					cfg.subsysnqn, cfg.version,
-					cfg.hmac, raw_secret, key_len, &tls_key);
+			err = nvme_insert_tls_key_versioned(ctx, cfg.keyring,
+				cfg.keytype, cfg.hostnqn,
+				cfg.subsysnqn, cfg.version,
+				cfg.hmac, raw_secret, key_len, &tls_key);
 		if (err) {
 			nvme_show_error("Failed to insert key, error %d", err);
 			return err;
@@ -9833,7 +9818,8 @@ static int gen_tls_key(int argc, char **argv, struct command *acmd, struct plugi
 		printf("Inserted TLS key %08x\n", (unsigned int)tls_key);
 
 		if (cfg.keyfile) {
-			err = append_keyfile(cfg.keyring, tls_key, cfg.keyfile);
+			err = append_keyfile(ctx, cfg.keyring,
+				tls_key, cfg.keyfile);
 			if (err)
 				return err;
 		}
@@ -9855,6 +9841,7 @@ static int check_tls_key(int argc, char **argv, struct command *acmd, struct plu
 	const char *keyfile = "Update key file with the derive TLS PSK.";
 	const char *compat = "Use non-RFC 8446 compliant algorithm for checking TLS PSK for older implementations.";
 
+	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_free_ unsigned char *decoded_key = NULL;
 	_cleanup_free_ char *hnqn = NULL;
 	int decoded_len, err = 0;
@@ -9909,7 +9896,14 @@ static int check_tls_key(int argc, char **argv, struct command *acmd, struct plu
 		return -EINVAL;
 	}
 
-	err = nvme_import_tls_key(cfg.keydata, &decoded_len, &hmac, &decoded_key);
+	ctx = nvme_create_global_ctx(stderr, log_level);
+	if (!ctx) {
+		nvme_show_error("Failed to create global context");
+		return -ENOMEM;
+	}
+
+	err = nvme_import_tls_key(ctx, cfg.keydata, &decoded_len,
+		&hmac, &decoded_key);
 	if (err) {
 		nvme_show_error("Key decoding failed, error %d\n", err);
 		return err;
@@ -9930,17 +9924,17 @@ static int check_tls_key(int argc, char **argv, struct command *acmd, struct plu
 
 	if (cfg.insert) {
 		if (cfg.compat)
-			err = nvme_insert_tls_key_compat(cfg.keyring,
-					cfg.keytype, cfg.hostnqn,
-					cfg.subsysnqn, cfg.identity,
-					hmac, decoded_key, decoded_len,
-					&tls_key);
+			err = nvme_insert_tls_key_compat(ctx, cfg.keyring,
+				cfg.keytype, cfg.hostnqn,
+				cfg.subsysnqn, cfg.identity,
+				hmac, decoded_key, decoded_len,
+				&tls_key);
 		else
-			err = nvme_insert_tls_key_versioned(cfg.keyring,
-					cfg.keytype, cfg.hostnqn,
-					cfg.subsysnqn, cfg.identity,
-					hmac, decoded_key, decoded_len,
-					&tls_key);
+			err = nvme_insert_tls_key_versioned(ctx, cfg.keyring,
+				cfg.keytype, cfg.hostnqn,
+				cfg.subsysnqn, cfg.identity,
+				hmac, decoded_key, decoded_len,
+				&tls_key);
 		if (err) {
 			nvme_show_error("Failed to insert key, error %d", err);
 			return err;
@@ -9948,7 +9942,8 @@ static int check_tls_key(int argc, char **argv, struct command *acmd, struct plu
 		printf("Inserted TLS key %08x\n", (unsigned int)tls_key);
 
 		if (cfg.keyfile) {
-			err = append_keyfile(cfg.keyring, tls_key, cfg.keyfile);
+			err = append_keyfile(ctx, cfg.keyring,
+				tls_key, cfg.keyfile);
 			if (err)
 				return err;
 		}
@@ -9956,15 +9951,15 @@ static int check_tls_key(int argc, char **argv, struct command *acmd, struct plu
 		_cleanup_free_ char *tls_id = NULL;
 
 		if (cfg.compat)
-			err = nvme_generate_tls_key_identity_compat(cfg.hostnqn,
-					cfg.subsysnqn, cfg.identity,
-					hmac, decoded_key, decoded_len,
-					&tls_id);
+			err = nvme_generate_tls_key_identity_compat(ctx,
+				cfg.hostnqn, cfg.subsysnqn, cfg.identity,
+				hmac, decoded_key, decoded_len,
+				&tls_id);
 		else
-			err = nvme_generate_tls_key_identity(cfg.hostnqn,
-					cfg.subsysnqn, cfg.identity,
-					hmac, decoded_key, decoded_len,
-					&tls_id);
+			err = nvme_generate_tls_key_identity(ctx,
+				cfg.hostnqn, cfg.subsysnqn, cfg.identity,
+				hmac, decoded_key, decoded_len,
+				&tls_id);
 		if (err) {
 			nvme_show_error("Failed to generate identity, error %d",
 					err);
@@ -9975,8 +9970,8 @@ static int check_tls_key(int argc, char **argv, struct command *acmd, struct plu
 	return 0;
 }
 
-static void __scan_tls_key(long keyring_id, long key_id,
-			   char *desc, int desc_len, void *data)
+static void __scan_tls_key(struct nvme_global_ctx *ctx, long keyring_id,
+		long key_id, char *desc, int desc_len, void *data)
 {
 	FILE *fd = data;
 	_cleanup_free_ unsigned char *key_data = NULL;
@@ -9986,21 +9981,22 @@ static void __scan_tls_key(long keyring_id, long key_id,
 	char type;
 	int err;
 
-	err = nvme_read_key(keyring_id, key_id, &key_len, &key_data);
+	err = nvme_read_key(ctx, keyring_id, key_id, &key_len, &key_data);
 	if (err)
 		return;
 
 	if (sscanf(desc, "NVMe%01d%c%02d %*s", &ver, &type, &hmac) != 3)
 		return;
 
-	err = nvme_export_tls_key_versioned(ver, hmac, key_data, key_len,
-					    &encoded_key);
+	err = nvme_export_tls_key_versioned(ctx, ver, hmac, key_data, key_len,
+		&encoded_key);
 	if (err)
 		return;
 	fprintf(fd, "%s %s\n", desc, encoded_key);
 }
 
-static int import_key(const char *keyring, FILE *fd)
+static int import_key(struct nvme_global_ctx *ctx, const char *keyring,
+		FILE *fd)
 {
 	long keyring_id, key;
 	char tls_str[512];
@@ -10010,7 +10006,7 @@ static int import_key(const char *keyring, FILE *fd)
 	int linenum = -1, key_len;
 	int err;
 
-	err = nvme_lookup_keyring(keyring, &keyring_id);
+	err = nvme_lookup_keyring(ctx, keyring, &keyring_id);
 	if (err) {
 		nvme_show_error("Invalid keyring '%s'", keyring);
 		return err;
@@ -10027,13 +10023,13 @@ static int import_key(const char *keyring, FILE *fd)
 		*tls_key = '\0';
 		tls_key++;
 		tls_key[strcspn(tls_key, "\n")] = 0;
-		err = nvme_import_tls_key(tls_key, &key_len, &hmac, &psk);
+		err = nvme_import_tls_key(ctx, tls_key, &key_len, &hmac, &psk);
 		if (err) {
 			nvme_show_error("Failed to import key in line %d",
 					linenum);
 			continue;
 		}
-		err = nvme_update_key(keyring_id, "psk", tls_str,
+		err = nvme_update_key(ctx, keyring_id, "psk", tls_str,
 				psk, key_len, &key);
 		if (err)
 			continue;
@@ -10054,6 +10050,7 @@ static int tls_key(int argc, char **argv, struct command *acmd, struct plugin *p
 	const char *export = "Export all keys from the keyring.";
 	const char *revoke = "Revoke key from the keyring.";
 
+	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_file_ FILE *fd = NULL;
 	mode_t old_umask = 0;
 	int cnt, err = 0;
@@ -10088,6 +10085,12 @@ static int tls_key(int argc, char **argv, struct command *acmd, struct plugin *p
 	if (err)
 		return err;
 
+	ctx = nvme_create_global_ctx(stderr, log_level);
+	if (!ctx) {
+		nvme_show_error("Failed to create global context");
+		return -ENOMEM;
+	}
+
 	if (cfg.keyfile) {
 		const char *mode;
 
@@ -10120,7 +10123,7 @@ static int tls_key(int argc, char **argv, struct command *acmd, struct plugin *p
 		nvme_show_error("Must specify either --import, --export or --revoke");
 		return -EINVAL;
 	} else if (cfg.export) {
-		err = nvme_scan_tls_keys(cfg.keyring, __scan_tls_key, fd);
+		err = nvme_scan_tls_keys(ctx, cfg.keyring, __scan_tls_key, fd);
 		if (err < 0) {
 			nvme_show_error("Export of TLS keys failed with '%s'",
 				nvme_strerror(err));
@@ -10132,7 +10135,7 @@ static int tls_key(int argc, char **argv, struct command *acmd, struct plugin *p
 
 		return 0;
 	} else if (cfg.import) {
-		err = import_key(cfg.keyring, fd);
+		err = import_key(ctx, cfg.keyring, fd);
 		if (err) {
 			nvme_show_error("Import of TLS keys failed with '%s'",
 					nvme_strerror(err));
@@ -10142,7 +10145,8 @@ static int tls_key(int argc, char **argv, struct command *acmd, struct plugin *p
 		if (argconfig_parse_seen(opts, "verbose"))
 			printf("importing from %s\n", cfg.keyfile);
 	} else {
-		err = nvme_revoke_tls_key(cfg.keyring, cfg.keytype, cfg.revoke);
+		err = nvme_revoke_tls_key(ctx, cfg.keyring, cfg.keytype,
+			cfg.revoke);
 		if (err) {
 			nvme_show_error("Failed to revoke key '%s'",
 					nvme_strerror(err));
@@ -10396,23 +10400,23 @@ static int nvme_mi(int argc, char **argv, __u8 admin_opcode, const char *desc)
 	};
 
 	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (err < 0) {
-		nvme_show_error("nmi_recv: %s", nvme_strerror(err));
-	} else if (err) {
-		nvme_show_status(err);
-	} else  {
-		result = cmd.result;
-		printf(
-		    "%s Command is Success and result: 0x%08x (status: 0x%02x, response: 0x%06x)\n",
-		    nvme_cmd_to_string(true, admin_opcode), result, result & 0xff, result >> 8);
-		if (result & 0xff)
-			printf("status: %s\n", nvme_mi_status_to_string(result & 0xff));
-		if (!send && strlen(cfg.input_file)) {
-			if (write(fd, (void *)data, cfg.data_len) < 0)
-				perror("failed to write data buffer");
-		} else if (data && !send && !err) {
-			d((unsigned char *)data, cfg.data_len, 16, 1);
-		}
+	if (err) {
+		nvme_show_err("nmi_recv", err);
+		return err;
+	}
+
+	result = cmd.result;
+	printf(
+	    "%s Command is Success and result: 0x%08x (status: 0x%02x, response: 0x%06x)\n",
+	    nvme_cmd_to_string(true, admin_opcode), result, result & 0xff,
+	    result >> 8);
+	if (result & 0xff)
+		printf("status: %s\n", nvme_mi_status_to_string(result & 0xff));
+	if (!send && strlen(cfg.input_file)) {
+		if (write(fd, (void *)data, cfg.data_len) < 0)
+			perror("failed to write data buffer");
+	} else if (data && !send && !err) {
+		d((unsigned char *)data, cfg.data_len, 16, 1);
 	}
 
 	return err;
@@ -10460,12 +10464,12 @@ static int get_mgmt_addr_list_log(int argc, char **argv, struct command *acmd, s
 		return -ENOMEM;
 
 	err = nvme_get_log_mgmt_addr_list(hdl, ma_log, sizeof(*ma_log));
-	if (!err)
-		nvme_show_mgmt_addr_list_log(ma_log, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("management address list log");
+	if (err) {
+		nvme_show_err("management address list log", err);
+		return err;
+	}
+
+	nvme_show_mgmt_addr_list_log(ma_log, flags);
 
 	return err;
 }
@@ -10507,12 +10511,12 @@ static int get_rotational_media_info_log(int argc, char **argv, struct command *
 		return -ENOMEM;
 
 	err = nvme_get_log_rotational_media_info(hdl, cfg.endgid, info, sizeof(*info));
-	if (!err)
-		nvme_show_rotational_media_info_log(info, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("rotational media info log");
+	if (err) {
+		nvme_show_err("rotational media info log", err);
+		return err;
+	}
+
+	nvme_show_rotational_media_info_log(info, flags);
 
 	return err;
 }
@@ -10589,12 +10593,12 @@ static int get_dispersed_ns_participating_nss_log(int argc, char **argv, struct
 	}
 
 	err = get_dispersed_ns_psub(hdl, cfg.namespace_id, &log);
-	if (!err)
-		nvme_show_dispersed_ns_psub_log(log, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("dispersed ns participating nss log");
+	if (err) {
+		nvme_show_err("dispersed ns participating nss log", err);
+		return err;
+	}
+
+	nvme_show_dispersed_ns_psub_log(log, flags);
 
 	return err;
 }
@@ -10738,12 +10742,12 @@ static int get_reachability_groups_log(int argc, char **argv, struct command *ac
 	}
 
 	err = get_reachability_groups(hdl, cfg.rgo, cfg.rae, &log, &len);
-	if (!err)
-		nvme_show_reachability_groups_log(log, len, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("reachability groups log");
+	if (err) {
+		nvme_show_err("reachability groups log", err);
+		return err;
+	}
+
+	nvme_show_reachability_groups_log(log, len, flags);
 
 	return err;
 }
@@ -10849,12 +10853,12 @@ static int get_reachability_associations_log(int argc, char **argv, struct comma
 	}
 
 	err = get_reachability_associations(hdl, cfg.rao, cfg.rae, &log, &len);
-	if (!err)
-		nvme_show_reachability_associations_log(log, len, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("reachability associations log");
+	if (err) {
+		nvme_show_err("reachability associations log", err);
+		return err;
+	}
+
+	nvme_show_reachability_associations_log(log, len, flags);
 
 	return err;
 }
@@ -10930,12 +10934,12 @@ static int get_host_discovery_log(int argc, char **argv, struct command *acmd, s
 	}
 
 	err = get_host_discovery(hdl, cfg.allhoste, cfg.rae, &log);
-	if (!err)
-		nvme_show_host_discovery_log(log, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("host discovery log");
+	if (err) {
+		nvme_show_err("host discovery log", err);
+		return err;
+	}
+
+	nvme_show_host_discovery_log(log, flags);
 
 	return err;
 }
@@ -11004,12 +11008,12 @@ static int get_ave_discovery_log(int argc, char **argv, struct command *acmd, st
 	}
 
 	err = get_ave_discovery(hdl, cfg.rae, &log);
-	if (!err)
-		nvme_show_ave_discovery_log(log, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("ave discovery log");
+	if (err) {
+		nvme_show_err("ave discovery log", err);
+		return err;
+	}
+
+	nvme_show_ave_discovery_log(log, flags);
 
 	return err;
 }
@@ -11080,12 +11084,12 @@ static int get_pull_model_ddc_req_log(int argc, char **argv, struct command *acm
 	}
 
 	err = get_pull_model_ddc_req(hdl, cfg.rae, &log);
-	if (!err)
-		nvme_show_pull_model_ddc_req_log(log, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		nvme_show_perror("pull model ddc req log");
+	if (err) {
+		nvme_show_err("pull model ddc req log", err);
+		return err;
+	}
+
+	nvme_show_pull_model_ddc_req_log(log, flags);
 
 	return err;
 }
diff --git a/plugins/nbft/nbft-plugin.c b/plugins/nbft/nbft-plugin.c
index 1770bd7607..4f21689e91 100644
--- a/plugins/nbft/nbft-plugin.c
+++ b/plugins/nbft/nbft-plugin.c
@@ -534,13 +534,14 @@ static void normal_show_nbfts(struct nbft_file_entry *head, bool show_subsys,
 int show_nbft(int argc, char **argv, struct command *acmd, struct plugin *plugin)
 {
 	const char *desc = "Display contents of the ACPI NBFT files.";
+	bool show_subsys = false, show_hfi = false, show_discovery = false;
+	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	struct nbft_file_entry *head = NULL;
 	struct list_head nbft_list;
 	char *format = "normal";
 	char *nbft_path = NBFT_SYSFS_PATH;
 	nvme_print_flags_t flags;
 	int ret;
-	bool show_subsys = false, show_hfi = false, show_discovery = false;
 	unsigned int verbose = 0;
 
 	OPT_ARGS(opts) = {
@@ -558,17 +559,22 @@ int show_nbft(int argc, char **argv, struct command *acmd, struct plugin *plugin
 		return ret;
 
 	log_level = map_log_level(verbose, false /* quiet */);
-	nvme_init_default_logging(stderr, log_level, false, false);
 
 	ret = validate_output_format(format, &flags);
 	if (ret < 0)
 		return ret;
 
+	ctx = nvme_create_global_ctx(stderr, log_level);
+	if (!ctx) {
+		nvme_show_error("Failed to create global context");
+		return -ENOMEM;
+	}
+
 	if (!(show_subsys || show_hfi || show_discovery))
 		show_subsys = show_hfi = show_discovery = true;
 
 	list_head_init(&nbft_list);
-	ret = nvmf_nbft_read_files(nbft_path, &head);
+	ret = nvmf_nbft_read_files(ctx, nbft_path, &head);
 	if (!ret && head) {
 		if (flags == NORMAL)
 			normal_show_nbfts(head, show_subsys,
@@ -576,7 +582,7 @@ int show_nbft(int argc, char **argv, struct command *acmd, struct plugin *plugin
 		else if (flags == JSON)
 			ret = json_show_nbfts(head, show_subsys,
 				show_hfi, show_discovery);
-		nvmf_nbft_free(head);
+		nvmf_nbft_free(ctx, head);
 	}
 	return ret;
 }
diff --git a/plugins/ocp/ocp-print-json.c b/plugins/ocp/ocp-print-json.c
index a8c18ec18a..4a88ff2b23 100644
--- a/plugins/ocp/ocp-print-json.c
+++ b/plugins/ocp/ocp-print-json.c
@@ -226,6 +226,14 @@ static void json_smart_extended_log_v1(struct ocp_smart_extended_log *log)
 	case 0 ... 1:
 		break;
 	default:
+	case 6:
+		json_object_add_value_uint(root, "Form factor",
+						log->form_factor);
+		json_object_add_value_uint64(root, "Die use badnandblock raw",
+			int48_to_long(log->die_in_use_bad_nand_block_raw));
+		json_object_add_value_uint(root, "Die use badnandblock normal",
+			le16_to_cpu(log->die_in_use_bad_nand_block_normalized));
+		fallthrough;
 	case 5:
 		json_object_add_value_uint(root, "NVMe Over Pcie Errata Version",
 						log->nvme_over_pcie_errate_version);
diff --git a/plugins/ocp/ocp-print-stdout.c b/plugins/ocp/ocp-print-stdout.c
index 3c884c43a2..185b99a3ac 100644
--- a/plugins/ocp/ocp-print-stdout.c
+++ b/plugins/ocp/ocp-print-stdout.c
@@ -168,6 +168,14 @@ static void stdout_smart_extended_log(struct ocp_smart_extended_log *log, unsign
 	case 0 ... 1:
 		break;
 	default:
+	case 6:
+		printf("  Form factor					%d\n",
+			log->form_factor);
+		printf("  Die in use badnandblock-Raw		%"PRIu64"\n",
+			int48_to_long(log->die_in_use_bad_nand_block_raw));
+		printf("  Die in use badnandblock-Normal		%d\n",
+			le16_to_cpu(log->die_in_use_bad_nand_block_normalized));
+		fallthrough;
 	case 5:
 		printf("  NVMe Over Pcie Errata Version			%d\n",
 			log->nvme_over_pcie_errate_version);
diff --git a/plugins/ocp/ocp-smart-extended-log.h b/plugins/ocp/ocp-smart-extended-log.h
index 9ac52e508f..bbb2cefc1e 100644
--- a/plugins/ocp/ocp-smart-extended-log.h
+++ b/plugins/ocp/ocp-smart-extended-log.h
@@ -128,7 +128,7 @@ struct ocp_smart_extended_log {
 	__le16 total_die_failure_tolerance;		/* [219:218] */
 	__le16 media_dies_offline;			/* [221:220] */
 	__u8   max_temperature_recorded;		/* [222] */
-	__u8   rsvd223;					/* [223] */
+	__u8   form_factor;				/* [223] */
 	__le64 nand_avg_erase_count;			/* [231:224] */
 	__le32 command_timeouts;			/* [235:232] */
 	__le32 sys_area_program_fail_count_raw;		/* [239:236] */
@@ -145,8 +145,10 @@ struct ocp_smart_extended_log {
 	__u8   lifetime_power_consumed[6];		/* [269:264] */
 	__u8   dssd_firmware_revision[8];		/* [277:270] */
 	__u8   dssd_firmware_build_uuid[16];		/* [293:278] */
-	__u8   dssd_firmware_build_label[64];		/* [375:294] */
-	__u8   rsvd358[136];				/* [493:358] */
+	__u8   dssd_firmware_build_label[64];		/* [357:294] */
+	__u8   die_in_use_bad_nand_block_raw[6];	/* [363:358] */
+	__le16 die_in_use_bad_nand_block_normalized;	/* [365:364] */
+	__u8   rsvd358[128];				/* [493:358] */
 	__le16 log_page_version;			/* [495:494] */
 	__u8   log_page_guid[16];			/* [511:496] */
 };
diff --git a/plugins/sandisk/sandisk-utils.c b/plugins/sandisk/sandisk-utils.c
index 2d3a766b4a..1b28f9e1da 100644
--- a/plugins/sandisk/sandisk-utils.c
+++ b/plugins/sandisk/sandisk-utils.c
@@ -48,7 +48,7 @@ int sndk_get_pci_ids(struct nvme_global_ctx *ctx, struct nvme_transport_handle *
 			nvme_ctrl_get_sysfs_dir(c));
 		nvme_free_ctrl(c);
 	} else {
-		ret = nvme_scan_namespace(name, &n);
+		ret = nvme_scan_namespace(ctx, name, &n);
 		if (!ret) {
 			fprintf(stderr, "Unable to find %s\n", name);
 			return ret;
diff --git a/plugins/solidigm/solidigm-get-drive-info.c b/plugins/solidigm/solidigm-get-drive-info.c
index f92abfb41d..9e044b987a 100644
--- a/plugins/solidigm/solidigm-get-drive-info.c
+++ b/plugins/solidigm/solidigm-get-drive-info.c
@@ -48,7 +48,8 @@ int sldgm_get_drive_info(int argc, char **argv, struct command *acmd, struct plu
 	if (!err)
 		n = nvme_ctrl_first_ns(c);
 	else {
-		err = nvme_scan_namespace(nvme_transport_handle_get_name(hdl), &n);
+		err = nvme_scan_namespace(ctx,
+			nvme_transport_handle_get_name(hdl), &n);
 		if (err) {
 			nvme_show_error("solidigm-vs-drive-info: drive missing namespace");
 			return err;
diff --git a/plugins/solidigm/solidigm-nvme.h b/plugins/solidigm/solidigm-nvme.h
index e73cf7b50c..82d12029b2 100644
--- a/plugins/solidigm/solidigm-nvme.h
+++ b/plugins/solidigm/solidigm-nvme.h
@@ -13,7 +13,7 @@
 
 #include "cmd.h"
 
-#define SOLIDIGM_PLUGIN_VERSION "1.16"
+#define SOLIDIGM_PLUGIN_VERSION "1.17"
 
 PLUGIN(NAME("solidigm", "Solidigm vendor specific extensions", SOLIDIGM_PLUGIN_VERSION),
 	COMMAND_LIST(
diff --git a/plugins/solidigm/solidigm-telemetry.c b/plugins/solidigm/solidigm-telemetry.c
index 7f189c0cbf..1925253389 100644
--- a/plugins/solidigm/solidigm-telemetry.c
+++ b/plugins/solidigm/solidigm-telemetry.c
@@ -52,6 +52,7 @@ struct config {
 	int  data_area;
 	char *cfg_file;
 	char *binary_file;
+	char *jq_filter;
 };
 
 static void cleanup_json_object(struct json_object **jobj_ptr)
@@ -68,6 +69,7 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *acmd, stru
 	const char *dgen = "Pick which telemetry data area to report. Default is 3 to fetch areas 1-3. Valid options are 1, 2, 3, 4.";
 	const char *cfile = "JSON configuration file";
 	const char *sfile = "binary file containing log dump";
+	const char *jqfilt = "JSON config entry name containing jq filter";
 	bool has_binary_file = false;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
@@ -93,6 +95,7 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *acmd, stru
 		OPT_UINT("data-area",       'd', &cfg.data_area, dgen),
 		OPT_FILE("config-file",     'j', &cfg.cfg_file, cfile),
 		OPT_FILE("source-file",     's', &cfg.binary_file, sfile),
+		OPT_STR("jq-filter",        'q', &cfg.jq_filter, jqfilt),
 		OPT_INCR("verbose",         'v', &nvme_cfg.verbose, verbose),
 		OPT_END()
 	};
@@ -144,19 +147,14 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *acmd, stru
 			nvme_show_status(err);
 			return err;
 		}
-		struct json_tokener *jstok = json_tokener_new();
-
-		configuration = json_tokener_parse_ex(jstok, conf_str, length);
-		if (jstok->err != json_tokener_success)	{
-			SOLIDIGM_LOG_WARNING("Parsing error on JSON configuration file %s: %s (at offset %d)",
-					     cfg.cfg_file,
-					     json_tokener_error_desc(jstok->err),
-					     jstok->char_offset);
-			json_tokener_free(jstok);
+		configuration = json_tokener_parse(conf_str);
+		if (!configuration) {
+			SOLIDIGM_LOG_WARNING(
+				"Failed to parse JSON configuration file %s",
+				cfg.cfg_file);
 			err = EINVAL;
 			return err;
 		}
-		json_tokener_free(jstok);
 		tl.configuration = configuration;
 	}
 
@@ -196,7 +194,56 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *acmd, stru
 	tl.log = tlog;
 	solidigm_telemetry_log_data_areas_parse(&tl, cfg.data_area);
 
-	json_print_object(tl.root, NULL);
+	/* Check if jq filter is requested and available */
+	if (cfg.jq_filter && configuration) {
+		struct json_object *jq_filter_obj = NULL;
+
+		if (json_object_object_get_ex(configuration, cfg.jq_filter,
+					      &jq_filter_obj)) {
+			const char *jq_filter_str;
+
+			jq_filter_str = json_object_get_string(jq_filter_obj);
+			if (jq_filter_str) {
+				/* Get JSON string representation */
+				const char *json_str;
+				char cmd[1024];
+				FILE *jq_pipe;
+
+				json_str = json_object_to_json_string(tl.root);
+
+				/* Create jq command and pipe JSON through it */
+				snprintf(cmd, sizeof(cmd), "jq -r '%s'",
+					 jq_filter_str);
+				jq_pipe = popen(cmd, "w");
+				if (jq_pipe) {
+					fprintf(jq_pipe, "%s", json_str);
+					err = pclose(jq_pipe);
+					if (err != 0)
+						err = -EINVAL;
+				} else {
+					SOLIDIGM_LOG_WARNING(
+						"Failed to execute jq command");
+					err = -ENOENT;
+				}
+			} else {
+				SOLIDIGM_LOG_WARNING(
+					"jq filter entry '%s' is not a valid string",
+					cfg.jq_filter);
+				err = -EINVAL;
+			}
+		} else {
+			SOLIDIGM_LOG_WARNING(
+				"jq filter entry '%s' not found in configuration file",
+				cfg.jq_filter);
+			err = -ENOENT;
+		}
+	} else {
+		/*
+		 * No jq filter requested or no config file,
+		 * use normal JSON output
+		 */
+		json_print_object(tl.root, NULL);
+	}
 	printf("\n");
 
 	return err;
diff --git a/plugins/solidigm/solidigm-telemetry/config.c b/plugins/solidigm/solidigm-telemetry/config.c
index 52894d781d..aa8afa507e 100644
--- a/plugins/solidigm/solidigm-telemetry/config.c
+++ b/plugins/solidigm/solidigm-telemetry/config.c
@@ -9,6 +9,7 @@
 #include <string.h>
 #include <stdbool.h>
 #include <json.h>
+#include <stdint.h>
 #include "config.h"
 
 // max 16 bit unsigned integer number 65535
@@ -27,11 +28,29 @@ static bool config_get_by_version(const struct json_object *obj, int version_maj
 	snprintf(str_subkey, sizeof(str_subkey), "%d", version_minor);
 	struct json_object *major_obj = NULL;
 
-	if (!json_object_object_get_ex(obj, str_key, &major_obj))
-		return false;
-	if (!json_object_object_get_ex(major_obj, str_subkey, value))
-		return false;
-	return value != NULL;
+	/* Try exact major version match first */
+	if (json_object_object_get_ex(obj, str_key, &major_obj)) {
+		/* Try exact minor version match first */
+		if (json_object_object_get_ex(major_obj, str_subkey, value))
+			return value != NULL;
+
+		/* Try wildcard minor version if exact match failed */
+		if (json_object_object_get_ex(major_obj, "*", value))
+			return value != NULL;
+	}
+
+	/* Try wildcard major version if exact major version not found */
+	if (json_object_object_get_ex(obj, "*", &major_obj)) {
+		/* Try exact minor version match */
+		if (json_object_object_get_ex(major_obj, str_subkey, value))
+			return value != NULL;
+
+		/* Try wildcard minor version */
+		if (json_object_object_get_ex(major_obj, "*", value))
+			return value != NULL;
+	}
+
+	return false;
 }
 
 bool sldm_config_get_struct_by_key_version(const struct json_object *config, char *key,
diff --git a/plugins/wdc/wdc-nvme.c b/plugins/wdc/wdc-nvme.c
index 066a64b4c4..58fdd3fb97 100644
--- a/plugins/wdc/wdc-nvme.c
+++ b/plugins/wdc/wdc-nvme.c
@@ -1490,7 +1490,7 @@ static int wdc_get_pci_ids(struct nvme_global_ctx *ctx, struct nvme_transport_ha
 			nvme_ctrl_get_sysfs_dir(c));
 		nvme_free_ctrl(c);
 	} else {
-		ret = nvme_scan_namespace(name, &n);
+		ret = nvme_scan_namespace(ctx, name, &n);
 		if (ret) {
 			fprintf(stderr, "Unable to find %s\n", name);
 			return ret;
diff --git a/pyproject.toml b/pyproject.toml
index be6896bc4c..9e92370ec5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: LGPL-2.1-or-later
 [build-system]
 build-backend = 'mesonpy'
-requires = ['meson-python']
+requires = ['meson-python', 'meson', 'ninja', 'swig']
 
 [project]
 name = "libnvme"
@@ -31,3 +31,14 @@ dependencies = []
 "Homepage" = "https://github.com/linux-nvme/nvme-cli"
 "Source" = "https://github.com/linux-nvme/nvme-cli"
 "Bug Tracker" = "https://github.com/linux-nvme/nvme-cli/issues"
+
+[tool.meson-python.args]
+setup = [
+    "-Dnvme=disabled",
+    "-Dlibnvme=enabled",
+    "-Dpython=enabled",
+    "-Dpypi=true",
+    "-Dtests=false",
+    "-Dnvme-tests=false",
+    "-Dexamples=false",
+]

From 368f262852addd9db5781f0b26510de5aa4a00b7 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Fri, 30 Jan 2026 17:01:08 -0700
Subject: [PATCH 12/83] Fix circular dependency in platform_linux.h causing
 build failures (#38)

* Merge origin/master into mingw

* Initial plan

* Fix circular dependency in platform_linux.h by removing cleanup.h include

Co-authored-by: bbusacker_micron <199673931+bbusacker_micron@users.noreply.github.com>

* use the code base standard for initializing variables

---------

Co-authored-by: Brandon Capener <bcapener@micron.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: bbusacker_micron <199673931+bbusacker_micron@users.noreply.github.com>
---
 libnvme/src/nvme/platform/platform_linux.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/libnvme/src/nvme/platform/platform_linux.h b/libnvme/src/nvme/platform/platform_linux.h
index 783e369090..70df6d4067 100644
--- a/libnvme/src/nvme/platform/platform_linux.h
+++ b/libnvme/src/nvme/platform/platform_linux.h
@@ -32,7 +32,6 @@
 #include <linux/types.h>
 #include <endian.h>
 #include <net/if.h>
-#include "cleanup.h"
 
 /* Linux cleanup attribute */
 #define __nvme_cleanup(fn) __attribute__((__cleanup__(fn)))
@@ -43,7 +42,7 @@
 /* Platform-specific UUID generation using /dev/urandom */
 static inline int random_uuid(unsigned char *uuid, size_t len)
 {
-	_cleanup_fd_ int f = -1;
+	int f, ret = 0;
 	ssize_t n;
 
 	f = open("/dev/urandom", O_RDONLY);
@@ -52,11 +51,12 @@ static inline int random_uuid(unsigned char *uuid, size_t len)
 
 	n = read(f, uuid, len);
 	if (n < 0)
-		return -errno;
+		ret = -errno;
 	else if ((size_t)n != len)
-		return -EIO;
+		ret = -EIO;
 
-	return 0;
+	close(f);
+	return ret;
 }
 
 #endif /* _LIBNVME_PLATFORM_LINUX_H */
\ No newline at end of file

From 599f9e7f625318239649bf6f0e0bf4e24be311ed Mon Sep 17 00:00:00 2001
From: Brandon Busacker <bbusacker@micron.com>
Date: Mon, 2 Feb 2026 15:17:37 -0700
Subject: [PATCH 13/83] feat: Add Windows support for nvme-cli (#29)

* docs: Add comprehensive TODO.md for Windows port status

- Document all excluded plugins with priority ratings
- Detail critical missing device I/O functionality
- List implementable stubs (global context, dry-run, host NQN)
- Clarify fabrics string converters not needed (require Linux kernel)
- Add implementation phases and effort estimates
- Minor cleanup: nvme-rpmb.c whitespace

* feat: Add Windows support for nvme-cli

Enable compilation and linking of nvme-cli on Windows using MinGW-W64.
The build succeeds and produces a functional nvme.exe with help system
and 19 vendor plugins. Device I/O operations are stubbed (see TODO.md).

Core Changes:
- Expanded Windows POSIX compatibility layer in platform/windows.h/.c
  * dirent emulation (opendir/readdir/closedir)
  * POSIX functions: getline, strsep, reallocarray, gmtime_r
  * Signal handling: sigaction, sigemptyset
  * Memory mapping stubs: mmap, munmap, madvise
  * DLL loading: dlopen/dlsym/dlclose wrappers
  * mkdir wrapper, readlink stub, open_memstream stub
  * Fabrics/RPMB command stubs (commands registered but unsupported)

- Add platform/types.h stub that defines Windows equivalents to linux/types.h.

- Extend libnvme/src/nvme/windows-stubs.c with 120+ stub functions
  * Keyring/TLS functions (nvme_read_key, nvme_insert_tls_key_*, etc.)
  * Fabrics string converters (nvmf_trtype_str, nvmf_sectype_str, etc.)
  * Tree/topology functions (nvme_scan_topology, nvme_create_root, etc.)
  * Device operations (nvme_open, nvme_close)
  * Host NQN generation (nvmf_hostnqn_generate*)
  * NBFT, global context, path properties

Build System Changes:
- Update meson.build to exclude fabrics.c and nvme-rpmb.c on Windows
- Add windows-stubs.c to Windows-specific sources
- Add Windows library dependencies (ws2_32, wsock32, kernel32, iphlpapi)
- Conditional link args (-ldl on Linux only)

- Update plugins/meson.build:
  * 19 cross-platform plugins enabled (including micron)
  * 10 Linux-only plugins excluded (huawei, ibm, netapp, sandisk,
    scaleflux, wdc, ymtc, zns, lm)

Code Modifications:
- Changed #include of linux/includes.h to platform/includes.h accross the project.
- Add min/max macro guards in common.h to prevent Windows conflicts

Known Limitations:
- All device I/O operations are stubbed (ioctl returns -ENOSYS)
- Cannot open NVMe devices or enumerate devices
- fabrics and rpmb commands print 'not supported on Windows'
- See TODO.md for detailed implementation roadmap

* Fix Windows compilation warnings

- plugins/intel/intel-nvme.c: Use uintptr_t for pointer-to-int casts for 64-bit compatibility
- plugins/micron/micron-nvme.c: Guard min macro definition to avoid redefinition warnings
- plugins/micron/micron-nvme.c: Replace %T with %H:%M:%S in strftime for Windows compatibility
- nvme-print-stdout.c: Fix array-bounds warnings with proper union-based type conversion

* Consolidate Windows platform headers

Reorganizes Windows compatibility layer for cleaner separation between
OS-level abstractions (libnvme) and application-specific code (nvme-cli).

OS-level abstractions (libnvme platform layer):
- Created libnvme/src/nvme/platform/platform_windows.h
  * Windows-specific includes (winsock2.h, windows.h, dirent.h)
  * POSIX compatibility: getline, strsep, reallocarray, readlink,
    open_memstream, fnmatch
  * Signal handling: sigaction, sigemptyset
  * Error codes: ENAVAIL, EREMOTEIO, EDQUOT, ENOTBLK, etc.
  * ioctl constants: BLKBSZSET, BLKRRPART
  * Mode_t typedef and mkdir wrapper macro

- Created libnvme/src/nvme/platform/platform_windows.c
  * POSIX function implementations for Windows compatibility
  * Added exports to libnvme.map for DLL symbol visibility

Application-level stubs (nvme-cli layer):

- Created windows-stubs.c
  * Application-specific stubs: fabrics_discovery, fabrics_connect,
    fabrics_disconnect, fabrics_config, fabrics_dim, rpmb_cmd_option

Combined platform-specific support for both nvme-cli and libnvme and restructured and renamed some of the platform-specific files.

- Moved nvme/platform/*.* into platform/*.* and removed platform_ from file names.
- Moved Windows-specific linux/types.h into platform/types.h and fixed it to support linux.  Updated references to linux/types.h to use platform/types.h.

* Fixed warnings on Windows.

* PATH_MAX is used for some buffers in micron-nvme.c where it is assumed to be larger than 1024.  On Windows it is 260.  On Linux it is typically 4096.  Using 4096.

- Fixed possible underflow error during size comparison.

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Broc Going <bgoing@micron.com>
Co-authored-by: Brandon Capener <bcapener@micron.com>
Co-authored-by: Brandon Busacker <bbusacker@micron.com>
---
 .gitignore                                    |   1 +
 TODO.md                                       | 557 ++++++++++++++++++
 common.h                                      |   5 +
 fabrics.c                                     |   2 +-
 libnvme-wrap.c                                |   2 +
 libnvme/src/libnvme.ld                        |   7 +
 libnvme/src/meson.build                       |  10 +-
 libnvme/src/nvme/cleanup.h                    |   2 +-
 libnvme/src/nvme/fabrics.c                    |   2 +-
 libnvme/src/nvme/generate-accessors.c         |   2 +-
 libnvme/src/nvme/ioctl.h                      |   2 +-
 libnvme/src/nvme/linux.c                      |   2 +-
 libnvme/src/nvme/log.c                        |   2 +-
 libnvme/src/nvme/log.h                        |   2 +-
 libnvme/src/nvme/mi-mctp-compat.h             |   2 +-
 libnvme/src/nvme/mi-mctp.c                    |   2 +-
 libnvme/src/nvme/mi.h                         |   2 +-
 libnvme/src/nvme/nbft.c                       |   2 +-
 libnvme/src/nvme/private.h                    |   2 +-
 libnvme/src/nvme/tree.c                       |   2 +-
 libnvme/src/nvme/tree.h                       |   2 +-
 libnvme/src/nvme/types.h                      |   2 +-
 libnvme/src/nvme/util.c                       |   2 +-
 libnvme/src/nvme/util.h                       |   2 +-
 libnvme/src/nvme/windows-stubs.c              | 304 +++++++++-
 .../includes.h}                               |   6 +-
 .../platform_linux.h => platform/linux.h}     |   0
 libnvme/src/platform/types.h                  |  44 ++
 libnvme/src/platform/windows.c                | 118 ++++
 .../platform_windows.h => platform/windows.h} | 233 +++++++-
 logging.c                                     |   4 +-
 meson.build                                   |  34 +-
 nvme-models.c                                 |   1 +
 nvme-print-stdout.c                           |  12 +-
 nvme.c                                        |   6 +
 nvme.h                                        |   4 +-
 plugins/dera/dera-nvme.c                      |   2 +-
 plugins/fdp/fdp.c                             |   2 +
 plugins/intel/intel-nvme.c                    |   6 +-
 plugins/lm/lm-nvme.c                          |   2 +-
 plugins/memblaze/memblaze-nvme.c              |   2 +-
 plugins/meson.build                           |  33 +-
 plugins/micron/micron-nvme.c                  |  16 +-
 plugins/nbft/nbft-plugin.c                    |   2 +
 plugins/ocp/ocp-fw-activation-history.h       |   2 +-
 plugins/ocp/ocp-nvme.c                        |   2 +-
 plugins/ocp/ocp-smart-extended-log.h          |   2 +-
 plugins/ocp/ocp-telemetry-decode.c            |   2 +-
 plugins/sandisk/sandisk-nvme.c                |   2 +-
 plugins/scaleflux/sfx-nvme.c                  |   2 +-
 plugins/seagate/seagate-nvme.c                |   2 +-
 plugins/shannon/shannon-nvme.c                |   2 +-
 .../solidigm/solidigm-garbage-collection.c    |   2 +-
 plugins/solidigm/solidigm-latency-tracking.c  |   2 +-
 plugins/solidigm/solidigm-smart.c             |   2 +-
 plugins/ssstc/ssstc-nvme.c                    |   2 +-
 plugins/toshiba/toshiba-nvme.c                |   2 +-
 plugins/wdc/wdc-nvme.c                        |   2 +-
 plugins/ymtc/ymtc-nvme.c                      |   2 +-
 util/argconfig.h                              |   2 +-
 util/mem.c                                    |   4 +
 util/sighdl.c                                 |   2 +
 util/table.c                                  |   2 +
 util/types.h                                  |   2 +-
 windows-stubs.c                               |  78 +++
 65 files changed, 1464 insertions(+), 105 deletions(-)
 create mode 100644 TODO.md
 rename libnvme/src/{nvme/platform/platform_includes.h => platform/includes.h} (86%)
 rename libnvme/src/{nvme/platform/platform_linux.h => platform/linux.h} (100%)
 create mode 100644 libnvme/src/platform/types.h
 create mode 100644 libnvme/src/platform/windows.c
 rename libnvme/src/{nvme/platform/platform_windows.h => platform/windows.h} (54%)
 create mode 100644 windows-stubs.c

diff --git a/.gitignore b/.gitignore
index 5ce3d1fbe6..b8d60e2342 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,4 @@ tests/*.pyc
 dist/
 
 .vscode/
+.github
diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000000..2a125a1886
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,557 @@
+# Windows Build TODO - Excluded Features and Plugins
+
+This document tracks features and plugins that are currently excluded from the Windows build of nvme-cli.
+
+## Status Legend
+- ❌ **Will likely never need Windows support** - Requires Linux-specific kernel/networking features
+- ⚠️ **Low priority** - Limited use case on Windows
+- ✅ **Should eventually be supported** - Would be useful on Windows with porting effort
+
+---
+
+## Core Features Excluded
+
+### ❌ NVMe over Fabrics (fabrics.c)
+**Status:** Will likely never need Windows support  
+**Reason:** Requires Linux kernel NVMe-oF implementation, networking stack, and sysfs
+
+**Commands affected:**
+- `nvme discover` - Discover NVMeoF subsystems
+- `nvme connect` - Connect to NVMeoF subsystem
+- `nvme connect-all` - Connect to all discovered subsystems
+- `nvme disconnect` - Disconnect from NVMeoF subsystem
+- `nvme disconnect-all` - Disconnect from all subsystems
+- `nvme config` - Configuration of NVMeoF subsystems
+- `nvme dim` - Discovery Information Management
+
+**Current implementation:** Stub functions that print "not supported on Windows"
+
+---
+
+### ⚠️ RPMB (nvme-rpmb.c)
+**Status:** Low priority  
+**Reason:** Replay Protection Memory Block uses Linux kernel crypto API
+
+**Commands affected:**
+- `nvme rpmb` - RPMB operations
+
+**Porting effort:** Would require Windows crypto API port  
+**Current implementation:** Stub function that prints "not supported on Windows"
+
+---
+
+## Vendor Plugins Excluded
+
+### ✅ Huawei (plugins/huawei/huawei-nvme.c)
+**Status:** Should eventually be supported  
+**Reason:** Uses `scandir()`, `mkdir()` with mode parameter
+
+**Porting requirements:**
+- Replace `scandir()` with Windows equivalent (FindFirstFile/FindNextFile)
+- Handle `mkdir()` mode parameter (already have wrapper in win-compat.h)
+
+**Use case:** Useful for Huawei NVMe device users on Windows
+
+---
+
+### ✅ IBM (plugins/ibm/ibm-nvme.c)
+**Status:** Should eventually be supported  
+**Reason:** Uses `localtime_r()`, `mkdir()` with mode parameter
+
+**Porting requirements:**
+- Replace `localtime_r()` with `localtime_s()` (Windows equivalent)
+- Handle `mkdir()` mode parameter
+
+**Use case:** Useful for IBM NVMe device users on Windows
+
+---
+
+### ✅ NetApp (plugins/netapp/netapp-nvme.c)
+**Status:** Should eventually be supported  
+**Reason:** Uses `mkdir()` with mode parameter
+
+**Porting requirements:**
+- Handle `mkdir()` mode parameter (already have wrapper)
+- Verify no other Linux dependencies
+
+**Use case:** Useful for NetApp NVMe device users on Windows
+
+---
+
+### ✅ SanDisk (plugins/sandisk/)
+**Status:** Should eventually be supported  
+**Reason:** Uses `scandir()`, `mkdir()` with mode parameter
+
+**Files:**
+- `sandisk-nvme.c`
+- `sandisk-utils.c`
+
+**Porting requirements:**
+- Replace `scandir()` with Windows directory enumeration
+- Handle `mkdir()` mode parameter
+
+**Use case:** Popular consumer NVMe devices, high value for Windows users
+
+---
+
+### ⚠️ ScaleFlux (plugins/scaleflux/sfx-nvme.c)
+**Status:** Low priority  
+**Reason:** Uses `linux/fs.h` for filesystem ioctls
+
+**Porting requirements:**
+- Replace Linux filesystem ioctls with Windows equivalents
+- May require significant rework
+
+**Use case:** Enterprise storage, less common on Windows workstations
+
+---
+
+### ✅ WDC/Western Digital (plugins/wdc/)
+**Status:** Should eventually be supported  
+**Reason:** Uses `scandir()`, `mkdir()` with mode parameter, `linux/fs.h`
+
+**Files:**
+- `wdc-nvme.c`
+- `wdc-utils.c`
+
+**Porting requirements:**
+- Replace `scandir()` with Windows directory enumeration
+- Handle Linux filesystem ioctls (BLKGETSIZE, etc.)
+- Replace `mkdir()` mode handling
+
+**Use case:** Popular consumer and enterprise NVMe devices, **high priority** for Windows
+
+---
+
+### ⚠️ YMTC (plugins/ymtc/ymtc-nvme.c)
+**Status:** Low priority  
+**Reason:** Uses `mkdir()` with mode parameter
+
+**Porting requirements:**
+- Handle `mkdir()` mode parameter (already have wrapper)
+
+**Use case:** Chinese market primarily, lower Windows user base
+
+---
+
+### ✅ ZNS - Zoned Namespaces (plugins/zns/zns.c)
+**Status:** Should eventually be supported  
+**Reason:** Uses `linux/fs.h` for block device operations
+
+**Porting requirements:**
+- Replace Linux block device ioctls with Windows equivalents
+- May require Windows NVMe driver support for ZNS
+
+**Use case:** Zoned storage is emerging technology, useful for development/testing on Windows
+
+---
+
+### ❌ LM - Lossless Logger (plugins/lm/)
+**Status:** Will likely never need Windows support  
+**Reason:** Subdirectory plugin with heavy Linux dependencies
+
+**Porting requirements:**
+- Unknown - would need investigation
+- Likely uses sysfs, Linux-specific logging
+
+**Use case:** Appears to be Linux kernel/driver development focused
+
+---
+
+## Currently Enabled Plugins (19 total)
+
+These plugins work on Windows:
+- ✅ amzn - Amazon vendor specific
+- ✅ dapustor - DapuStor vendor specific
+- ✅ dell - Dell vendor specific
+- ✅ dera - Dera vendor specific
+- ✅ fdp - Flexible Data Placement
+- ✅ innogrit - Innogrit vendor specific
+- ✅ inspur - Inspur vendor specific
+- ✅ intel - Intel vendor specific
+- ✅ mangoboost - MangoBoost vendor specific
+- ✅ memblaze - Memblaze vendor specific
+- ✅ **micron - Micron vendor specific** (enabled with mkdir wrapper)
+- ✅ nbft - ACPI NBFT table extensions
+- ✅ nvidia - NVIDIA vendor specific
+- ✅ ocp - OCP cloud SSD extensions
+- ✅ feat - NVMe feature extensions  
+- ✅ seagate - Seagate vendor specific
+- ✅ shannon - Shannon vendor specific
+- ✅ ssstc - SSSTC vendor specific
+- ✅ toshiba - Toshiba vendor specific
+- ✅ transcend - Transcend vendor specific
+- ✅ virtium - Virtium vendor specific
+
+---
+
+## Porting Priority Recommendations
+
+### High Priority (Popular consumer devices)
+1. **WDC/Western Digital** - Very common consumer NVMe SSDs
+2. **SanDisk** - Popular consumer NVMe SSDs (owned by WD)
+3. **ZNS** - Emerging standard, useful for development
+
+### Medium Priority
+4. **IBM** - Enterprise users
+5. **Huawei** - Large vendor
+6. **NetApp** - Enterprise storage
+
+### Low Priority
+7. **YMTC** - Regional market focus
+8. **ScaleFlux** - Niche enterprise
+9. **LM** - Development/debug tool
+
+### Not Recommended
+- **NVMe-oF (fabrics)** - Requires Linux kernel support
+- **RPMB** - Requires crypto API port, limited use case
+
+---
+
+## Implementation Notes
+
+### Completed Compatibility Additions
+- ✅ `win-compat.h/c` - Windows compatibility layer
+- ✅ `mkdir(path, mode)` macro - Redirects to `_mkdir(path)`
+- ✅ `getline()`, `strsep()`, `reallocarray()` implementations
+- ✅ `gmtime_r()` wrapper using `gmtime_s()`
+- ✅ `dirent.h` emulation (opendir, readdir, closedir)
+- ✅ mmap/munmap stubs
+- ✅ Signal handling compatibility (sigaction, sigemptyset)
+
+### Still Needed for Full Plugin Support
+- ⚠️ `scandir()` implementation for Windows
+- ⚠️ `localtime_r()` wrapper using `localtime_s()`
+- ⚠️ Linux filesystem ioctl replacements (BLKGETSIZE, etc.)
+- ⚠️ Block device size detection on Windows
+
+---
+
+## How to Enable a Plugin
+
+1. Check the plugin source for Linux-specific dependencies:
+   ```bash
+   grep -E "scandir|localtime_r|linux/fs.h|sys/sysinfo.h" plugins/<vendor>/*.c
+   ```
+
+2. Add necessary compatibility wrappers to `win-compat.h`
+
+3. Move plugin from Linux-only section to cross-platform section in `plugins/meson.build`
+
+4. Build and test:
+   ```bash
+   meson compile -C .build
+   ```
+
+---
+
+## Testing on Windows
+
+Currently, testing is limited without physical NVMe devices. The Windows build:
+- ✅ Compiles successfully
+- ✅ Shows help and lists commands
+- ⚠️ Cannot test actual device operations without Windows NVMe devices
+- ⚠️ Device access requires Windows NVMe driver and proper permissions
+
+---
+
+Last updated: January 23, 2026
+
+---
+
+## Potentially Implementable Stub Functions
+
+This section lists stub functions in `libnvme/src/nvme/windows-stubs.c` that could be implemented with reasonable effort **if device I/O is implemented**. These are separate from the Critical Missing Functionality below, which blocks all device operations.
+
+### ✅ Easy - Simple Data Structures (30 minutes effort)
+
+**`nvme_create_global_ctx()`** - Global context allocation
+- Current: Returns NULL
+- Needed: Allocate `nvme_global_ctx` structure, initialize log level, return pointer
+- Use case: Required by many commands for configuration/logging
+- Implementation: ~50 lines, mostly struct initialization
+- Dependencies: None
+
+**`nvme_set_dry_run()`** - Dry run mode flag
+- Current: No-op stub
+- Needed: Set flag in global context: `ctx->dry_run = enable;`
+- Use case: Testing commands without actual hardware changes
+- Implementation: 1 line
+- Dependencies: Requires `nvme_create_global_ctx()` first
+
+**`nvme_set_etdas()` / `nvme_clear_etdas()`** - Telemetry flags
+- Current: Return -ENOTSUP
+- Needed: Set/clear flags in global context
+- Use case: Telemetry data collection control
+- Implementation: 2-3 lines each
+- Dependencies: Requires `nvme_create_global_ctx()` first
+
+### ⚠️ Medium - Requires Windows APIs (4-8 hours effort)
+
+**`nvmf_hostnqn_generate()`** - Host NQN generation
+- Current: Returns NULL
+- Needed: Generate UUID-based host NQN using Windows `UuidCreate()` API
+- Use case: Host identification for some NVMe commands (may be needed even without fabrics)
+- Implementation: ~30 lines
+  ```c
+  // Use Windows RPC API
+  UUID uuid;
+  UuidCreate(&uuid);
+  UuidToStringA(&uuid, &uuid_str);
+  asprintf(&hostnqn, "nqn.2014-08.org.nvmexpress:uuid:%s", uuid_str);
+  RpcStringFreeA(&uuid_str);
+  return hostnqn;
+  ```
+- Dependencies: Link against `rpcrt4.lib`
+- Note: Linux version tries DMI/device-tree first, Windows can just use random UUID
+
+**`nvmf_hostnqn_generate_from_hostid()`** - Format host NQN from UUID
+- Current: Returns NULL
+- Needed: Format provided UUID into NQN string
+- Use case: Creates standardized host identifier
+- Implementation: ~10 lines (just string formatting)
+- Dependencies: None (pure string manipulation)
+
+### ❌ NOT Implementable - Require Linux Kernel Features
+
+**Fabrics Operations** - All require Linux NVMe-oF kernel driver:
+- `nvmf_add_ctrl()`, `nvmf_get_discovery_log()`, `nvmf_connect_*()`, etc.
+- These will NEVER work on Windows without kernel NVMe-oF support
+
+**Fabrics String Converters** - Pointless without fabrics:
+- `nvmf_trtype_str()`, `nvmf_adrfam_str()`, `nvmf_sectype_str()`, etc.
+- These only format fabrics discovery/connection information
+- No fabrics = no use for these functions
+
+**Tree/Topology Functions** - Require Linux sysfs:
+- `nvme_scan_topology()`, `nvme_create_root()`, `nvme_free_tree()`
+- Windows has no sysfs equivalent
+- Path properties (NUMA, queue depth) also depend on sysfs
+
+**Keyring/TLS Functions** - Require Linux keyctl:
+- `nvme_read_key()`, `nvme_lookup_keyring()`, `nvme_insert_tls_key_*()`, etc.
+- Windows Credential Manager is completely different architecture
+
+**NBFT Functions** - Fabrics boot table (fabrics-specific):
+- `nvmf_nbft_read_files()`, `nvmf_nbft_free()`
+- Only used for NVMe-oF boot, not applicable to Windows
+
+### Summary
+
+**Worth implementing (if device I/O works):**
+- ✅ `nvme_create_global_ctx()` - Essential for most commands
+- ✅ `nvme_set_dry_run()` - Testing support
+- ✅ `nvme_set_etdas()` / `nvme_clear_etdas()` - Telemetry control
+- ⚠️ `nvmf_hostnqn_generate*()` - May be needed for host identification (2 functions)
+
+**Total effort:** ~8-10 hours for all of the above
+
+**Not worth implementing:**
+- ❌ 9 fabrics string converters - Useless without fabrics support
+- ❌ 40+ fabrics operations - Require Linux kernel
+- ❌ 30+ tree/topology functions - Require sysfs
+- ❌ 20+ keyring/TLS functions - Require Linux keyctl
+- ❌ NBFT functions - Fabrics boot only
+
+**Critical Note:** These stubs are low priority. The entire list above is meaningless until the Critical Missing Functionality (device I/O layer) is implemented. Focus should be on Windows IOCTL implementation first.
+
+---
+
+## Critical Missing Functionality for Windows
+
+The current Windows build successfully compiles and shows help output, but **cannot actually communicate with NVMe devices**. All device I/O operations are stubbed. The following core functionality must be implemented for a minimally functional tool:
+
+### 🔴 CRITICAL: Device I/O Layer (libnvme)
+
+**Status:** Currently all stubbed - zero device functionality  
+**Location:** `libnvme/src/nvme/ioctl.c` and Windows platform layer  
+**Priority:** **HIGHEST - MUST IMPLEMENT**
+
+#### What's Missing:
+
+1. **Windows NVMe IOCTL Implementation**
+   - Current: `ioctl()` function in `platform/windows.h` returns `ENOSYS`
+   - Needed: Implement Windows storage device IOCTLs using:
+     - `IOCTL_STORAGE_QUERY_PROPERTY`
+     - `IOCTL_STORAGE_PROTOCOL_COMMAND` (Windows 10+)
+     - `DeviceIoControl()` Win32 API
+   - Reference: Windows NVMe driver documentation
+   - Impact: **ALL nvme commands fail without this**
+
+2. **Device Path Translation**
+   - Current: Code expects Linux paths like `/dev/nvme0`, `/dev/nvme0n1`
+   - Needed: Windows device paths:
+     - Physical drives: `\\.\PhysicalDrive0`, `\\.\PhysicalDrive1`
+     - SCSI devices: `\\.\SCSI#Disk&Ven_...`
+     - NVMe devices: May need Windows NVMe miniport interfaces
+   - Must implement path translation in device open routines
+   - Impact: **Cannot open any devices**
+
+3. **Device Enumeration (`nvme list`)**
+   - Current: `nvme_scan_topology()` stubbed to return error
+   - Needed: Windows device enumeration using:
+     - `SetupAPI` (`SetupDiGetClassDevs`, `SetupDiEnumDeviceInterfaces`)
+     - `CFGMGR32` (Configuration Manager API)
+     - Query for NVMe device class GUID
+     - Enumerate physical drives and identify NVMe devices
+   - Location: `libnvme/src/nvme/tree.c` (excluded from Windows build)
+   - Impact: **`nvme list` command completely non-functional**
+
+4. **Global Context (`nvme_create_global_ctx()`)**
+   - Current: Stubbed to return NULL in `windows-stubs.c`
+   - Needed: Minimal implementation for Windows
+     - Log level management
+     - Device handle tracking
+     - Configuration state
+   - Impact: **Most commands fail to initialize**
+
+5. **Device Handle Management**
+   - Current: `nvme_open()`, `nvme_close()` stubbed
+   - Needed: 
+     - Use `CreateFile()` with proper flags for NVMe device access
+     - Handle exclusive access (`O_EXCL` → `FILE_SHARE_*` flags)
+     - Manage file descriptors vs Windows `HANDLE`
+   - Impact: **Cannot open/close devices**
+
+6. **Admin and I/O Command Passthrough**
+   - Current: All passthrough stubbed
+   - Needed: Windows IOCTL wrappers for:
+     - `nvme_submit_admin_passthru()` 
+     - `nvme_submit_io_passthru()`
+     - Convert Linux NVMe commands to Windows NVMe protocol commands
+   - Reference: `STORAGE_PROTOCOL_COMMAND` structure
+   - Impact: **All NVMe commands (identify, get-log, etc.) fail**
+
+#### Implementation Approach:
+
+**Phase 1 - Basic Device Access (Minimal Functionality):**
+1. Implement `nvme_open()` using `CreateFile()` for physical drives
+2. Implement basic `ioctl()` wrapper for `IOCTL_STORAGE_PROTOCOL_COMMAND`
+3. Implement admin passthrough for Identify Controller command
+4. Test: `nvme id-ctrl \\.\PhysicalDrive0` should work
+
+**Phase 2 - Device Enumeration:**
+5. Implement basic `nvme_scan_topology()` using SetupAPI
+6. Enumerate NVMe devices and populate device list
+7. Test: `nvme list` should show NVMe devices
+
+**Phase 3 - Full Command Support:**
+8. Implement remaining admin commands (get-log, get-feature, etc.)
+9. Implement I/O passthrough for data transfer commands
+10. Test vendor-specific commands with supported devices
+
+#### Files Requiring Implementation:
+
+- `libnvme/src/platform/windows.h` - Replace `ioctl()` stub
+- `libnvme/src/nvme/windows-stubs.c` - Implement device functions
+- New file: `libnvme/src/nvme/windows-ioctl.c` (recommended)
+- New file: `libnvme/src/nvme/windows-enum.c` (recommended)
+
+#### Testing Requirements:
+
+- **Administrator privileges required** - Windows restricts direct device access
+- Need physical NVMe device on Windows test machine
+- Cannot test in VM without NVMe passthrough
+- Consider using Windows Driver Kit (WDK) samples as reference
+
+---
+
+### 🟡 IMPORTANT: Block Device Operations
+
+**Status:** Partially stubbed  
+**Priority:** **HIGH**
+
+Several commands need block device size and properties:
+- `nvme format` - needs device size
+- `nvme write`, `nvme read` - need block size
+- Various log pages reference block counts
+
+**Missing APIs:**
+- Block device size detection (IOCTL_DISK_GET_LENGTH_INFO)
+- Sector size queries (IOCTL_STORAGE_QUERY_PROPERTY)
+- `fstat()` for device files - Windows equivalent needed
+- `S_ISCHR()`, `S_ISBLK()` macros - need Windows device type checking
+
+**Current Workarounds:**
+- Some operations may work without size info (admin commands)
+- I/O commands will need proper implementation
+
+---
+
+### 🟡 IMPORTANT: Permissions and Security
+
+**Status:** Not addressed  
+**Priority:** **HIGH**
+
+**Requirements:**
+1. **Administrator/Elevated Privileges**
+   - Direct device access requires admin rights on Windows
+   - Should detect and warn if not elevated
+   - Add manifest to request elevation?
+
+2. **Device Access Rights**
+   - Windows restricts `FILE_SHARE_*` flags
+   - Exclusive access may conflict with system drivers
+   - May need to coordinate with Windows NVMe driver
+
+3. **Error Handling**
+   - Windows error codes differ from errno
+   - `GetLastError()` → translate to errno equivalents
+   - Proper error messages for permission denied scenarios
+
+**Implementation:**
+- Add `IsUserAnAdmin()` check on startup
+- Display warning if not elevated
+- Consider UAC elevation prompt
+
+---
+
+### 🟢 NICE TO HAVE: Additional Improvements
+
+**Priority:** **LOW**
+
+1. **Native Windows Paths**
+   - Accept both Linux-style and Windows-style paths
+   - `/dev/nvme0` → `\\.\PhysicalDrive0` auto-translation
+   - Device aliases/friendly names
+
+2. **Windows-Specific Documentation**
+   - Update man pages for Windows
+   - Document device path format
+   - Document privilege requirements
+   - Installation instructions for Windows
+
+3. **Windows Installer**
+   - MSI or MSIX package
+   - Include libnvme DLL
+   - Add to PATH automatically
+   - Desktop shortcuts
+
+4. **Error Message Improvements**
+   - Windows-specific error messages
+   - Link to troubleshooting docs
+   - Better privilege requirement messages
+
+---
+
+## Summary of Required Work
+
+| Component | Priority | Effort | Blocker |
+|-----------|----------|--------|---------|
+| Device IOCTL implementation | 🔴 Critical | High | **YES** |
+| Device path translation | 🔴 Critical | Medium | **YES** |
+| Device enumeration | 🔴 Critical | High | **YES** |
+| Admin command passthrough | 🔴 Critical | High | **YES** |
+| Block device operations | 🟡 Important | Medium | Partial |
+| Permission handling | 🟡 Important | Low | No |
+| Documentation | 🟢 Nice to have | Medium | No |
+
+**Bottom Line:** The Windows build is currently a "shell" that compiles but has **zero runtime device functionality**. All the critical I/O operations are stubbed. Implementing Windows NVMe device access is a **significant porting effort** requiring:
+- Windows Driver Kit knowledge
+- Understanding of Windows storage stack
+- Testing hardware with NVMe devices
+- ~2-4 weeks for experienced Windows driver developer
+
+---
+
+Last updated: January 23, 2026
diff --git a/common.h b/common.h
index 9e3a367bc3..d24893e9a5 100644
--- a/common.h
+++ b/common.h
@@ -9,8 +9,13 @@
 
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
 
+/* On Windows, min/max may be provided by libnvme but ensure they exist */
+#ifndef min
 #define min(x, y) ((x) > (y) ? (y) : (x))
+#endif
+#ifndef max
 #define max(x, y) ((x) > (y) ? (x) : (y))
+#endif
 
 #ifdef __packed
 #else /* __packed */
diff --git a/fabrics.c b/fabrics.c
index 9a1f0a0e98..4930862fa5 100644
--- a/fabrics.c
+++ b/fabrics.c
@@ -36,7 +36,7 @@
 #include <time.h>
 
 #include <sys/types.h>
-#include <linux/types.h>
+#include <platform/types.h>
 
 #include <libnvme.h>
 
diff --git a/libnvme-wrap.c b/libnvme-wrap.c
index 70ce5cb443..b8918f26e6 100644
--- a/libnvme-wrap.c
+++ b/libnvme-wrap.c
@@ -5,7 +5,9 @@
  * Copyright (c) 2022 Daniel Wagner, SUSE
  */
 
+#ifndef _WIN32
 #include <dlfcn.h>
+#endif
 #include <errno.h>
 #include <stdlib.h>
 
diff --git a/libnvme/src/libnvme.ld b/libnvme/src/libnvme.ld
index ce97672ee0..cd405faf97 100644
--- a/libnvme/src/libnvme.ld
+++ b/libnvme/src/libnvme.ld
@@ -1,5 +1,12 @@
 # SPDX-License-Identifier: LGPL-2.1-or-later
 LIBNVME_UNRELEASED {
+	global:
+		# Windows POSIX compatibility functions
+		getline;
+		reallocarray;
+		readlink;
+		open_memstream;
+		strsep;
 };
 
 LIBNVME_2_0 {
diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index fe8eb9af87..d98502c1fe 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -19,6 +19,7 @@ if is_windows
     # Windows-specific sources (exclude Linux networking, fabrics, and filesystem code)
     sources += [
         'nvme/windows-stubs.c',  # Stubs for excluded functions
+        'platform/windows.c',  # POSIX compatibility implementations
     ]
 else
     # Linux-specific sources (include networking and fabrics support)
@@ -148,10 +149,11 @@ install_headers(
 
 # Install platform abstraction headers
 install_headers([
-        'nvme/platform/platform_includes.h',
-        'nvme/platform/platform_linux.h',
-        'nvme/platform/platform_windows.h',
+        'platform/includes.h',
+        'platform/linux.h',
+        'platform/windows.h',
+        'platform/types.h'
     ],
-    subdir: 'nvme/platform',
+    subdir: 'platform',
     install_mode: mode,
 )
diff --git a/libnvme/src/nvme/cleanup.h b/libnvme/src/nvme/cleanup.h
index 0d3e6ab6f6..e17657938e 100644
--- a/libnvme/src/nvme/cleanup.h
+++ b/libnvme/src/nvme/cleanup.h
@@ -6,7 +6,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
 
 #include "fabrics.h"
 
diff --git a/libnvme/src/nvme/fabrics.c b/libnvme/src/nvme/fabrics.c
index 4e47a0d54f..06336dbc1f 100644
--- a/libnvme/src/nvme/fabrics.c
+++ b/libnvme/src/nvme/fabrics.c
@@ -21,7 +21,7 @@
 #include <dirent.h>
 #include <inttypes.h>
 
-#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
 
 #include <ccan/endian/endian.h>
 #include <ccan/list/list.h>
diff --git a/libnvme/src/nvme/generate-accessors.c b/libnvme/src/nvme/generate-accessors.c
index d3ef1485ef..80afacc0cf 100644
--- a/libnvme/src/nvme/generate-accessors.c
+++ b/libnvme/src/nvme/generate-accessors.c
@@ -1718,7 +1718,7 @@ int main(int argc, char *argv[])
 		"#include <string.h>\n"
 		"#include <stdbool.h>\n"
 		"#include <stdint.h>\n"
-		"#include <linux/types.h> /* __u32, __u64, etc. */\n"
+		"#include <platform/types.h> /* __u32, __u64, etc. */\n"
 		"\n", banner, guard, guard);
 
 	fprintf(generated_hdr, "/* Forward declarations. These are internal (opaque) structs. */\n");
diff --git a/libnvme/src/nvme/ioctl.h b/libnvme/src/nvme/ioctl.h
index d47e58c2e2..52f41f6cbf 100644
--- a/libnvme/src/nvme/ioctl.h
+++ b/libnvme/src/nvme/ioctl.h
@@ -11,7 +11,7 @@
 #define _LIBNVME_IOCTL_H
 
 #include <string.h>
-#include "platform/platform_includes.h"  /* Platform abstraction - includes endian.h and ioctl.h */
+#include "platform/includes.h"  /* Platform abstraction - includes endian.h and ioctl.h */
 #include <errno.h>
 #include <stddef.h>
 #include <string.h>
diff --git a/libnvme/src/nvme/linux.c b/libnvme/src/nvme/linux.c
index 175e7e3460..86596a269f 100644
--- a/libnvme/src/nvme/linux.c
+++ b/libnvme/src/nvme/linux.c
@@ -12,7 +12,7 @@
 #include <string.h>
 #include <errno.h>
 
-#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
 
 #ifdef CONFIG_OPENSSL
 #include <openssl/evp.h>
diff --git a/libnvme/src/nvme/log.c b/libnvme/src/nvme/log.c
index 1e5e880809..5004dd420c 100644
--- a/libnvme/src/nvme/log.c
+++ b/libnvme/src/nvme/log.c
@@ -12,7 +12,7 @@
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdbool.h>
-#include "platform/platform_includes.h"  /* Platform abstraction - includes syslog */
+#include "platform/includes.h"  /* Platform abstraction - includes syslog */
 #include <time.h>
 #define LOG_FUNCNAME 1
 #include "private.h"
diff --git a/libnvme/src/nvme/log.h b/libnvme/src/nvme/log.h
index dfe9624830..36f4e66203 100644
--- a/libnvme/src/nvme/log.h
+++ b/libnvme/src/nvme/log.h
@@ -6,7 +6,7 @@
 #define _LOG_H
 
 #include <stdbool.h>
-#include "platform/platform_includes.h"  /* Platform abstraction - includes syslog */
+#include "platform/includes.h"  /* Platform abstraction - includes syslog */
 
 /* for nvme_root_t */
 #include <nvme/tree.h>
diff --git a/libnvme/src/nvme/mi-mctp-compat.h b/libnvme/src/nvme/mi-mctp-compat.h
index b6427dda01..b60807fe7a 100644
--- a/libnvme/src/nvme/mi-mctp-compat.h
+++ b/libnvme/src/nvme/mi-mctp-compat.h
@@ -3,7 +3,7 @@
 #ifndef _MI_MCTP_COMPAT_H
 #define _MI_MCTP_COMPAT_H
 
-#include <linux/types.h>
+#include <platform/types.h>
 
 /* As of kernel v5.15, these AF_MCTP-related definitions are provided by
  * linux/mctp.h. However, we provide a set here while that header percolates
diff --git a/libnvme/src/nvme/mi-mctp.c b/libnvme/src/nvme/mi-mctp.c
index c3c51cef5b..227072867c 100644
--- a/libnvme/src/nvme/mi-mctp.c
+++ b/libnvme/src/nvme/mi-mctp.c
@@ -10,7 +10,7 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
 #include <fcntl.h>
 
 #if HAVE_LINUX_MCTP_H
diff --git a/libnvme/src/nvme/mi.h b/libnvme/src/nvme/mi.h
index 919ef3fb64..447a7c3d56 100644
--- a/libnvme/src/nvme/mi.h
+++ b/libnvme/src/nvme/mi.h
@@ -84,7 +84,7 @@
 #ifndef _LIBNVME_MI_MI_H
 #define _LIBNVME_MI_MI_H
 
-#include "platform/platform_includes.h"  /* Platform abstraction */
+#include "platform/includes.h"  /* Platform abstraction */
 #include <stdint.h>
 
 #include <nvme/types.h>
diff --git a/libnvme/src/nvme/nbft.c b/libnvme/src/nvme/nbft.c
index 13cb0f50f4..05390b6134 100644
--- a/libnvme/src/nvme/nbft.c
+++ b/libnvme/src/nvme/nbft.c
@@ -10,7 +10,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
 #include <ccan/endian/endian.h>
 
 #include "private.h"
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index c7b2558235..4337d83af0 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -10,7 +10,7 @@
 #define _LIBNVME_PRIVATE_H
 
 #include <ccan/list/list.h>
-#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
 
 #include <nvme/fabrics.h>
 #include <nvme/mi.h>
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index 9303a44036..30c67eaa7b 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -15,7 +15,7 @@
 #include <fcntl.h>
 #include <libgen.h>
 
-#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
 
 #include <ccan/endian/endian.h>
 #include <ccan/list/list.h>
diff --git a/libnvme/src/nvme/tree.h b/libnvme/src/nvme/tree.h
index a102ca2df0..94197872b8 100644
--- a/libnvme/src/nvme/tree.h
+++ b/libnvme/src/nvme/tree.h
@@ -13,7 +13,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-#include "platform/platform_includes.h"  /* Platform abstraction */
+#include "platform/includes.h"  /* Platform abstraction */
 
 #include <nvme/ioctl.h>
 #include <nvme/util.h>
diff --git a/libnvme/src/nvme/types.h b/libnvme/src/nvme/types.h
index 11bc07f796..d689e069d9 100644
--- a/libnvme/src/nvme/types.h
+++ b/libnvme/src/nvme/types.h
@@ -14,7 +14,7 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include "platform/platform_includes.h"  /* Platform abstraction - includes type definitions */
+#include "platform/includes.h"  /* Platform abstraction - includes type definitions */
 
 struct nvme_global_ctx;
 struct nvme_transport_handle;
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 255d123836..6b3bf57e44 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -16,7 +16,7 @@
 
 #include <sys/stat.h>
 #include <fcntl.h>
-#include "platform/platform_includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
 
 #include <ccan/minmax/minmax.h>
 #include <ccan/endian/endian.h>
diff --git a/libnvme/src/nvme/util.h b/libnvme/src/nvme/util.h
index 93a48c17d1..8d08816a4a 100644
--- a/libnvme/src/nvme/util.h
+++ b/libnvme/src/nvme/util.h
@@ -9,7 +9,7 @@
 #ifndef _LIBNVME_UTIL_H
 #define _LIBNVME_UTIL_H
 
-#include "platform/platform_includes.h"  /* Platform abstraction */
+#include "platform/includes.h"  /* Platform abstraction */
 
 #include <nvme/types.h>
 
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index c1b217c7ca..3426f823ab 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -674,10 +674,11 @@ int nvme_dump_tree(struct nvme_global_ctx *ctx)
 	return -1;
 }
 
-int nvme_dump_config(struct nvme_global_ctx *ctx)
+int nvme_dump_config(struct nvme_global_ctx *ctx, const char *config_file)
 {
 	stub_log(__func__);
 	(void)ctx;
+	(void)config_file;
 	errno = ENOTSUP;
 	return -1;
 }
@@ -1008,4 +1009,305 @@ const char *nvme_mi_status_to_string(int status)
 	stub_log(__func__);
 	(void)status;
 	return "MI not supported on Windows";
+}
+
+/*
+ * Linux keyring and TLS key management stubs (linux.c)
+ * These are used by nvme-cli security commands
+ */
+int nvme_read_key(long keyring_id, long key_id, int *key_len, unsigned char **key_data)
+{
+	stub_log(__func__);
+	(void)keyring_id;
+	(void)key_id;
+	(void)key_len;
+	(void)key_data;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_lookup_keyring(const char *keyring, long *kr_id)
+{
+	stub_log(__func__);
+	(void)keyring;
+	(void)kr_id;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_update_key(long keyring_id, long key_id, const unsigned char *key_data, int key_len)
+{
+	stub_log(__func__);
+	(void)keyring_id;
+	(void)key_id;
+	(void)key_data;
+	(void)key_len;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_revoke_tls_key(const char *keyring, const char *key_type, const char *identity)
+{
+	stub_log(__func__);
+	(void)keyring;
+	(void)key_type;
+	(void)identity;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_scan_tls_keys(const char *keyring)
+{
+	stub_log(__func__);
+	(void)keyring;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_describe_key_serial(long key_id)
+{
+	stub_log(__func__);
+	(void)key_id;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_insert_tls_key_versioned(const char *keyring, const char *key_type, const char *hostnqn,
+				 const char *subsysnqn, int version, int hmac,
+				 unsigned char *configured_key, int key_len)
+{
+	stub_log(__func__);
+	(void)keyring;
+	(void)key_type;
+	(void)hostnqn;
+	(void)subsysnqn;
+	(void)version;
+	(void)hmac;
+	(void)configured_key;
+	(void)key_len;
+	errno = ENOTSUP;
+	return -1;
+}
+
+char *nvme_generate_tls_key_identity_compat(const char *hostnqn, const char *subsysnqn,
+					   int version, int hmac,
+					   unsigned char *configured_key, int key_len)
+{
+	stub_log(__func__);
+	(void)hostnqn;
+	(void)subsysnqn;
+	(void)version;
+	(void)hmac;
+	(void)configured_key;
+	(void)key_len;
+	return NULL;
+}
+
+int nvme_insert_tls_key_compat(const char *keyring, const char *key_type, const char *identity,
+			       unsigned char *key_data, int key_len)
+{
+	stub_log(__func__);
+	(void)keyring;
+	(void)key_type;
+	(void)identity;
+	(void)key_data;
+	(void)key_len;
+	errno = ENOTSUP;
+	return -1;
+}
+
+char *nvme_generate_tls_key_identity(const char *hostnqn, const char *subsysnqn,
+				    int version, int hmac,
+				    unsigned char *configured_key, int key_len)
+{
+	stub_log(__func__);
+	(void)hostnqn;
+	(void)subsysnqn;
+	(void)version;
+	(void)hmac;
+	(void)configured_key;
+	(void)key_len;
+	return NULL;
+}
+
+char *nvmf_hostnqn_from_file(void)
+{
+	stub_log(__func__);
+	/* No /etc/nvme/hostnqn equivalent on Windows */
+	return NULL;
+}
+
+int nvme_gen_dhchap_key(char *hostnqn, unsigned int hmac, unsigned int key_len,
+		       unsigned char *secret, unsigned char *key)
+{
+	stub_log(__func__);
+	(void)hostnqn;
+	(void)hmac;
+	(void)key_len;
+	(void)secret;
+	(void)key;
+	errno = ENOTSUP;
+	return -1;
+}
+
+/* Hostnqn generation (fabrics.c) */
+char *nvmf_hostnqn_generate(void)
+{
+	stub_log(__func__);
+	/* Could implement UUID-based generation, but for now just fail */
+	return NULL;
+}
+
+char *nvmf_hostnqn_generate_from_hostid(char *hostid)
+{
+	stub_log(__func__);
+	(void)hostid;
+	return NULL;
+}
+
+/* Dry run and other global state functions (linux.c) */
+void nvme_set_dry_run(void *ctx, int enable)
+{
+	stub_log(__func__);
+	(void)ctx;
+	(void)enable;
+}
+
+/* Extended Telemetry (linux.c) */
+int nvme_set_etdas(void *hdl, int *changed)
+{
+	stub_log(__func__);
+	(void)hdl;
+	(void)changed;
+	errno = ENOTSUP;
+	return -1;
+}
+
+int nvme_clear_etdas(void *hdl, int *changed)
+{
+	stub_log(__func__);
+	(void)hdl;
+	(void)changed;
+	errno = ENOTSUP;
+	return -1;
+}
+
+/* Transport handle callbacks (linux.c) */
+void nvme_transport_handle_set_submit_entry(void *hdl, void *fn)
+{
+	stub_log(__func__);
+	(void)hdl;
+	(void)fn;
+}
+
+void nvme_transport_handle_set_submit_exit(void *hdl, void *fn)
+{
+	stub_log(__func__);
+	(void)hdl;
+	(void)fn;
+}
+
+void nvme_transport_handle_set_decide_retry(void *hdl, void *fn)
+{
+	stub_log(__func__);
+	(void)hdl;
+	(void)fn;
+}
+
+/* Path property getters (tree.c) */
+const char *nvme_path_get_numa_nodes(struct nvme_path *p)
+{
+	stub_log(__func__);
+	(void)p;
+	return "";
+}
+
+int nvme_path_get_queue_depth(struct nvme_path *p)
+{
+	stub_log(__func__);
+	(void)p;
+	return 0;
+}
+
+/* Fabrics string conversion functions (fabrics.c) */
+const char *nvmf_trtype_str(__u8 trtype)
+{
+	stub_log(__func__);
+	(void)trtype;
+	return "unknown";
+}
+
+const char *nvmf_eflags_str(__u16 eflags)
+{
+	stub_log(__func__);
+	(void)eflags;
+	return "unknown";
+}
+
+const char *nvmf_sectype_str(__u8 sectype)
+{
+	stub_log(__func__);
+	(void)sectype;
+	return "unknown";
+}
+
+const char *nvmf_cms_str(__u8 cms)
+{
+	stub_log(__func__);
+	(void)cms;
+	return "unknown";
+}
+
+const char *nvmf_qptype_str(__u8 qptype)
+{
+	stub_log(__func__);
+	(void)qptype;
+	return "unknown";
+}
+
+const char *nvmf_prtype_str(__u8 prtype)
+{
+	stub_log(__func__);
+	(void)prtype;
+	return "unknown";
+}
+
+const char *nvmf_adrfam_str(__u8 adrfam)
+{
+	stub_log(__func__);
+	(void)adrfam;
+	return "unknown";
+}
+
+const char *nvmf_subtype_str(__u8 subtype)
+{
+	stub_log(__func__);
+	(void)subtype;
+	return "unknown";
+}
+
+const char *nvmf_treq_str(__u8 treq)
+{
+	stub_log(__func__);
+	(void)treq;
+	return "unknown";
+}
+
+/* NBFT functions (nbft.c) */
+int nvmf_nbft_read_files(struct nvme_global_ctx *ctx, char *path,
+			  struct nbft_file_entry **nbft_list)
+{
+	stub_log(__func__);
+	(void)ctx;
+	(void)path;
+	(void)nbft_list;
+	errno = ENOTSUP;
+	return -1;
+}
+
+void nvmf_nbft_free(struct nvme_global_ctx *ctx, struct nbft_file_entry *head)
+{
+	stub_log(__func__);
+	(void)ctx;
+	(void)head;
 }
\ No newline at end of file
diff --git a/libnvme/src/nvme/platform/platform_includes.h b/libnvme/src/platform/includes.h
similarity index 86%
rename from libnvme/src/nvme/platform/platform_includes.h
rename to libnvme/src/platform/includes.h
index dbf1ac3288..22a97c14d1 100644
--- a/libnvme/src/nvme/platform/platform_includes.h
+++ b/libnvme/src/platform/includes.h
@@ -20,11 +20,13 @@
 #include <stdint.h>
 #include <stdbool.h>
 
+#include "platform/types.h"
+
 /* Platform-specific includes */
 #ifdef _WIN32
-    #include "platform_windows.h"
+    #include "platform/windows.h"
 #else
-    #include "platform_linux.h"
+    #include "platform/linux.h"
 #endif
 
 #endif /* _LIBNVME_PLATFORM_INCLUDES_H */
\ No newline at end of file
diff --git a/libnvme/src/nvme/platform/platform_linux.h b/libnvme/src/platform/linux.h
similarity index 100%
rename from libnvme/src/nvme/platform/platform_linux.h
rename to libnvme/src/platform/linux.h
diff --git a/libnvme/src/platform/types.h b/libnvme/src/platform/types.h
new file mode 100644
index 0000000000..3cd9842994
--- /dev/null
+++ b/libnvme/src/platform/types.h
@@ -0,0 +1,44 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Platform compatibility for linux/types.h
+ */
+#ifndef _PLATFORM_TYPES_H
+#define _PLATFORM_TYPES_H
+
+#ifdef _WIN32
+
+#include <stdint.h>
+
+/* Windows type definitions to replace linux/types.h */
+typedef uint8_t  __u8;
+typedef uint16_t __u16;
+typedef uint32_t __u32;
+typedef uint64_t __u64;
+typedef int8_t   __s8;
+typedef int16_t  __s16;
+typedef int32_t  __s32;
+typedef int64_t  __s64;
+
+/* Little-endian types (Windows is little-endian) */
+typedef __u16    __le16;
+typedef __u32    __le32;
+typedef __u64    __le64;
+typedef __s16    __le16s;
+typedef __s32    __le32s;
+typedef __s64    __le64s;
+
+/* Big-endian types for completeness */
+typedef __u16    __be16;
+typedef __u32    __be32;
+typedef __u64    __be64;
+typedef __s16    __be16s;
+typedef __s32    __be32s;
+typedef __s64    __be64s;
+
+#else
+
+#include <linux/types.h>
+
+#endif
+
+#endif /* _PLATFORM_TYPES_H */
diff --git a/libnvme/src/platform/windows.c b/libnvme/src/platform/windows.c
new file mode 100644
index 0000000000..65533df248
--- /dev/null
+++ b/libnvme/src/platform/windows.c
@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2025 Micron Technology, Inc.
+ *
+ * Windows platform-specific function implementations.
+ * Provides POSIX-compatible functions for Windows.
+ */
+
+#ifdef _WIN32
+
+#include "platform/includes.h"
+
+/* getline implementation for Windows */
+ssize_t getline(char **lineptr, size_t *n, FILE *stream) {
+	char *bufptr = NULL;
+	char *p = bufptr;
+	size_t size;
+	int c;
+
+	if (lineptr == NULL || stream == NULL || n == NULL) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	bufptr = *lineptr;
+	size = *n;
+
+	c = fgetc(stream);
+	if (c == EOF) {
+		return -1;
+	}
+
+	if (bufptr == NULL) {
+		bufptr = malloc(128);
+		if (bufptr == NULL) {
+			errno = ENOMEM;
+			return -1;
+		}
+		size = 128;
+	}
+
+	p = bufptr;
+	while (c != EOF) {
+		if ((size_t)(p - bufptr) + 1 >= size) {
+			size_t pos = (size_t)(p - bufptr);
+			size = size + 128;
+			bufptr = realloc(bufptr, size);
+			if (bufptr == NULL) {
+				errno = ENOMEM;
+				return -1;
+			}
+			p = bufptr + pos;
+		}
+		*p++ = c;
+		if (c == '\n') {
+			break;
+		}
+		c = fgetc(stream);
+	}
+
+	*p = '\0';
+	*lineptr = bufptr;
+	*n = size;
+
+	return p - bufptr;
+}
+
+/* strsep implementation for Windows */
+char *strsep(char **stringp, const char *delim) {
+	char *start = *stringp;
+	char *p;
+
+	if (start == NULL)
+		return NULL;
+
+	p = strpbrk(start, delim);
+	if (p) {
+		*p = '\0';
+		*stringp = p + 1;
+	} else {
+		*stringp = NULL;
+	}
+
+	return start;
+}
+
+/* reallocarray implementation for Windows */
+void *reallocarray(void *ptr, size_t nmemb, size_t size)
+{
+	size_t total_size;
+	
+	/* Check for multiplication overflow */
+	if (nmemb != 0 && size > SIZE_MAX / nmemb) {
+		errno = ENOMEM;
+		return NULL;
+	}
+	
+	total_size = nmemb * size;
+	return realloc(ptr, total_size);
+}
+
+/* readlink stub - Windows doesn't have symbolic links in the same way */
+int readlink(const char *path, char *buf, size_t bufsiz) {
+	(void)path; (void)buf; (void)bufsiz;
+	errno = EINVAL;
+	return -1;
+}
+
+/* open_memstream stub - returns a temporary file instead */
+FILE *open_memstream(char **ptr, size_t *sizeloc) {
+	FILE *f = tmpfile();
+	if (ptr) *ptr = NULL;
+	if (sizeloc) *sizeloc = 0;
+	return f;
+}
+
+#endif /* _WIN32 */
diff --git a/libnvme/src/nvme/platform/platform_windows.h b/libnvme/src/platform/windows.h
similarity index 54%
rename from libnvme/src/nvme/platform/platform_windows.h
rename to libnvme/src/platform/windows.h
index 002cc19a54..00db818496 100644
--- a/libnvme/src/nvme/platform/platform_windows.h
+++ b/libnvme/src/platform/windows.h
@@ -37,32 +37,6 @@
 #undef max
 #endif
 
-/* Windows type definitions to replace linux/types.h */
-typedef uint8_t  __u8;
-typedef uint16_t __u16;
-typedef uint32_t __u32;
-typedef uint64_t __u64;
-typedef int8_t   __s8;
-typedef int16_t  __s16;
-typedef int32_t  __s32;
-typedef int64_t  __s64;
-
-/* Little-endian types (Windows is little-endian) */
-typedef __u16    __le16;
-typedef __u32    __le32;
-typedef __u64    __le64;
-typedef __s16    __le16s;
-typedef __s32    __le32s;
-typedef __s64    __le64s;
-
-/* Big-endian types for completeness */
-typedef __u16    __be16;
-typedef __u32    __be32;
-typedef __u64    __be64;
-typedef __s16    __be16s;
-typedef __s32    __be32s;
-typedef __s64    __be64s;
-
 /* Windows cleanup - no-op since Windows doesn't have cleanup attribute */
 #define __nvme_cleanup(fn) /* No cleanup attribute on Windows */
 
@@ -117,6 +91,14 @@ static inline void closelog(void) { }
 /* sys/ioctl.h stubs */
 #define IOCTL_STORAGE_QUERY_PROPERTY CTL_CODE(IOCTL_STORAGE_BASE, 0x0500, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
+/* Linux ioctl constants - stubs for block device operations */
+#ifndef BLKBSZSET
+#define BLKBSZSET 0x40081271
+#endif
+#ifndef BLKRRPART
+#define BLKRRPART 0x125F
+#endif
+
 /* Windows ioctl stub functions */
 static inline int ioctl(int fd, unsigned long request, ...) {
     (void)fd; (void)request;
@@ -153,10 +135,19 @@ static inline int ioctl(int fd, unsigned long request, ...) {
 #ifndef ENOTBLK
 #define ENOTBLK 15
 #endif
+#ifndef ENAVAIL
+#define ENAVAIL 119
+#endif
 
 /* Windows missing socket types */
 typedef unsigned long nfds_t;
 
+/* Windows missing mode_t */
+#ifndef _MODE_T_
+#define _MODE_T_
+typedef unsigned int mode_t;
+#endif
+
 /* Windows missing socket structures */
 struct msghdr {
     void *msg_name;
@@ -268,4 +259,194 @@ static inline int random_uuid(unsigned char *uuid, size_t len)
 	return 0;
 }
 
+/* ========== POSIX Compatibility Layer ========== */
+
+/* dirent.h emulation for Windows - only if not provided by compiler */
+#if !defined(_DIRENT_H_) && !defined(_DIRENT_H)
+#include <dirent.h>
+#endif
+
+/* If dirent.h is not available, we would define our own, but MinGW provides it */
+
+/* stdio.h POSIX extensions */
+ssize_t getline(char **lineptr, size_t *n, FILE *stream);
+FILE *open_memstream(char **ptr, size_t *sizeloc);
+
+/* string.h POSIX extensions */
+char *strsep(char **stringp, const char *delim);
+void *reallocarray(void *ptr, size_t nmemb, size_t size);
+
+/* unistd.h POSIX functions */
+int readlink(const char *path, char *buf, size_t bufsiz);
+
+/* unistd.h additions */
+#ifndef fsync
+#define fsync _commit
+#endif
+int readlink(const char *path, char *buf, size_t bufsiz);
+
+/* time.h POSIX compatibility */
+static inline struct tm *gmtime_r(const time_t *timep, struct tm *result) {
+	if (gmtime_s(result, timep) == 0)
+		return result;
+	return NULL;
+}
+
+/* signal.h POSIX compatibility - Windows doesn't have sigaction */
+#ifndef _SIGACTION_DEFINED
+#define _SIGACTION_DEFINED
+#include <signal.h>
+
+struct sigaction {
+	void (*sa_handler)(int);
+	int sa_flags;
+	int sa_mask;  /* simplified - normally sigset_t */
+};
+
+#define SA_RESTART 0x10000000
+
+static inline int sigemptyset(int *set) {
+	*set = 0;
+	return 0;
+}
+
+static inline int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact) {
+	(void)oldact; /* ignore old action for simplicity */
+	if (act && act->sa_handler) {
+		signal(signum, act->sa_handler);
+		return 0;
+	}
+	return -1;
+}
+
+#endif /* _SIGACTION_DEFINED */
+
+/* fnmatch.h POSIX compatibility */
+#define FNM_NOMATCH 1
+#define FNM_PATHNAME 0x01
+
+/* Basic fnmatch implementation for Windows:
+ * - Supports '*' (match any sequence, including empty) and
+ *   '?' (match any single character).
+ * - Ignores flags for now; they are accepted for compatibility.
+ * Returns 0 on match, FNM_NOMATCH on mismatch.
+ */
+static inline int fnmatch(const char *pattern, const char *string, int flags)
+{
+	(void)flags; /* flags currently unused */
+
+	while (*pattern) {
+		if (*pattern == '*') {
+			/* Skip consecutive '*' characters */
+			while (*pattern == '*')
+				pattern++;
+
+			if (!*pattern)
+				/* Trailing '*' matches the rest of the string */
+				return 0;
+
+			/* Try to match the remainder of the pattern at each suffix of string */
+			while (*string) {
+				if (!fnmatch(pattern, string, flags))
+					return 0;
+				string++;
+			}
+			/* No match found for pattern suffix after '*' */
+			return FNM_NOMATCH;
+		} else if (*pattern == '?') {
+			/* '?' matches any single character, if present */
+			if (!*string)
+				return FNM_NOMATCH;
+			pattern++;
+			string++;
+		} else {
+			/* Literal character match */
+			if (*pattern != *string)
+				return FNM_NOMATCH;
+			pattern++;
+			string++;
+		}
+	}
+
+	/* At end of pattern: match only if we're also at end of string */
+	return *string ? FNM_NOMATCH : 0;
+}
+
+/* limits.h additions */
+#ifndef NAME_MAX
+#define NAME_MAX 260
+#endif
+
+/* sys/stat.h compatibility */
+#ifndef S_ISBLK
+#define S_ISBLK(m) (0)
+#endif
+
+/* mkdir compatibility - Windows _mkdir doesn't take mode parameter */
+#ifndef mkdir
+#define mkdir(path, mode) _mkdir(path)
+#endif
+
+/* Memory mapping stubs - not fully supported on Windows */
+#define PROT_READ  0x1
+#define PROT_WRITE 0x2
+#define MAP_SHARED 0x01
+#define MAP_PRIVATE 0x02
+#define MAP_ANONYMOUS 0x20
+#define MAP_HUGETLB 0x40000
+#define MAP_FAILED ((void *) -1)
+#define MADV_HUGEPAGE 14
+
+static inline void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset) {
+	(void)addr; (void)length; (void)prot; (void)flags; (void)fd; (void)offset;
+	errno = ENOSYS;
+	return MAP_FAILED;
+}
+
+static inline int munmap(void *addr, size_t length) {
+	(void)addr; (void)length;
+	errno = ENOSYS;
+	return -1;
+}
+
+static inline int madvise(void *addr, size_t length, int advice) {
+	(void)addr; (void)length; (void)advice;
+	errno = ENOSYS;
+	return -1;
+}
+
+/* DLL loading compatibility */
+#define RTLD_LAZY 0
+static inline void *dlopen(const char *filename, int flag) {
+	(void)flag;
+	return (void *)LoadLibraryA(filename);
+}
+
+static inline void *dlsym(void *handle, const char *symbol) {
+	return (void *)GetProcAddress((HMODULE)handle, symbol);
+}
+
+static inline int dlclose(void *handle) {
+	return FreeLibrary((HMODULE)handle) ? 0 : -1;
+}
+
+static inline char *dlerror(void) {
+	static char buf[256];
+	DWORD err = GetLastError();
+	snprintf(buf, sizeof(buf), "Error %lu", err);
+	return buf;
+}
+
+/* Socket compatibility */
+#ifndef MSG_NOSIGNAL
+#define MSG_NOSIGNAL 0
+#endif
+
+/* sendfile stub */
+static inline ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count) {
+	(void)out_fd; (void)in_fd; (void)offset; (void)count;
+	errno = ENOSYS;
+	return -1;
+}
+
 #endif /* _LIBNVME_PLATFORM_WINDOWS_H */
\ No newline at end of file
diff --git a/logging.c b/logging.c
index dcb8e7638b..4d1c8e65f6 100644
--- a/logging.c
+++ b/logging.c
@@ -5,10 +5,12 @@
 #include <stdint.h>
 #include <string.h>
 #include <errno.h>
+#ifndef _WIN32
 #include <sys/ioctl.h>
 #include <sys/syslog.h>
 #include <sys/time.h>
-#include <linux/types.h>
+#include <platform/types.h>
+#endif
 
 #include <libnvme.h>
 #include <libnvme-mi.h>
diff --git a/meson.build b/meson.build
index e5aaab2f34..2209d16b40 100644
--- a/meson.build
+++ b/meson.build
@@ -511,17 +511,24 @@ if want_nvme
     subdir('util')      # declares: util_sources
 
     sources = [
-        'fabrics.c',
         'nvme.c',
         'nvme-models.c',
         'nvme-print.c',
         'nvme-print-stdout.c',
         'nvme-print-binary.c',
-        'nvme-rpmb.c',
         'plugin.c',
         'libnvme-wrap.c',
         'logging.c',
     ]
+    # fabrics.c and nvme-rpmb.c use Linux-specific libnvme functionality
+    if not is_windows
+        sources += ['fabrics.c', 'nvme-rpmb.c']
+    endif
+    if is_windows
+        sources += [
+            'windows-stubs.c',
+        ]
+    endif
     if json_c_dep.found()
         sources += [
             'nvme-print-json.c',
@@ -530,16 +537,25 @@ if want_nvme
     sources += plugin_sources
     sources += util_sources
 
+    link_args_list = []
+    link_deps = [
+        config_dep,
+        ccan_dep,
+        libnvme_dep,
+        json_c_dep,
+    ]
+    
+    if not is_windows
+        link_args_list = ['-ldl']
+    else
+        link_deps += [ws2_32_dep, wsock32_dep, kernel32_dep, iphlpapi_dep]
+    endif
+
     executable(
         'nvme',
         sources,
-        dependencies: [
-            config_dep,
-            ccan_dep,
-            libnvme_dep,
-            json_c_dep,
-        ],
-        link_args: '-ldl',
+        dependencies: link_deps,
+        link_args: link_args_list,
         install: true,
         install_dir: sbindir,
     )
diff --git a/nvme-models.c b/nvme-models.c
index f638e4d03d..523dfa51a9 100644
--- a/nvme-models.c
+++ b/nvme-models.c
@@ -9,6 +9,7 @@
 #include <unistd.h>
 #include <errno.h>
 #include "nvme-models.h"
+#include "platform/includes.h"
 
 static char *_fmt1 = "/sys/class/nvme/nvme%d/device/subsystem_vendor";
 static char *_fmt2 = "/sys/class/nvme/nvme%d/device/subsystem_device";
diff --git a/nvme-print-stdout.c b/nvme-print-stdout.c
index 09ee8fecee..52d1519082 100644
--- a/nvme-print-stdout.c
+++ b/nvme-print-stdout.c
@@ -7,8 +7,10 @@
 #include <time.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#ifndef _WIN32
 #include <sys/socket.h>
 #include <arpa/inet.h>
+#endif
 #include <ccan/strset/strset.h>
 #include <ccan/htable/htable_type.h>
 #include <ccan/htable/htable.h>
@@ -1555,9 +1557,15 @@ static void stdout_registers_pmrmscu(uint32_t pmrmscu)
 static void stdout_ctrl_register_human(int offset, uint64_t value, bool support)
 {
 	switch (offset) {
-	case NVME_REG_CAP:
-		stdout_registers_cap((struct nvme_bar_cap *)&value);
+	case NVME_REG_CAP: {
+		union {
+			uint64_t raw;
+			struct nvme_bar_cap cap;
+		} u = {};
+		u.raw = value;
+		stdout_registers_cap(&u.cap);
 		break;
+	}
 	case NVME_REG_VS:
 		stdout_registers_version(value);
 		break;
diff --git a/nvme.c b/nvme.c
index 4331db36a1..881c8d5cff 100644
--- a/nvme.c
+++ b/nvme.c
@@ -38,13 +38,19 @@
 #include <string.h>
 #include <unistd.h>
 #include <math.h>
+#ifndef _WIN32
 #include <dirent.h>
+#endif
 #include <libgen.h>
 #include <signal.h>
 
+#ifndef _WIN32
 #include <linux/fs.h>
+#endif
 
+#ifndef _WIN32
 #include <sys/mman.h>
+#endif
 #include <sys/types.h>
 #include <sys/stat.h>
 
diff --git a/nvme.h b/nvme.h
index 054976d1bf..2121616402 100644
--- a/nvme.h
+++ b/nvme.h
@@ -16,12 +16,14 @@
 #ifndef _NVME_H
 #define _NVME_H
 
-#include <dirent.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
+#ifndef _WIN32
+#include <dirent.h>
 #include <endian.h>
 #include <sys/time.h>
+#endif
 #include <sys/stat.h>
 
 #include <libnvme-mi.h>
diff --git a/plugins/dera/dera-nvme.c b/plugins/dera/dera-nvme.c
index 7a0d54ea8a..0ffe0e4cb5 100644
--- a/plugins/dera/dera-nvme.c
+++ b/plugins/dera/dera-nvme.c
@@ -13,7 +13,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 
 #define CREATE_CMD
diff --git a/plugins/fdp/fdp.c b/plugins/fdp/fdp.c
index 445a68ccce..61f86880e0 100644
--- a/plugins/fdp/fdp.c
+++ b/plugins/fdp/fdp.c
@@ -6,7 +6,9 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <inttypes.h>
+#ifndef _WIN32
 #include <linux/fs.h>
+#endif
 #include <sys/stat.h>
 
 #include "common.h"
diff --git a/plugins/intel/intel-nvme.c b/plugins/intel/intel-nvme.c
index 545f44a615..b3ee75973f 100644
--- a/plugins/intel/intel-nvme.c
+++ b/plugins/intel/intel-nvme.c
@@ -10,7 +10,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 
 #define CREATE_CMD
@@ -1271,7 +1271,7 @@ static int read_header(struct nvme_passthru_cmd *cmd, __u8 *buf,
 	cmd->cdw10 = 0x400;
 	cmd->cdw12 = dw12;
 	cmd->data_len = 0x1000;
-	cmd->addr = (unsigned long)(void *)buf;
+	cmd->addr = (uintptr_t)(void *)buf;
 	return read_entire_cmd(cmd, 0x400, 0x400, -1, hdl, buf);
 }
 
@@ -1416,7 +1416,7 @@ static int get_internal_log(int argc, char **argv, struct command *acmd,
 	/* for 1.1 Fultondales will use old nlog, but current assert/event */
 	if ((intel->ver.major < 1 && intel->ver.minor < 1) ||
 	    (intel->ver.major <= 1 && intel->ver.minor <= 1 && cfg.log == 0)) {
-		cmd.addr = (unsigned long)(void *)buf;
+		cmd.addr = (uintptr_t)(void *)buf;
 		err = get_internal_log_old(buf, output, hdl, &cmd);
 		goto out;
 	}
diff --git a/plugins/lm/lm-nvme.c b/plugins/lm/lm-nvme.c
index 6f65f6b3d8..a8041e15dc 100644
--- a/plugins/lm/lm-nvme.c
+++ b/plugins/lm/lm-nvme.c
@@ -28,7 +28,7 @@
 #include "nvme-print.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "util/cleanup.h"
 
 #define CREATE_CMD
diff --git a/plugins/memblaze/memblaze-nvme.c b/plugins/memblaze/memblaze-nvme.c
index 57c6d5bd1d..58e9dc3dbe 100644
--- a/plugins/memblaze/memblaze-nvme.c
+++ b/plugins/memblaze/memblaze-nvme.c
@@ -11,7 +11,7 @@
 #include "common.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 
 #define CREATE_CMD
diff --git a/plugins/meson.build b/plugins/meson.build
index 8def5651f6..269a54f5ee 100644
--- a/plugins/meson.build
+++ b/plugins/meson.build
@@ -1,13 +1,12 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 
+# Plugins that work on all platforms
 plugin_sources = [
     'plugins/amzn/amzn-nvme.c',
     'plugins/dapustor/dapustor-nvme.c',
     'plugins/dell/dell-nvme.c',
     'plugins/dera/dera-nvme.c',
     'plugins/fdp/fdp.c',
-    'plugins/huawei/huawei-nvme.c',
-    'plugins/ibm/ibm-nvme.c',
     'plugins/innogrit/innogrit-nvme.c',
     'plugins/inspur/inspur-nvme.c',
     'plugins/intel/intel-nvme.c',
@@ -15,25 +14,37 @@ plugin_sources = [
     'plugins/memblaze/memblaze-nvme.c',
     'plugins/micron/micron-nvme.c',
     'plugins/nbft/nbft-plugin.c',
-    'plugins/netapp/netapp-nvme.c',
     'plugins/nvidia/nvidia-nvme.c',
-    'plugins/sandisk/sandisk-nvme.c',
-    'plugins/sandisk/sandisk-utils.c',
-    'plugins/scaleflux/sfx-nvme.c',
     'plugins/seagate/seagate-nvme.c',
     'plugins/shannon/shannon-nvme.c',
     'plugins/ssstc/ssstc-nvme.c',
     'plugins/toshiba/toshiba-nvme.c',
     'plugins/transcend/transcend-nvme.c',
     'plugins/virtium/virtium-nvme.c',
-    'plugins/wdc/wdc-nvme.c',
-    'plugins/wdc/wdc-utils.c',
-    'plugins/ymtc/ymtc-nvme.c',
-    'plugins/zns/zns.c',
 ]
 
+# Plugins with Linux-specific dependencies - exclude on Windows
+if not is_windows
+    plugin_sources += [
+        'plugins/huawei/huawei-nvme.c',
+        'plugins/ibm/ibm-nvme.c',
+        'plugins/netapp/netapp-nvme.c',
+        'plugins/sandisk/sandisk-nvme.c',
+        'plugins/sandisk/sandisk-utils.c',
+        'plugins/scaleflux/sfx-nvme.c',
+        'plugins/wdc/wdc-nvme.c',
+        'plugins/wdc/wdc-utils.c',
+        'plugins/ymtc/ymtc-nvme.c',
+        'plugins/zns/zns.c',
+    ]
+endif
+
 subdir('feat')
-subdir('lm')
+
+if not is_windows
+    subdir('lm')
+endif
+
 subdir('ocp')
 
 if conf.get('HAVE_SED_OPAL') != 0
diff --git a/plugins/micron/micron-nvme.c b/plugins/micron/micron-nvme.c
index 08d1e98257..40a8cee84d 100644
--- a/plugins/micron/micron-nvme.c
+++ b/plugins/micron/micron-nvme.c
@@ -26,7 +26,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include <limits.h>
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 #include "util/cleanup.h"
 #include "util/utils.h"
@@ -57,7 +57,9 @@
 #define C6_log_size 512
 #define C5_MicronWorkLoad_log_size 256
 
+#ifndef min
 #define min(x, y) ((x) > (y) ? (y) : (x))
+#endif
 #define SensorCount 8
 
 /* Plugin version major_number.minor_number.patch */
@@ -232,7 +234,7 @@ static enum eDriveModel GetDriveModel(int idx)
 static int ZipAndRemoveDir(char *strDirName, char *strFileName)
 {
 	int  err = 0;
-	char strBuffer[PATH_MAX];
+	char strBuffer[4096];
 	int  nRet;
 	bool is_tgz = false;
 	struct stat sb;
@@ -251,14 +253,14 @@ static int ZipAndRemoveDir(char *strDirName, char *strFileName)
 	/* check if log file is created, if not print error message */
 	if (nRet < 0 || (stat(strFileName, &sb) == -1)) {
 		if (is_tgz)
-			sprintf(strBuffer, "check if tar and gzip commands are installed");
+			snprintf(strBuffer, sizeof(strBuffer), "check if tar and gzip commands are installed");
 		else
-			sprintf(strBuffer, "check if zip command is installed");
+			snprintf(strBuffer, sizeof(strBuffer), "check if zip command is installed");
 
 		fprintf(stderr, "Failed to create log data package, %s!\n", strBuffer);
 	}
 
-	sprintf(strBuffer, "rm -f -R \"%s\" >temp.txt 2>&1", strDirName);
+	snprintf(strBuffer, sizeof(strBuffer), "rm -f -R \"%s\" >temp.txt 2>&1", strDirName);
 	nRet = system(strBuffer);
 	if (nRet < 0)
 		printf("Failed to remove temporary files!\n");
@@ -2166,7 +2168,7 @@ static void GetTimestampInfo(const char *strOSDirName)
 		return;
 
 	num = strftime((char *)outstr, sizeof(outstr),
-				   "Timestamp (UTC): %a, %d %b %Y %T %z", tmp);
+				   "Timestamp (UTC): %a, %d %b %Y %H:%M:%S %z", tmp);
 	num += sprintf((char *)(outstr + num), "\nPackage Version: 1.4");
 	if (num) {
 		strPDir = strdup(strOSDirName);
@@ -2273,7 +2275,7 @@ static void GetOSConfig(const char *strOSDirName)
 {
 	FILE *fpOSConfig = NULL;
 	char strBuffer[1024];
-	char strFileName[PATH_MAX];
+	char strFileName[4096];
 	int i;
 
 	struct {
diff --git a/plugins/nbft/nbft-plugin.c b/plugins/nbft/nbft-plugin.c
index 4f21689e91..8a1739d2f9 100644
--- a/plugins/nbft/nbft-plugin.c
+++ b/plugins/nbft/nbft-plugin.c
@@ -2,7 +2,9 @@
 
 #include <errno.h>
 #include <stdio.h>
+#ifndef _WIN32
 #include <fnmatch.h>
+#endif
 
 #include <libnvme.h>
 #include "nvme-print.h"
diff --git a/plugins/ocp/ocp-fw-activation-history.h b/plugins/ocp/ocp-fw-activation-history.h
index 89a86f65da..7e0185fa38 100644
--- a/plugins/ocp/ocp-fw-activation-history.h
+++ b/plugins/ocp/ocp-fw-activation-history.h
@@ -6,7 +6,7 @@
  */
 #include <libnvme.h>
 #include "common.h"
-#include "linux/types.h"
+#include "platform/types.h"
 
 #ifndef OCP_FIRMWARE_ACTIVATION_HISTORY_H
 #define OCP_FIRMWARE_ACTIVATION_HISTORY_H
diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index d7efc2cdb0..a49d59c357 100644
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -20,7 +20,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "util/types.h"
 #include "logging.h"
 #include "nvme-print.h"
diff --git a/plugins/ocp/ocp-smart-extended-log.h b/plugins/ocp/ocp-smart-extended-log.h
index bbb2cefc1e..63738b43bd 100644
--- a/plugins/ocp/ocp-smart-extended-log.h
+++ b/plugins/ocp/ocp-smart-extended-log.h
@@ -7,7 +7,7 @@
  */
 
 #include "common.h"
-#include "linux/types.h"
+#include "platform/types.h"
 
 #ifndef OCP_SMART_EXTENDED_LOG_H
 #define OCP_SMART_EXTENDED_LOG_H
diff --git a/plugins/ocp/ocp-telemetry-decode.c b/plugins/ocp/ocp-telemetry-decode.c
index f51e23fbe3..d497d2c9e5 100644
--- a/plugins/ocp/ocp-telemetry-decode.c
+++ b/plugins/ocp/ocp-telemetry-decode.c
@@ -8,7 +8,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "util/types.h"
 #include "nvme-print.h"
 
diff --git a/plugins/sandisk/sandisk-nvme.c b/plugins/sandisk/sandisk-nvme.c
index 1bb73d0abb..82d62fe079 100644
--- a/plugins/sandisk/sandisk-nvme.c
+++ b/plugins/sandisk/sandisk-nvme.c
@@ -18,7 +18,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "util/cleanup.h"
 #include "util/types.h"
 #include "nvme-print.h"
diff --git a/plugins/scaleflux/sfx-nvme.c b/plugins/scaleflux/sfx-nvme.c
index 23783a5c60..7e87fb578d 100644
--- a/plugins/scaleflux/sfx-nvme.c
+++ b/plugins/scaleflux/sfx-nvme.c
@@ -18,7 +18,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 #include "util/cleanup.h"
 #include "util/types.h"
diff --git a/plugins/seagate/seagate-nvme.c b/plugins/seagate/seagate-nvme.c
index 44956c5d09..91dca9cb8c 100644
--- a/plugins/seagate/seagate-nvme.c
+++ b/plugins/seagate/seagate-nvme.c
@@ -36,7 +36,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 #include <time.h>
 
diff --git a/plugins/shannon/shannon-nvme.c b/plugins/shannon/shannon-nvme.c
index 3c43602778..cd20800b71 100644
--- a/plugins/shannon/shannon-nvme.c
+++ b/plugins/shannon/shannon-nvme.c
@@ -10,7 +10,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 
 #define CREATE_CMD
diff --git a/plugins/solidigm/solidigm-garbage-collection.c b/plugins/solidigm/solidigm-garbage-collection.c
index 3146823175..cfb46db4b6 100644
--- a/plugins/solidigm/solidigm-garbage-collection.c
+++ b/plugins/solidigm/solidigm-garbage-collection.c
@@ -16,7 +16,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 #include "solidigm-garbage-collection.h"
 #include "solidigm-util.h"
diff --git a/plugins/solidigm/solidigm-latency-tracking.c b/plugins/solidigm/solidigm-latency-tracking.c
index f6142ea9e1..31a78cbcc0 100644
--- a/plugins/solidigm/solidigm-latency-tracking.c
+++ b/plugins/solidigm/solidigm-latency-tracking.c
@@ -15,7 +15,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 #include "solidigm-util.h"
 
diff --git a/plugins/solidigm/solidigm-smart.c b/plugins/solidigm/solidigm-smart.c
index 4b327d9a6e..f1e4dd9d2f 100644
--- a/plugins/solidigm/solidigm-smart.c
+++ b/plugins/solidigm/solidigm-smart.c
@@ -15,7 +15,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 
 #include "solidigm-smart.h"
diff --git a/plugins/ssstc/ssstc-nvme.c b/plugins/ssstc/ssstc-nvme.c
index 90571f7b1f..76c55c3570 100644
--- a/plugins/ssstc/ssstc-nvme.c
+++ b/plugins/ssstc/ssstc-nvme.c
@@ -10,7 +10,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 
 #define CREATE_CMD
diff --git a/plugins/toshiba/toshiba-nvme.c b/plugins/toshiba/toshiba-nvme.c
index d4b783bbb8..7d07584c6b 100644
--- a/plugins/toshiba/toshiba-nvme.c
+++ b/plugins/toshiba/toshiba-nvme.c
@@ -11,7 +11,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 
 #define CREATE_CMD
diff --git a/plugins/wdc/wdc-nvme.c b/plugins/wdc/wdc-nvme.c
index 58fdd3fb97..e7b9ce2db3 100644
--- a/plugins/wdc/wdc-nvme.c
+++ b/plugins/wdc/wdc-nvme.c
@@ -35,7 +35,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "util/cleanup.h"
 #include "util/types.h"
 #include "nvme-print.h"
diff --git a/plugins/ymtc/ymtc-nvme.c b/plugins/ymtc/ymtc-nvme.c
index 945b2315bf..69d57cf2de 100644
--- a/plugins/ymtc/ymtc-nvme.c
+++ b/plugins/ymtc/ymtc-nvme.c
@@ -8,7 +8,7 @@
 #include "nvme.h"
 #include "libnvme.h"
 #include "plugin.h"
-#include "linux/types.h"
+#include "platform/types.h"
 #include "nvme-print.h"
 
 #define CREATE_CMD
diff --git a/util/argconfig.h b/util/argconfig.h
index 44d2e4e6ab..afe183e5f4 100644
--- a/util/argconfig.h
+++ b/util/argconfig.h
@@ -41,7 +41,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-#include <linux/types.h>
+#include <platform/types.h>
 
 enum argconfig_types {
 	CFG_FLAG,
diff --git a/util/mem.c b/util/mem.c
index d2be46e870..de9294aa63 100644
--- a/util/mem.c
+++ b/util/mem.c
@@ -3,7 +3,11 @@
 #include <unistd.h>
 #include <malloc.h>
 #include <string.h>
+#ifndef _WIN32
 #include <sys/mman.h>
+#endif
+
+#include "platform/includes.h"
 
 #include "mem.h"
 
diff --git a/util/sighdl.c b/util/sighdl.c
index 2fbb59fdf4..7b7f03a936 100644
--- a/util/sighdl.c
+++ b/util/sighdl.c
@@ -5,6 +5,8 @@
 
 #include "sighdl.h"
 
+#include "platform/includes.h"
+
 bool nvme_sigint_received;
 
 static void nvme_sigint_handler(int signum)
diff --git a/util/table.c b/util/table.c
index 76366b93da..4936f41439 100644
--- a/util/table.c
+++ b/util/table.c
@@ -22,6 +22,8 @@
 
 #include "table.h"
 
+#include "platform/includes.h"
+
 static int table_get_value_width(struct value *v)
 {
 	char buf[64];
diff --git a/util/types.h b/util/types.h
index 4046d5c18c..abec3ba969 100644
--- a/util/types.h
+++ b/util/types.h
@@ -5,7 +5,7 @@
 /* type conversion helpers */
 
 #include <stdint.h>
-#include <linux/types.h>
+#include <platform/types.h>
 
 #include <libnvme.h>
 
diff --git a/windows-stubs.c b/windows-stubs.c
new file mode 100644
index 0000000000..00fa13111d
--- /dev/null
+++ b/windows-stubs.c
@@ -0,0 +1,78 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Windows compatibility implementation for nvme-cli application.
+ * 
+ * This file contains nvme-cli-specific Windows stubs for functionality
+ * not currently supported on Windows.
+ */
+
+#ifdef _WIN32
+
+#include <stdio.h>
+#include <stdbool.h>
+
+/* ========== NVMe Fabrics Command Stubs ========== */
+/*
+ * NVMe over Fabrics is not currently supported on Windows.
+ * These stubs provide error messages when users attempt to use fabrics commands.
+ */
+
+int fabrics_discovery(const char *desc, int argc, char **argv, bool connect)
+{
+	(void)desc; (void)argc; (void)argv; (void)connect;
+	fprintf(stderr, "NVMe fabrics discovery is not supported on Windows\n");
+	return -1;
+}
+
+int fabrics_connect(const char *desc, int argc, char **argv)
+{
+	(void)desc; (void)argc; (void)argv;
+	fprintf(stderr, "NVMe fabrics connect is not supported on Windows\n");
+	return -1;
+}
+
+int fabrics_disconnect(const char *desc, int argc, char **argv)
+{
+	(void)desc; (void)argc; (void)argv;
+	fprintf(stderr, "NVMe fabrics disconnect is not supported on Windows\n");
+	return -1;
+}
+
+int fabrics_disconnect_all(const char *desc, int argc, char **argv)
+{
+	(void)desc; (void)argc; (void)argv;
+	fprintf(stderr, "NVMe fabrics disconnect-all is not supported on Windows\n");
+	return -1;
+}
+
+int fabrics_config(const char *desc, int argc, char **argv)
+{
+	(void)desc; (void)argc; (void)argv;
+	fprintf(stderr, "NVMe fabrics config is not supported on Windows\n");
+	return -1;
+}
+
+int fabrics_dim(const char *desc, int argc, char **argv)
+{
+	(void)desc; (void)argc; (void)argv;
+	fprintf(stderr, "NVMe fabrics DIM is not supported on Windows\n");
+	return -1;
+}
+
+/* ========== NVMe RPMB Command Stubs ========== */
+/*
+ * NVMe RPMB (Replay Protected Memory Block) operations are not currently
+ * supported on Windows. This stub provides an error message.
+ */
+
+struct command;
+struct plugin;
+
+int rpmb_cmd_option(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+{
+	(void)argc; (void)argv; (void)cmd; (void)plugin;
+	fprintf(stderr, "NVMe RPMB commands are not supported on Windows\n");
+	return -1;
+}
+
+#endif /* _WIN32 */

From 2417c93e38641a04eec97411878ba6f4b30992fc Mon Sep 17 00:00:00 2001
From: Brandon Capener <bcapener@micron.com>
Date: Thu, 5 Feb 2026 09:01:10 -0700
Subject: [PATCH 14/83] More updates to windows-stubs.c function signatures
 (#42)

---
 libnvme/src/nvme/windows-stubs.c | 63 +++++++++++++++++++-------------
 1 file changed, 37 insertions(+), 26 deletions(-)

diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 3426f823ab..a56a8d51b4 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -284,17 +284,18 @@ void *nvme_next_ctrl(void *s, void *c)
 	return NULL;
 }
 
-nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport, const char *traddr,
-		       const char *trsvcid, const char *subsysnqn,
-		       const char *host_traddr, nvme_ctrl_t p)
+nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport,
+			     const char *traddr, const char *host_traddr,
+			     const char *host_iface, const char *trsvcid,
+			     nvme_ctrl_t p)
 {
 	stub_log(__func__);
 	(void)s;
 	(void)transport;
 	(void)traddr;
-	(void)trsvcid;
-	(void)subsysnqn;
 	(void)host_traddr;
+	(void)host_iface;
+	(void)trsvcid;
 	(void)p;
 	return NULL;
 }
@@ -735,18 +736,19 @@ int nvme_mi_scan_ep(nvme_mi_ep_t ep, bool force_rescan)
 	return -1;
 }
 
-void *nvme_mi_first_ctrl(void *ep)
+struct nvme_transport_handle *nvme_mi_first_transport_handle(nvme_mi_ep_t ep)
 {
 	stub_log(__func__);
 	(void)ep;
 	return NULL;
 }
 
-void *nvme_mi_next_ctrl(void *ep, void *c)
+struct nvme_transport_handle *nvme_mi_next_transport_handle(nvme_mi_ep_t ep,
+	struct nvme_transport_handle *hdl)
 {
 	stub_log(__func__);
 	(void)ep;
-	(void)c;
+	(void)hdl;
 	return NULL;
 }
 
@@ -769,53 +771,61 @@ int nvme_linux_status_to_errno(int status)
 /*
  * TLS/PSK key management stubs (linux.c functions)
  */
-int nvme_export_tls_key_versioned(unsigned char version, unsigned char hmac,
+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)
+				  size_t key_len, char **identity)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)version;
 	(void)hmac;
 	(void)key_data;
 	(void)key_len;
-	(void)encoded_keyp;
+	(void)identity;
 	errno = ENOTSUP;
 	return -1;
 }
 
-int nvme_export_tls_key(const unsigned char *key_data, int key_len, char **key)
+int nvme_export_tls_key(struct nvme_global_ctx *ctx,
+	const unsigned char *key_data, int key_len, char **identity)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)key_data;
 	(void)key_len;
-	(void)key;
+	(void)identity;
 	errno = ENOTSUP;
 	return -1;
 }
 
-int nvme_import_tls_key_versioned(const char *encoded_key,
+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)
+				  unsigned char **key)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)encoded_key;
 	(void)version;
 	(void)hmac;
 	(void)key_len;
-	(void)keyp;
+	(void)key;
 	errno = ENOTSUP;
 	return -1;
 }
 
-int nvme_import_tls_key(const char *encoded_key, int *key_len,
-			unsigned char **keyp)
+int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encoded_key,
+			int *key_len, unsigned int *hmac, unsigned char **key)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)encoded_key;
 	(void)key_len;
-	(void)keyp;
+	(void)hmac;
+	(void)key;
 	errno = ENOTSUP;
 	return -1;
 }
@@ -856,25 +866,25 @@ const char *nvme_transport_handle_get_name(void *hdl)
 	return "";
 }
 
-int nvme_transport_handle_is_blkdev(void *hdl)
+bool nvme_transport_handle_is_blkdev(struct nvme_transport_handle *hdl)
 {
 	stub_log(__func__);
 	(void)hdl;
-	return 0;
+	return false;
 }
 
-int nvme_transport_handle_is_chardev(void *hdl)
+bool nvme_transport_handle_is_chardev(struct nvme_transport_handle *hdl)
 {
 	stub_log(__func__);
 	(void)hdl;
-	return 0;
+	return false;
 }
 
-int nvme_transport_handle_is_direct(void *hdl)
+bool nvme_transport_handle_is_direct(struct nvme_transport_handle *hdl)
 {
 	stub_log(__func__);
 	(void)hdl;
-	return 0;
+	return false;
 }
 
 /* Controller property getters (tree.c) */
@@ -995,7 +1005,8 @@ nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p)
 }
 
 /* ANA log utilities (linux.c) */
-unsigned long nvme_get_ana_log_len_from_id_ctrl(const void *id_ctrl, int rgo)
+size_t nvme_get_ana_log_len_from_id_ctrl(const struct nvme_id_ctrl *id_ctrl,
+	bool rgo)
 {
 	stub_log(__func__);
 	(void)id_ctrl;

From aad5f1f5d92c4f1b39f21003b101215879aebf2a Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Thu, 5 Feb 2026 15:13:50 -0700
Subject: [PATCH 15/83] Add workflow to auto-merge master into mingw

---
 .../micron-merge-master-to-mingw.yml          | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 .github/workflows/micron-merge-master-to-mingw.yml

diff --git a/.github/workflows/micron-merge-master-to-mingw.yml b/.github/workflows/micron-merge-master-to-mingw.yml
new file mode 100644
index 0000000000..0481038fba
--- /dev/null
+++ b/.github/workflows/micron-merge-master-to-mingw.yml
@@ -0,0 +1,52 @@
+name: Micron - Merge master to mingw
+
+on:
+  push:
+    branches:
+      # Trigger merge when master is synced to upstream.
+      - master
+  schedule:
+    # Backup: Run at 4:30 AM UTC (1 hour after sync completes)
+    - cron: '30 4 * * *'
+  workflow_dispatch:
+
+jobs:
+  merge:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+      
+      - name: Configure Git identity
+        run: |
+          set -euo pipefail
+          git config --global user.name  "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+      
+      - name: Fetch branches
+        run: |
+          set -euo pipefail
+          git fetch origin master
+          git fetch origin mingw
+      
+      - name: Merge master into mingw
+        run: |
+          set -euo pipefail
+          git checkout mingw
+          git merge origin/master -m "Auto-merge master into mingw"
+      
+      - name: Push changes
+        run: |
+          set -euo pipefail
+          git push origin mingw
+      
+      - name: Notify on merge conflict
+        if: failure()
+        run: |
+          set -euo pipefail
+          echo "::error::Failed to merge master into mingw. Manual intervention required."
+          exit 1
\ No newline at end of file

From 83f78b154da9ef8b0ecd1d91d2e65cd9c1572236 Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Thu, 5 Feb 2026 15:40:42 -0700
Subject: [PATCH 16/83] Remove trailing whitespace.

---
 .github/workflows/micron-merge-master-to-mingw.yml | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/micron-merge-master-to-mingw.yml b/.github/workflows/micron-merge-master-to-mingw.yml
index 0481038fba..cd20dafe97 100644
--- a/.github/workflows/micron-merge-master-to-mingw.yml
+++ b/.github/workflows/micron-merge-master-to-mingw.yml
@@ -13,37 +13,37 @@ on:
 jobs:
   merge:
     runs-on: ubuntu-latest
-    
+
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
           token: ${{ secrets.GITHUB_TOKEN }}
-      
+
       - name: Configure Git identity
         run: |
           set -euo pipefail
           git config --global user.name  "github-actions[bot]"
           git config --global user.email "github-actions[bot]@users.noreply.github.com"
-      
+
       - name: Fetch branches
         run: |
           set -euo pipefail
           git fetch origin master
           git fetch origin mingw
-      
+
       - name: Merge master into mingw
         run: |
           set -euo pipefail
           git checkout mingw
           git merge origin/master -m "Auto-merge master into mingw"
-      
+
       - name: Push changes
         run: |
           set -euo pipefail
           git push origin mingw
-      
+
       - name: Notify on merge conflict
         if: failure()
         run: |

From a72bc91c001fba962b37118862fbe9f7090835c7 Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Fri, 6 Feb 2026 11:38:31 -0700
Subject: [PATCH 17/83] Use personal access token (PAT) so workflow can push
 the merge.

---
 .github/workflows/micron-merge-master-to-mingw.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/micron-merge-master-to-mingw.yml b/.github/workflows/micron-merge-master-to-mingw.yml
index cd20dafe97..7c0adbb207 100644
--- a/.github/workflows/micron-merge-master-to-mingw.yml
+++ b/.github/workflows/micron-merge-master-to-mingw.yml
@@ -19,7 +19,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
+          token: ${{ secrets.JLMUNN_PAT }}
 
       - name: Configure Git identity
         run: |

From b579b6ae44a6efa7f7d7beaeebdbc0f5d3bc6d3c Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Fri, 6 Feb 2026 15:12:28 -0700
Subject: [PATCH 18/83] Use Github app instead of PAT.

---
 .github/workflows/micron-merge-master-to-mingw.yml | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/micron-merge-master-to-mingw.yml b/.github/workflows/micron-merge-master-to-mingw.yml
index 7c0adbb207..824bc76dde 100644
--- a/.github/workflows/micron-merge-master-to-mingw.yml
+++ b/.github/workflows/micron-merge-master-to-mingw.yml
@@ -15,11 +15,18 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
+      - name: Generate token
+        id: generate-token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.TACT_SYNC_APP_ID }}
+          private-key: ${{ secrets.TACT_SYNC_APP_PRIVATE_KEY }}
+
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
-          token: ${{ secrets.JLMUNN_PAT }}
+          token: ${{ steps.generate-token.outputs.token }}
 
       - name: Configure Git identity
         run: |

From 80748e9f718c3736d24470bd5b61ee08faad1450 Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Fri, 6 Feb 2026 16:38:55 -0700
Subject: [PATCH 19/83] More tweaks to file

---
 .github/workflows/micron-merge-master-to-mingw.yml | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/micron-merge-master-to-mingw.yml b/.github/workflows/micron-merge-master-to-mingw.yml
index 824bc76dde..4d534f5ea4 100644
--- a/.github/workflows/micron-merge-master-to-mingw.yml
+++ b/.github/workflows/micron-merge-master-to-mingw.yml
@@ -25,25 +25,20 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
+          ref: mingw
           fetch-depth: 0
           token: ${{ steps.generate-token.outputs.token }}
 
       - name: Configure Git identity
         run: |
           set -euo pipefail
-          git config --global user.name  "github-actions[bot]"
-          git config --global user.email "github-actions[bot]@users.noreply.github.com"
-
-      - name: Fetch branches
-        run: |
-          set -euo pipefail
-          git fetch origin master
-          git fetch origin mingw
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
 
       - name: Merge master into mingw
         run: |
           set -euo pipefail
-          git checkout mingw
+          git fetch origin master
           git merge origin/master -m "Auto-merge master into mingw"
 
       - name: Push changes

From d5bfc8757b9b38bf93ff8484f5b00f5ff360c9c8 Mon Sep 17 00:00:00 2001
From: Jim Munn <jlmunn@micron.com>
Date: Mon, 9 Feb 2026 12:23:45 -0700
Subject: [PATCH 20/83] Remove --strict from call to checkpatch.pl to match
 upstream behavior.

---
 .github/workflows/micron-checkpatch.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/micron-checkpatch.yml b/.github/workflows/micron-checkpatch.yml
index 60e2bc192a..7cb83ad05c 100644
--- a/.github/workflows/micron-checkpatch.yml
+++ b/.github/workflows/micron-checkpatch.yml
@@ -41,7 +41,7 @@ jobs:
         git diff origin/${{ github.base_ref }} > patch.diff
 
         echo "::group::Checkpatch Results"
-        if ./checkpatch.pl --no-tree --strict --show-types patch.diff; then
+        if ./checkpatch.pl --no-tree --show-types patch.diff; then
           echo "::endgroup::"
           echo "✅ No checkpatch issues found"
         else

From de9449ead6de79a6e4d351a265a704d8bdc288ca Mon Sep 17 00:00:00 2001
From: Brandon Capener <bcapener@micron.com>
Date: Mon, 9 Feb 2026 12:44:47 -0700
Subject: [PATCH 21/83] Update nvme transport handle file descriptor type (#45)

---
 libnvme/src/libnvme.ld           |  1 +
 libnvme/src/nvme/ioctl.c         |  4 +-
 libnvme/src/nvme/linux.c         |  6 +--
 libnvme/src/nvme/linux.h         |  2 +-
 libnvme/src/nvme/private.h       |  2 +-
 libnvme/src/nvme/windows-stubs.c | 70 +++++++++++++++++++++++++++++---
 libnvme/src/platform/linux.h     | 10 +++++
 libnvme/src/platform/windows.h   | 10 ++++-
 libnvme/test/ioctl/ana.c         |  1 -
 libnvme/test/ioctl/discovery.c   |  1 -
 libnvme/test/ioctl/features.c    |  1 -
 libnvme/test/ioctl/identify.c    |  1 -
 libnvme/test/ioctl/logs.c        |  1 -
 libnvme/test/ioctl/misc.c        |  1 -
 libnvme/test/ioctl/mock.c        | 12 +++---
 libnvme/test/ioctl/mock.h        |  2 +-
 libnvme/test/ioctl/zns.c         |  1 -
 plugins/ocp/ocp-nvme.c           |  4 +-
 18 files changed, 101 insertions(+), 29 deletions(-)

diff --git a/libnvme/src/libnvme.ld b/libnvme/src/libnvme.ld
index cd405faf97..67748349c8 100644
--- a/libnvme/src/libnvme.ld
+++ b/libnvme/src/libnvme.ld
@@ -77,6 +77,7 @@ LIBNVME_2_0 {
 		nvme_free_ns;
 		nvme_free_subsystem;
 		nvme_free_uri;
+		nvme_fstat;
 		nvme_fw_download_seq;
 		nvme_gen_dhchap_key;
 		nvme_generate_tls_key_identity;
diff --git a/libnvme/src/nvme/ioctl.c b/libnvme/src/nvme/ioctl.c
index 2242b07d05..1c412c7240 100644
--- a/libnvme/src/nvme/ioctl.c
+++ b/libnvme/src/nvme/ioctl.c
@@ -27,7 +27,7 @@
 static int nvme_verify_chr(struct nvme_transport_handle *hdl)
 {
 	static struct stat nvme_stat;
-	int err = fstat(hdl->fd, &nvme_stat);
+	int err = nvme_fstat(hdl->fd, &nvme_stat);
 
 	if (err < 0)
 		return -errno;
@@ -298,7 +298,7 @@ static bool nvme_uring_is_usable(struct nvme_transport_handle *hdl)
 
 	if (io_uring_kernel_support != IO_URING_AVAILABLE ||
 	    hdl->type != NVME_TRANSPORT_HANDLE_TYPE_DIRECT ||
-	    fstat(hdl->fd, &st) || !S_ISCHR(st.st_mode))
+	    nvme_fstat(hdl->fd, &st) || !S_ISCHR(st.st_mode))
 		return false;
 
 	return true;
diff --git a/libnvme/src/nvme/linux.c b/libnvme/src/nvme/linux.c
index 86596a269f..5822560054 100644
--- a/libnvme/src/nvme/linux.c
+++ b/libnvme/src/nvme/linux.c
@@ -94,7 +94,7 @@ static int __nvme_transport_handle_open_direct(struct nvme_transport_handle *hdl
 	if (hdl->fd < 0)
 		return -errno;
 
-	ret = fstat(hdl->fd, &hdl->stat);
+	ret = nvme_fstat(hdl->fd, &hdl->stat);
 	if (ret < 0)
 		return -errno;
 
@@ -152,7 +152,7 @@ int nvme_open(struct nvme_global_ctx *ctx, const char *name,
 
 	if (!strncmp(name, "NVME_TEST_FD", 12)) {
 		hdl->type = NVME_TRANSPORT_HANDLE_TYPE_DIRECT;
-		hdl->fd = 0xFD;
+		hdl->fd = TEST_FD;
 
 		if (!strcmp(name, "NVME_TEST_FD64"))
 			hdl->ioctl64 = true;
@@ -196,7 +196,7 @@ void nvme_close(struct nvme_transport_handle *hdl)
 	}
 }
 
-int nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl)
+nvme_fd_t nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl)
 {
 	return hdl->fd;
 }
diff --git a/libnvme/src/nvme/linux.h b/libnvme/src/nvme/linux.h
index 45c2e6da07..71b5597c67 100644
--- a/libnvme/src/nvme/linux.h
+++ b/libnvme/src/nvme/linux.h
@@ -243,7 +243,7 @@ void nvme_close(struct nvme_transport_handle *hdl);
  *
  * Return: File descriptor for an IOCTL based transport handle, otherwise -1.
  */
-int nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl);
+nvme_fd_t nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl);
 
 /**
  * nvme_transport_handle_get_name - Return name of the device transport handle
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index 4337d83af0..22a728fc17 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -97,7 +97,7 @@ struct nvme_transport_handle {
 			struct nvme_passthru_cmd *cmd, int err);
 
 	/* direct */
-	int fd;
+	nvme_fd_t fd;
 	struct stat stat;
 	bool ioctl64;
 
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index a56a8d51b4..7ea84e42d2 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -852,14 +852,13 @@ void nvme_close(struct nvme_transport_handle *hdl)
 	(void)hdl;
 }
 
-int nvme_transport_handle_get_fd(void *hdl)
+nvme_fd_t nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl)
 {
-	stub_log(__func__);
-	(void)hdl;
-	return -1;
+	// TODO: identical to linux.c, need to refactor.
+	return hdl->fd;
 }
 
-const char *nvme_transport_handle_get_name(void *hdl)
+const char *nvme_transport_handle_get_name(struct nvme_transport_handle *hdl)
 {
 	stub_log(__func__);
 	(void)hdl;
@@ -1321,4 +1320,65 @@ void nvmf_nbft_free(struct nvme_global_ctx *ctx, struct nbft_file_entry *head)
 	stub_log(__func__);
 	(void)ctx;
 	(void)head;
+}
+
+/* Platform-specific fstat wrapper for nvme_fd_t */
+int nvme_fstat(nvme_fd_t fd, struct stat *buf)
+{
+	BY_HANDLE_FILE_INFORMATION file_info;
+	ULARGE_INTEGER ull;
+
+	if (!buf) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	/* Check for invalid handle */
+	if (fd == INVALID_HANDLE_VALUE || fd == NULL) {
+		errno = EBADF;
+		return -1;
+	}
+
+	/* Get file information from Windows handle */
+	if (!GetFileInformationByHandle(fd, &file_info)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	/* Fill in the stat structure */
+	memset(buf, 0, sizeof(*buf));
+
+	/* Convert Windows file attributes to stat mode */
+	if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DEVICE)
+		/* Windows device files should be marked as block devices */
+		/* This is used by nvme_verify_chr to check device type */
+		buf->st_mode = S_IFBLK | 0600;
+	else if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+		buf->st_mode = S_IFDIR | 0755;
+	else
+		buf->st_mode = S_IFREG | 0644;
+
+	/* File size */
+	buf->st_size = (((off_t)file_info.nFileSizeHigh << 32)
+					| file_info.nFileSizeLow);
+
+	/* Number of hard links */
+	buf->st_nlink = file_info.nNumberOfLinks;
+
+	/* Convert FILETIME to time_t for timestamps */
+	/* Windows FILETIME is 100-nanosecond intervals since Jan 1, 1601 */
+	/* Unix time_t is seconds since Jan 1, 1970 */
+	ull.LowPart = file_info.ftLastWriteTime.dwLowDateTime;
+	ull.HighPart = file_info.ftLastWriteTime.dwHighDateTime;
+	buf->st_mtime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
+
+	ull.LowPart = file_info.ftLastAccessTime.dwLowDateTime;
+	ull.HighPart = file_info.ftLastAccessTime.dwHighDateTime;
+	buf->st_atime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
+
+	ull.LowPart = file_info.ftCreationTime.dwLowDateTime;
+	ull.HighPart = file_info.ftCreationTime.dwHighDateTime;
+	buf->st_ctime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
+
+	return 0;
 }
\ No newline at end of file
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index 70df6d4067..d72fa48595 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -39,6 +39,16 @@
 /* Extract IPv4 from IPv6 mapped address */
 #define ipv4_from_in6_addr(addr) &(addr.s6_addr32[3])
 
+typedef int nvme_fd_t;
+#define TEST_FD 0xFD
+#define INIT_FD -1
+
+/* Platform-specific fstat wrapper for nvme_fd_t */
+static inline int nvme_fstat(nvme_fd_t fd, struct stat *buf)
+{
+	return fstat(fd, buf);
+}
+
 /* Platform-specific UUID generation using /dev/urandom */
 static inline int random_uuid(unsigned char *uuid, size_t len)
 {
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 00db818496..96e04f08d5 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -99,8 +99,16 @@ static inline void closelog(void) { }
 #define BLKRRPART 0x125F
 #endif
 
+typedef HANDLE nvme_fd_t;
+#define TEST_FD INVALID_HANDLE_VALUE
+#define INIT_FD nullptr
+
+/* Platform-specific fstat wrapper for nvme_fd_t */
+int nvme_fstat(nvme_fd_t fd, struct stat *buf);
+
 /* Windows ioctl stub functions */
-static inline int ioctl(int fd, unsigned long request, ...) {
+static inline int ioctl(nvme_fd_t fd, unsigned long request, ...)
+{
     (void)fd; (void)request;
     errno = ENOSYS;
     return -1;
diff --git a/libnvme/test/ioctl/ana.c b/libnvme/test/ioctl/ana.c
index 77aa17e904..d26ba72262 100644
--- a/libnvme/test/ioctl/ana.c
+++ b/libnvme/test/ioctl/ana.c
@@ -14,7 +14,6 @@
 #include "nvme/types.h"
 #include "util.h"
 
-#define TEST_FD 0xFD
 #define PDU_SIZE NVME_LOG_PAGE_PDU_SIZE
 
 static struct nvme_transport_handle *test_hdl;
diff --git a/libnvme/test/ioctl/discovery.c b/libnvme/test/ioctl/discovery.c
index a39621d8b3..0dfe58e784 100644
--- a/libnvme/test/ioctl/discovery.c
+++ b/libnvme/test/ioctl/discovery.c
@@ -13,7 +13,6 @@
 #include "mock.h"
 #include "util.h"
 
-#define TEST_FD 0xFD
 #define HEADER_LEN 20
 
 static struct nvme_transport_handle *test_hdl;
diff --git a/libnvme/test/ioctl/features.c b/libnvme/test/ioctl/features.c
index 5c4eddcf1e..88804b9276 100644
--- a/libnvme/test/ioctl/features.c
+++ b/libnvme/test/ioctl/features.c
@@ -8,7 +8,6 @@
 #include "mock.h"
 #include "util.h"
 
-#define TEST_FD 0xFD
 #define TEST_TIMEOUT 1234
 #define TEST_NSID 0x89ABCDEF
 #define TEST_CDW11 0x11111111
diff --git a/libnvme/test/ioctl/identify.c b/libnvme/test/ioctl/identify.c
index cdafd22b1e..6a52b62675 100644
--- a/libnvme/test/ioctl/identify.c
+++ b/libnvme/test/ioctl/identify.c
@@ -8,7 +8,6 @@
 #include "mock.h"
 #include "util.h"
 
-#define TEST_FD 0xFD
 #define TEST_NSID 0x12345678
 #define TEST_NVMSETID 0xABCD
 #define TEST_UUID 123
diff --git a/libnvme/test/ioctl/logs.c b/libnvme/test/ioctl/logs.c
index a641470d24..b3d63b4b33 100644
--- a/libnvme/test/ioctl/logs.c
+++ b/libnvme/test/ioctl/logs.c
@@ -7,7 +7,6 @@
 #include <nvme/ioctl.h>
 #include <nvme/types.h>
 
-#define TEST_FD 0xFD
 #define TEST_NSID 0x12345678
 #define TEST_NVMSETID 0xABCD
 #define TEST_CSI NVME_CSI_KV
diff --git a/libnvme/test/ioctl/misc.c b/libnvme/test/ioctl/misc.c
index 7ac6519d86..160aaa9c02 100644
--- a/libnvme/test/ioctl/misc.c
+++ b/libnvme/test/ioctl/misc.c
@@ -9,7 +9,6 @@
 #include <string.h>
 #include <inttypes.h>
 
-#define TEST_FD 0xFD
 #define TEST_NSID 0x12345678
 #define TEST_CSI NVME_CSI_KV
 
diff --git a/libnvme/test/ioctl/mock.c b/libnvme/test/ioctl/mock.c
index d6ff12ee7e..22297c97c2 100644
--- a/libnvme/test/ioctl/mock.c
+++ b/libnvme/test/ioctl/mock.c
@@ -19,7 +19,7 @@ struct mock_cmds {
 	size_t remaining_cmds;
 };
 
-static int mock_fd = -1;
+static nvme_fd_t mock_fd = INIT_FD;
 static struct mock_cmds mock_admin_cmds = {.name = "admin"};
 static struct mock_cmds mock_io_cmds = {.name = "IO"};
 
@@ -37,7 +37,7 @@ static void mock_cmds_done(const struct mock_cmds *mock_cmds)
 	      mock_cmds->remaining_cmds, mock_cmds->name);
 }
 
-void set_mock_fd(int fd)
+void set_mock_fd(nvme_fd_t fd)
 {
 	mock_fd = fd;
 }
@@ -120,11 +120,11 @@ void end_mock_cmds(void)
 })
 
 #if defined(HAVE_GLIBC_IOCTL) && HAVE_GLIBC_IOCTL == 1
-typedef int (*ioctl_func_t)(int, unsigned long, void *);
-int ioctl(int fd, unsigned long request, ...)
+typedef int (*ioctl_func_t)(nvme_fd_t, unsigned long, void *);
+int ioctl(nvme_fd_t fd, unsigned long request, ...)
 #else
-typedef int (*ioctl_func_t)(int, int, void *);
-int ioctl(int fd, int request, ...)
+typedef int (*ioctl_func_t)(nvme_fd_t, int, void *);
+int ioctl(nvme_fd_t fd, int request, ...)
 #endif
 {
 	ioctl_func_t real_ioctl = NULL;
diff --git a/libnvme/test/ioctl/mock.h b/libnvme/test/ioctl/mock.h
index c4b4bd6ac1..8e2af7cab6 100644
--- a/libnvme/test/ioctl/mock.h
+++ b/libnvme/test/ioctl/mock.h
@@ -61,7 +61,7 @@ struct mock_cmd {
  * set_mock_fd() - sets the expected file descriptor for NVMe passthru ioctls()
  * @fd: file descriptor expected to be passed to ioctl()
  */
-void set_mock_fd(int fd);
+void set_mock_fd(nvme_fd_t fd);
 
 /**
  * set_mock_admin_cmds() - mocks NVMe admin passthru ioctl() invocations
diff --git a/libnvme/test/ioctl/zns.c b/libnvme/test/ioctl/zns.c
index 56ababbc9a..76a381d0d8 100644
--- a/libnvme/test/ioctl/zns.c
+++ b/libnvme/test/ioctl/zns.c
@@ -8,7 +8,6 @@
 #include <nvme/types.h>
 #include <inttypes.h>
 
-#define TEST_FD 0xFD
 #define TEST_NSID 0x12345678
 #define TEST_SLBA 0xffffffff12345678
 
diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index a49d59c357..88244a3776 100644
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -360,7 +360,7 @@ int ocp_set_latency_monitor_feature(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = fstat(nvme_transport_handle_get_fd(hdl), &nvme_stat);
+	err = nvme_fstat(nvme_transport_handle_get_fd(hdl), &nvme_stat);
 	if (err < 0)
 		return err;
 
@@ -1472,7 +1472,7 @@ static int ocp_telemetry_log(int argc, char **argv, struct command *acmd, struct
 	if (opt.telemetry_type == 0)
 		opt.telemetry_type = "host";
 
-	err = fstat(nvme_transport_handle_get_fd(hdl), &nvme_stat);
+	err = nvme_fstat(nvme_transport_handle_get_fd(hdl), &nvme_stat);
 	if (err < 0)
 		return err;
 

From e0939af60ca7a9e5a8eab7604278c0d786487069 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Wed, 11 Feb 2026 13:27:59 -0700
Subject: [PATCH 22/83] feat: Implemented admin commands supported on Windows
 using Windows IOCTLs (#50)

* Broke methods with Linux ioctl calls into linux-specific implementation file and added stubs for Windows implementations.

* Added admin command stubs for supported commands.

* Initial implementation of nvme_submit_admin_identify.

Compiles. Untested.

* Removed ioctl stub function from platform_windows.h

Any ioctl calls need to be handled by Windows-specific code.  Current libnvme ioctl calls have been moved into ioctl-linux.c/ioctl-windows.c, so the ioctl stub in platform_windows.h is no longer needed.

* Added initial implementation of nvme_submit_admin_vendor_unique (passthrough)

* Pulled command initialization out of loop and additional cleanup.

* Added Get Log Page implementation.

* Updates for format_cmd direct ioctl calls.

- Calling nvme_ns_rescan instead of direct NVME_IOCTL_RESCAN ioctl call.
- Restored ioctl stub in platform/windows.h as temporary workaround for direct BLKBSZSET and BLKRRPART ioctl calls.
- Updated TODO.md entry for ioctl stub to note what will be needed to get rid of the stub.

* Implemented get features command.

* Implemented Set Features command.

* Removed unsupported SubValue5 setting.

* Implemented FW Download.  Several TODO comments left that require verification.

* Added FW commit implementation.

* Fixed security receive check and method name.

* Added security send/receive implementations.

* Implement self test and sanitize using storage protocol command pass-through.

* Format NVM implemented as much as possible based on documentation.

* Cleanup and fixes.

* Removing unrelated changes to ioctl usage in nvme.c.  Saving for a separate PR.

* REmoving unneccesary .gitignore change.

* Fixed checkpatch errors and explicitly added windows includes.

* Fixed identify CSI check.

* Checking SCSI command status after IOCTL_SCSI_PASS_THROUGH

* Handling data direction of storage protocol passthrough commands and added some more error checking.

* Fixed opening brace formatting reported by checkpatch.

* Fixing checkpatch formatting warnings where feasible.

* More minor checkpatch fixes.

* Removed HANDLE casts and switched to using hdl->fd directly.

A recent change that was merged in updated the type of nvme_transport_handle::fd on Windows builds to be HANDLE, so casting the value and storing it in a new variable was no longer necessary.

* Update ioctl-linux.c to align with upstream changes.

Co-authored-by: Brandon Capener <bcapener@micron.com>

* Moving linux implementations back into main ioctl.c.

To make merges from upstream easier for now, leaving linux-specific implementations where they are, but inside of #ifndef _WIN32 blocks.  Eventually we will probably pull these out again.

---------

Co-authored-by: Brandon Capener <bcapener@micron.com>
---
 libnvme/src/meson.build          |    1 +
 libnvme/src/nvme/ioctl-windows.c | 1225 ++++++++++++++++++++++++++++++
 libnvme/src/nvme/ioctl.c         |    4 +
 3 files changed, 1230 insertions(+)
 create mode 100644 libnvme/src/nvme/ioctl-windows.c

diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index d98502c1fe..7244ff0d86 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -18,6 +18,7 @@ sources = [
 if is_windows
     # Windows-specific sources (exclude Linux networking, fabrics, and filesystem code)
     sources += [
+        'nvme/ioctl-windows.c',  # Windows stubs for Linux-specific ioctl functions
         'nvme/windows-stubs.c',  # Stubs for excluded functions
         'platform/windows.c',  # POSIX compatibility implementations
     ]
diff --git a/libnvme/src/nvme/ioctl-windows.c b/libnvme/src/nvme/ioctl-windows.c
new file mode 100644
index 0000000000..d23e2aacbb
--- /dev/null
+++ b/libnvme/src/nvme/ioctl-windows.c
@@ -0,0 +1,1225 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2025 Micron Technology, Inc.
+ *
+ * Authors: Broc Going <bgoing@micron.com>
+ *
+ * Windows-specific implementations of ioctl-based functions.
+ */
+
+#include "ioctl.h"
+#include "private.h"
+#include "types.h"
+
+#include <windows.h>
+#include <winioctl.h>
+#include <errno.h>
+#include <ntddscsi.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+/* Definitions not yet included in mingw's winerror.h */
+#define STG_E_FIRMWARE_SLOT_INVALID      _HRESULT_TYPEDEF_(0x80030208L)
+#define STG_E_FIRMWARE_IMAGE_INVALID     _HRESULT_TYPEDEF_(0x80030209L)
+
+static int get_last_error_as_errno(void)
+{
+	DWORD error = GetLastError();
+
+	/* Convert Windows error to errno */
+	switch (error) {
+	case ERROR_INVALID_PARAMETER:
+		return -EINVAL;
+	case ERROR_NOT_SUPPORTED:
+		return -ENOTSUP;
+	case ERROR_INSUFFICIENT_BUFFER:
+		return -ENOMEM;
+	case ERROR_IO_DEVICE:
+		return -EIO;
+	case STG_E_FIRMWARE_IMAGE_INVALID:
+		return -EILSEQ;
+	case STG_E_FIRMWARE_SLOT_INVALID:
+		return -EINVAL;
+	default:
+		return -EIO;
+	}
+}
+
+static int get_errno_from_storage_protocol_status(DWORD status)
+{
+	switch (status) {
+	case STORAGE_PROTOCOL_STATUS_SUCCESS:
+		return 0;
+	case STORAGE_PROTOCOL_STATUS_PENDING:
+		return -EAGAIN;
+	case STORAGE_PROTOCOL_STATUS_ERROR:
+		return -EIO;
+	case STORAGE_PROTOCOL_STATUS_INVALID_REQUEST:
+		return -EINVAL;
+	case STORAGE_PROTOCOL_STATUS_NO_DEVICE:
+		return -ENODEV;
+	case STORAGE_PROTOCOL_STATUS_BUSY:
+		return -EBUSY;
+	case STORAGE_PROTOCOL_STATUS_DATA_OVERRUN:
+		return -E2BIG;
+	case STORAGE_PROTOCOL_STATUS_INSUFFICIENT_RESOURCES:
+		return -ENOMEM;
+	case STORAGE_PROTOCOL_STATUS_THROTTLED_REQUEST:
+		return -EIO;
+	case STORAGE_PROTOCOL_STATUS_NOT_SUPPORTED:
+		return -ENOTSUP;
+	default:
+		return -EIO;
+	}
+}
+
+int nvme_subsystem_reset(struct nvme_transport_handle *hdl)
+{
+	(void)hdl;
+	return -ENOTSUP;
+}
+
+int nvme_ctrl_reset(struct nvme_transport_handle *hdl)
+{
+	(void)hdl;
+	return -ENOTSUP;
+}
+
+int nvme_ns_rescan(struct nvme_transport_handle *hdl)
+{
+	(void)hdl;
+	return -ENOTSUP;
+}
+
+int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
+{
+	(void)hdl;
+	(void)nsid;
+	return -ENOTSUP;
+}
+
+int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	(void)hdl;
+	(void)cmd;
+	return -ENOTSUP;
+}
+
+static int nvme_submit_storage_protocol_command(
+		struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	PSTORAGE_PROTOCOL_COMMAND protocol_command = NULL;
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	PUCHAR buffer = NULL;
+	void *user_data;
+	int err = 0;
+	bool is_read = false;
+	bool is_write = false;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	if (cmd->data_len > 0 && !cmd->addr) {
+		err = -EINVAL;
+		goto out;
+	}
+
+	/*
+	 * Get the Data Transfer Direction (DTD) from the opcode:
+	 * 00b = No data transfer
+	 * 01b = Host to Controller Transfer
+	 * 10b = Controller to Host Transfer
+	 * 11b = Bi-Directional Transfer
+	 */
+	is_write = cmd->opcode & 0x1;
+	is_read = cmd->opcode & 0x2;
+
+	/* Bi-directional transfers not supported */
+	if (is_read && is_write) {
+		err = -ENOTSUP;
+		goto out;
+	}
+
+	/* Allocate buffer for STORAGE_PROTOCOL_COMMAND + NVME command + data */
+	buffer_len = FIELD_OFFSET(STORAGE_PROTOCOL_COMMAND, Command) +
+		STORAGE_PROTOCOL_COMMAND_LENGTH_NVME +
+		(cmd->data_len > 0 ? cmd->data_len : 0);
+
+	buffer = (PUCHAR)malloc(buffer_len);
+	if (!buffer) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(buffer, buffer_len);
+
+	protocol_command = (PSTORAGE_PROTOCOL_COMMAND)buffer;
+
+	protocol_command->Version = STORAGE_PROTOCOL_STRUCTURE_VERSION;
+	protocol_command->Length = sizeof(STORAGE_PROTOCOL_COMMAND);
+	protocol_command->ProtocolType = ProtocolTypeNvme;
+	protocol_command->Flags = STORAGE_PROTOCOL_COMMAND_FLAG_ADAPTER_REQUEST;
+	protocol_command->CommandLength = STORAGE_PROTOCOL_COMMAND_LENGTH_NVME;
+	protocol_command->ErrorInfoLength = 0;
+	protocol_command->TimeOutValue = (cmd->timeout_ms > 0) ?
+		((cmd->timeout_ms + 999) / 1000) : 10; // Round up to seconds
+
+	protocol_command->CommandSpecific =
+		STORAGE_PROTOCOL_SPECIFIC_NVME_ADMIN_COMMAND;
+	memcpy(protocol_command->Command, cmd,
+		STORAGE_PROTOCOL_COMMAND_LENGTH_NVME);
+
+	if (cmd->addr && cmd->data_len > 0 && is_read) {
+		protocol_command->DataFromDeviceTransferLength = cmd->data_len;
+		protocol_command->DataFromDeviceBufferOffset =
+			FIELD_OFFSET(STORAGE_PROTOCOL_COMMAND, Command) +
+			STORAGE_PROTOCOL_COMMAND_LENGTH_NVME;
+	} else if (cmd->addr && cmd->data_len > 0 && is_write) {
+		protocol_command->DataToDeviceTransferLength = cmd->data_len;
+		protocol_command->DataToDeviceBufferOffset =
+			FIELD_OFFSET(STORAGE_PROTOCOL_COMMAND, Command) +
+			STORAGE_PROTOCOL_COMMAND_LENGTH_NVME;
+		memcpy((PUCHAR)buffer + protocol_command->DataToDeviceBufferOffset,
+			(void *)(uintptr_t)cmd->addr, cmd->data_len);
+	}
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+					IOCTL_STORAGE_PROTOCOL_COMMAND,
+					buffer,
+					buffer_len,
+					buffer,
+					buffer_len,
+					&returned_len,
+					NULL);
+		if (result && protocol_command->ReturnStatus == STORAGE_PROTOCOL_STATUS_SUCCESS)
+			break;
+
+		if (!result)
+			err = get_last_error_as_errno();
+		else
+			err = get_errno_from_storage_protocol_status(
+				protocol_command->ReturnStatus);
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	/* Copy the returned data to the user's buffer */
+	if (cmd->addr && cmd->data_len > 0 && is_read) {
+		memcpy((void *)(uintptr_t)cmd->addr,
+			(PUCHAR)buffer + protocol_command->DataFromDeviceBufferOffset,
+			cmd->data_len);
+	}
+
+	/* Copy the completion queue entry (CQE) DW0-1 into cmd->result. */
+	memcpy(&cmd->result, &protocol_command->FixedProtocolReturnData,
+		sizeof(cmd->result));
+
+out_free_buffer:
+	free(buffer);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+static int nvme_submit_admin_get_log_page(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	PSTORAGE_PROPERTY_QUERY query = NULL;
+	PSTORAGE_PROTOCOL_SPECIFIC_DATA protocol_data = NULL;
+	STORAGE_PROTOCOL_DATA_SUBVALUE_GET_LOG_PAGE protocol_data_subval = { 0 };
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	PUCHAR buffer = NULL;
+	__u32 csi;
+	void *user_data;
+	int err = 0;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	/* Command Set Indicator values other than NVME_CSI_NVM not supported */
+	csi = NVME_FIELD_DECODE(cmd->cdw14,
+				NVME_LOG_CDW14_CSI_SHIFT,
+				NVME_LOG_CDW14_CSI_MASK);
+	if (csi != NVME_CSI_NVM) {
+		err = -ENOTSUP;
+		goto out;
+	}
+
+	buffer_len = FIELD_OFFSET(STORAGE_PROPERTY_QUERY, AdditionalParameters) +
+		sizeof(STORAGE_PROTOCOL_SPECIFIC_DATA) + cmd->data_len;
+
+	buffer = (PUCHAR)malloc(buffer_len);
+	if (!buffer) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(buffer, buffer_len);
+
+	query = (PSTORAGE_PROPERTY_QUERY)buffer;
+	protocol_data = (PSTORAGE_PROTOCOL_SPECIFIC_DATA)query->AdditionalParameters;
+
+	/*
+	 * Use StorageDeviceProtocolSpecificProperty for log pages.
+	 * Per Windows documentation, this queries device/namespace
+	 * protocol-specific properties.
+	 */
+	query->PropertyId = StorageDeviceProtocolSpecificProperty;
+	query->QueryType = PropertyStandardQuery;
+
+	protocol_data->ProtocolType = ProtocolTypeNvme;
+	protocol_data->DataType = NVMeDataTypeLogPage;
+
+	protocol_data->ProtocolDataRequestValue = NVME_FIELD_DECODE(cmd->cdw10,
+					NVME_LOG_CDW10_LID_SHIFT,
+					NVME_LOG_CDW10_LID_MASK);
+
+	protocol_data->ProtocolDataRequestSubValue = cmd->cdw12;	/* LPO[31:0]  */
+	protocol_data->ProtocolDataRequestSubValue2 = cmd->cdw13;	/* LPO[63:32] */
+
+	protocol_data->ProtocolDataRequestSubValue3 = NVME_FIELD_DECODE(cmd->cdw11,
+					NVME_LOG_CDW11_LSI_SHIFT,
+					NVME_LOG_CDW11_LSI_MASK);
+
+	protocol_data_subval.RetainAsynEvent = NVME_FIELD_DECODE(cmd->cdw10,
+					NVME_LOG_CDW10_RAE_SHIFT,
+					NVME_LOG_CDW10_RAE_MASK);
+	protocol_data_subval.LogSpecificField = NVME_FIELD_DECODE(cmd->cdw10,
+					NVME_LOG_CDW10_LSP_SHIFT,
+					NVME_LOG_CDW10_LSP_MASK);
+	protocol_data->ProtocolDataRequestSubValue4 = protocol_data_subval.AsUlong;
+
+	protocol_data->ProtocolDataOffset = sizeof(STORAGE_PROTOCOL_SPECIFIC_DATA);
+	protocol_data->ProtocolDataLength = cmd->data_len;
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+					IOCTL_STORAGE_QUERY_PROPERTY,
+					buffer,
+					buffer_len,
+					buffer,
+					buffer_len,
+					&returned_len,
+					NULL);
+		if (result)
+			break;
+		err = get_last_error_as_errno();
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	/* Copy the returned log page data to the user's buffer */
+	if (cmd->addr && cmd->data_len > 0) {
+		memcpy((void *)(uintptr_t)cmd->addr,
+			(PUCHAR)protocol_data + protocol_data->ProtocolDataOffset,
+			min(protocol_data->ProtocolDataLength, cmd->data_len));
+	}
+
+	/* Only 32-bits of return data. Assuming CQE DW0. */
+	cmd->result = protocol_data->FixedProtocolReturnData;
+
+out_free_buffer:
+	free(buffer);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+static int nvme_submit_admin_identify(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	PSTORAGE_PROPERTY_QUERY query = NULL;
+	PSTORAGE_PROTOCOL_SPECIFIC_DATA protocol_data = NULL;
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	PUCHAR buffer = NULL;
+	__u32 cns;
+	__u32 csi;
+	void *user_data;
+	int err = 0;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	/*
+	 * From Windows STORAGE_PROTOCOL_NVME_DATA_TYPE documentation
+	 * for NVMeDataTypeIdentify:
+	 * "ProtocolDataRequestValue will be NVME_IDENTIFY_CNS_CONTROLLER for
+	 * adapter or NVME_IDENTIFY_CNS_SPECIFIC_NAMESPACE for namespace."
+	 * Other CNS values are not supported.
+	 */
+	cns = NVME_FIELD_DECODE(cmd->cdw10,
+				NVME_IDENTIFY_CDW10_CNS_SHIFT,
+				NVME_IDENTIFY_CDW10_CNS_MASK);
+	if (cns != NVME_IDENTIFY_CNS_CTRL && cns != NVME_IDENTIFY_CNS_NS) {
+		err = -ENOTSUP;
+		goto out;
+	}
+
+	/* Command Set Indicator values other than NVME_CSI_NVM not supported */
+	csi = NVME_FIELD_DECODE(cmd->cdw11,
+				NVME_IDENTIFY_CDW11_CSI_SHIFT,
+				NVME_IDENTIFY_CDW11_CSI_MASK);
+	if (csi != NVME_CSI_NVM) {
+		err = -ENOTSUP;
+		goto out;
+	}
+
+	buffer_len = FIELD_OFFSET(STORAGE_PROPERTY_QUERY, AdditionalParameters) +
+		sizeof(STORAGE_PROTOCOL_SPECIFIC_DATA) + cmd->data_len;
+
+	buffer = (PUCHAR)malloc(buffer_len);
+	if (!buffer) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(buffer, buffer_len);
+
+	query = (PSTORAGE_PROPERTY_QUERY)buffer;
+	protocol_data = (PSTORAGE_PROTOCOL_SPECIFIC_DATA)query->AdditionalParameters;
+
+	// NOTE: If testing fails with Identify Specific Namespace, try
+	// StorageDeviceProtocolSpecificProperty for that cns.
+	query->PropertyId = StorageAdapterProtocolSpecificProperty;
+
+	protocol_data->ProtocolType = ProtocolTypeNvme;
+	protocol_data->DataType = NVMeDataTypeIdentify;
+
+	protocol_data->ProtocolDataRequestValue = cns;
+	protocol_data->ProtocolDataRequestSubValue = cmd->nsid;
+	protocol_data->ProtocolDataOffset = sizeof(STORAGE_PROTOCOL_SPECIFIC_DATA);
+	protocol_data->ProtocolDataLength = cmd->data_len;
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+					IOCTL_STORAGE_QUERY_PROPERTY,
+					buffer,
+					buffer_len,
+					buffer,
+					buffer_len,
+					&returned_len,
+					NULL);
+		if (result)
+			break;
+		err = get_last_error_as_errno();
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	/* Copy the returned data to the user's buffer */
+	if (cmd->addr && cmd->data_len > 0) {
+		memcpy((void *)(uintptr_t)cmd->addr,
+			(char *)protocol_data + protocol_data->ProtocolDataOffset,
+			min(protocol_data->ProtocolDataLength, cmd->data_len));
+	}
+
+	/* Only 32-bits of return data. Assuming CQE DW0. */
+	cmd->result = protocol_data->FixedProtocolReturnData;
+
+out_free_buffer:
+	free(buffer);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+static int nvme_submit_admin_set_features(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	PSTORAGE_PROPERTY_SET set_property = NULL;
+	PSTORAGE_PROTOCOL_SPECIFIC_DATA_EXT protocol_data = NULL;
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	PUCHAR buffer = NULL;
+	void *user_data;
+	int err = 0;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	buffer_len = FIELD_OFFSET(STORAGE_PROPERTY_SET, AdditionalParameters) +
+		sizeof(STORAGE_PROTOCOL_SPECIFIC_DATA_EXT) + cmd->data_len;
+
+	buffer = (PUCHAR)malloc(buffer_len);
+	if (!buffer) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(buffer, buffer_len);
+
+	set_property = (PSTORAGE_PROPERTY_SET)buffer;
+	protocol_data = (PSTORAGE_PROTOCOL_SPECIFIC_DATA_EXT)set_property->AdditionalParameters;
+
+	set_property->PropertyId = StorageAdapterProtocolSpecificProperty;
+	set_property->SetType = PropertyStandardSet;
+
+	protocol_data->ProtocolType = ProtocolTypeNvme;
+	protocol_data->DataType = NVMeDataTypeFeature;
+
+	/*
+	 * Map NVMe Set Features command DWORDs to protocol data fields.
+	 * STORAGE_PROTOCOL_SPECIFIC_DATA_EXT values for NVMeDataTypeFeature
+	 * are documented in the STORAGE_PROTOCOL_NVME_DATA_TYPE enumeration.
+	 */
+	protocol_data->ProtocolDataValue = cmd->cdw10;
+	protocol_data->ProtocolDataSubValue = cmd->cdw11;
+	protocol_data->ProtocolDataSubValue2 = cmd->cdw12;
+	protocol_data->ProtocolDataSubValue3 = cmd->cdw13;
+	protocol_data->ProtocolDataSubValue4 = cmd->cdw14;
+	protocol_data->ProtocolDataSubValue5 = cmd->cdw15;
+
+	protocol_data->ProtocolDataOffset = sizeof(STORAGE_PROTOCOL_SPECIFIC_DATA_EXT);
+	protocol_data->ProtocolDataLength = cmd->data_len;
+
+	/* Copy input data if present */
+	if (cmd->addr && cmd->data_len > 0) {
+		memcpy((PUCHAR)protocol_data + protocol_data->ProtocolDataOffset,
+			(void *)(uintptr_t)cmd->addr,
+			cmd->data_len);
+	}
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+					IOCTL_STORAGE_SET_PROPERTY,
+					buffer,
+					buffer_len,
+					buffer,
+					buffer_len,
+					&returned_len,
+					NULL);
+		if (result)
+			break;
+		err = get_last_error_as_errno();
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	/* Only 32-bits of return data. Assuming CQE DW0. */
+	cmd->result = protocol_data->FixedProtocolReturnData;
+
+out_free_buffer:
+	free(buffer);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+static int nvme_submit_admin_get_features(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	PSTORAGE_PROPERTY_QUERY query = NULL;
+	PSTORAGE_PROTOCOL_SPECIFIC_DATA protocol_data = NULL;
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	PUCHAR buffer = NULL;
+	void *user_data;
+	int err = 0;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	buffer_len = FIELD_OFFSET(STORAGE_PROPERTY_QUERY, AdditionalParameters) +
+		sizeof(STORAGE_PROTOCOL_SPECIFIC_DATA) + cmd->data_len;
+
+	buffer = (PUCHAR)malloc(buffer_len);
+	if (!buffer) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(buffer, buffer_len);
+
+	query = (PSTORAGE_PROPERTY_QUERY)buffer;
+	protocol_data = (PSTORAGE_PROTOCOL_SPECIFIC_DATA)query->AdditionalParameters;
+
+	query->PropertyId = StorageAdapterProtocolSpecificProperty;
+	query->QueryType = PropertyStandardQuery;
+
+	protocol_data->ProtocolType = ProtocolTypeNvme;
+	protocol_data->DataType = NVMeDataTypeFeature;
+
+	/*
+	 * Map NVMe Get Features command DWORDs to protocol data fields.
+	 * STORAGE_PROTOCOL_SPECIFIC_DATA values for Get Features are documented
+	 * in the STORAGE_PROTOCOL_NVME_DATA_TYPE enumeration documentation.
+	 */
+	protocol_data->ProtocolDataRequestValue = cmd->cdw10;
+	protocol_data->ProtocolDataRequestSubValue = cmd->cdw11;
+	protocol_data->ProtocolDataRequestSubValue2 = cmd->cdw12;
+	protocol_data->ProtocolDataRequestSubValue3 = cmd->cdw13;
+	protocol_data->ProtocolDataRequestSubValue4 = cmd->cdw14;
+
+	protocol_data->ProtocolDataOffset = sizeof(STORAGE_PROTOCOL_SPECIFIC_DATA);
+	protocol_data->ProtocolDataLength = cmd->data_len;
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+					IOCTL_STORAGE_QUERY_PROPERTY,
+					buffer,
+					buffer_len,
+					buffer,
+					buffer_len,
+					&returned_len,
+					NULL);
+		if (result)
+			break;
+		err = get_last_error_as_errno();
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	/* Copy the returned data to the user's buffer if present */
+	if (cmd->addr && cmd->data_len > 0) {
+		memcpy((void *)(uintptr_t)cmd->addr,
+			(PUCHAR)protocol_data + protocol_data->ProtocolDataOffset,
+			min(protocol_data->ProtocolDataLength, cmd->data_len));
+	}
+
+	/* Only 32-bits of return data. Assuming CQE DW0. */
+	cmd->result = protocol_data->FixedProtocolReturnData;
+
+out_free_buffer:
+	free(buffer);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+#ifndef STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER
+
+/*
+ * Definitions for values and types not yet included in mingw's winioctl.h.
+ * Values found in the 10.0.26100.0 Windows SDK winioctl.h.
+ */
+
+#define STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER    0x00000001
+
+/* Activate the existing firmware immediately without controller reset. */
+#define STORAGE_HW_FIRMWARE_REQUEST_FLAG_SWITCH_TO_FIRMWARE_WITHOUT_RESET 0x10000000
+/* Replace existing firmware and activate with controller reset. */
+#define STORAGE_HW_FIRMWARE_REQUEST_FLAG_REPLACE_AND_SWITCH_UPON_RESET 0x20000000
+/* Replace the existing firmware. Not activated. */
+#define STORAGE_HW_FIRMWARE_REQUEST_FLAG_REPLACE_EXISTING_IMAGE      0x40000000
+/* Activate the existing firmware with a controller reset. */
+#define STORAGE_HW_FIRMWARE_REQUEST_FLAG_SWITCH_TO_EXISTING_FIRMWARE 0x80000000
+
+typedef struct _STORAGE_HW_FIRMWARE_ACTIVATE {
+	DWORD   Version;
+	DWORD   Size;
+
+	DWORD   Flags;
+	BYTE    Slot;
+	BYTE    Reserved0[3];
+} STORAGE_HW_FIRMWARE_ACTIVATE, *PSTORAGE_HW_FIRMWARE_ACTIVATE;
+
+typedef struct _STORAGE_HW_FIRMWARE_DOWNLOAD {
+	DWORD       Version;
+	DWORD       Size;
+
+	DWORD       Flags;
+	BYTE        Slot;
+	BYTE        Reserved[3];
+
+	DWORDLONG   Offset;
+	DWORDLONG   BufferSize;
+
+	BYTE        ImageBuffer[ANYSIZE_ARRAY];
+} STORAGE_HW_FIRMWARE_DOWNLOAD, *PSTORAGE_HW_FIRMWARE_DOWNLOAD;
+
+#endif
+
+static int nvme_submit_admin_fw_commit(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	PSTORAGE_HW_FIRMWARE_ACTIVATE firmware_activate = NULL;
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	__u8 commit_action;
+	void *user_data;
+	int err = 0;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	buffer_len = sizeof(STORAGE_HW_FIRMWARE_ACTIVATE);
+
+	firmware_activate = (PSTORAGE_HW_FIRMWARE_ACTIVATE)malloc(buffer_len);
+	if (!firmware_activate) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(firmware_activate, buffer_len);
+
+	firmware_activate->Version = sizeof(STORAGE_HW_FIRMWARE_ACTIVATE);
+	firmware_activate->Size = sizeof(STORAGE_HW_FIRMWARE_ACTIVATE);
+	firmware_activate->Slot = NVME_FIELD_DECODE(cmd->cdw10,
+			NVME_FW_COMMIT_CDW10_FS_SHIFT,
+			NVME_FW_COMMIT_CDW10_FS_MASK);
+
+	/* For NVMe devices, the target is the controller */
+	firmware_activate->Flags = STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER;
+
+	/* Set additional flags based on the commit action */
+	commit_action = NVME_FIELD_DECODE(cmd->cdw10,
+		NVME_FW_COMMIT_CDW10_CA_SHIFT,
+		NVME_FW_COMMIT_CDW10_CA_MASK);
+
+	switch (commit_action) {
+	case 0: /* Replace, no activate */
+		firmware_activate->Flags |=
+			STORAGE_HW_FIRMWARE_REQUEST_FLAG_REPLACE_EXISTING_IMAGE;
+		break;
+	case 1: /* Replace and activate at next reset */
+		firmware_activate->Flags |=
+			STORAGE_HW_FIRMWARE_REQUEST_FLAG_REPLACE_AND_SWITCH_UPON_RESET;
+		break;
+	case 2: /* Activate the current firmware at next reset */
+		firmware_activate->Flags |=
+			STORAGE_HW_FIRMWARE_REQUEST_FLAG_SWITCH_TO_EXISTING_FIRMWARE;
+		break;
+	case 3: /* Activate the current firmware immediately without reset */
+		firmware_activate->Flags |=
+			STORAGE_HW_FIRMWARE_REQUEST_FLAG_SWITCH_TO_FIRMWARE_WITHOUT_RESET;
+		break;
+	}
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+					IOCTL_STORAGE_FIRMWARE_ACTIVATE,
+					firmware_activate,
+					buffer_len,
+					NULL,
+					0,
+					&returned_len,
+					NULL);
+		if (result)
+			break;
+		err = get_last_error_as_errno();
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	/* FW Commit doesn't return result data */
+	cmd->result = 0;
+
+out_free_buffer:
+	free(firmware_activate);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+static int nvme_submit_admin_fw_download(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	PSTORAGE_HW_FIRMWARE_DOWNLOAD firmware_download = NULL;
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	PUCHAR buffer = NULL;
+	void *user_data;
+	int err = 0;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	/*
+	 * Allocate buffer for STORAGE_HW_FIRMWARE_DOWNLOAD structure.
+	 * The structure contains the firmware image data inline at the end.
+	 */
+	buffer_len = FIELD_OFFSET(STORAGE_HW_FIRMWARE_DOWNLOAD, ImageBuffer)
+			+ cmd->data_len;
+
+	buffer = (PUCHAR)malloc(buffer_len);
+	if (!buffer) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(buffer, buffer_len);
+
+	firmware_download = (PSTORAGE_HW_FIRMWARE_DOWNLOAD)buffer;
+	firmware_download->Version = sizeof(STORAGE_HW_FIRMWARE_DOWNLOAD);
+	firmware_download->Size = buffer_len;
+	/*
+	 * TODO: Determine whether DWORD alignment or byte alignment is required.
+	 * Windows comments for BufferSize and Offset in winioctl.h
+	 * state that they should be aligned to the "ImagePayloadAlignment"
+	 * value from STORAGE_FIRMWARE_INFO.
+	 * Do we need to issue an IOCTL_STORAGE_FIRMWARE_GET_INFO to get
+	 * the alignment, or will it always be the same for NVMe devices?
+	 * NOTE: swworkbench uses byte alignment for Buffer size and CDW11
+	 * for offset, which should be DWORD aligned. That doesn't seem correct.
+	 * For now, we assume DWORD alignment since that is what is set in
+	 * CDW10 and CDW11 (see ioctl.h/nvme_init_fw_download).
+	 */
+	firmware_download->BufferSize = cmd->cdw10;	/* Length in DWORDS */
+	firmware_download->Offset = cmd->cdw11;		/* Offset in DWORDS */
+	/*
+	 * Assuming we need the CONTROLLER flag.
+	 * TODO: Do we need to set the
+	 * STORAGE_HW_FIRMWARE_REQUEST_FLAG_LAST_SEGMENT flag?
+	 * If so, we will need a way to communicate in the cmd struct
+	 * whether this is the last segment.
+	 */
+	firmware_download->Flags = STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER;
+	/*
+	 * Assuming that slot is not used for NVMe devices since it is not
+	 * part of the NVMe FW Download command. Setting to 0.
+	 * If needed, we will need a way to communicate it in the cmd struct.
+	 * If not needed, just remove this setting completely.
+	 */
+	firmware_download->Slot = 0;
+
+	if (cmd->addr && cmd->data_len > 0) {
+		memcpy(firmware_download->ImageBuffer,
+			(void *)(uintptr_t)cmd->addr,
+			cmd->data_len);
+	}
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+					IOCTL_STORAGE_FIRMWARE_DOWNLOAD,
+					buffer,
+					buffer_len,
+					NULL,
+					0,
+					&returned_len,
+					NULL);
+		if (result)
+			break;
+		err = get_last_error_as_errno();
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	/* Firmware download doesn't return result data */
+	cmd->result = 0;
+
+out_free_buffer:
+	free(buffer);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+/* SCSI operation code for sanitize command - from ddk/scsi.h */
+#define SCSIOP_SANITIZE 0x48
+
+static int nvme_submit_admin_format_nvm_user_data_erase(
+		struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	/*
+	 * User Data Erase: Use IOCTL_SCSI_PASS_THROUGH with SCSIOP_SANITIZE
+	 * to erase user data. The sanitize operation erases all user data,
+	 * with the contents being indeterminate after erase.
+	 */
+	PSCSI_PASS_THROUGH pass_through = NULL;
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	PUCHAR buffer = NULL;
+	void *user_data;
+	int err = 0;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	/* Allocate buffer for SCSI_PASS_THROUGH */
+	buffer_len = sizeof(SCSI_PASS_THROUGH);
+	buffer = (PUCHAR)malloc(buffer_len);
+	if (!buffer) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(buffer, buffer_len);
+
+	pass_through = (PSCSI_PASS_THROUGH)buffer;
+	pass_through->Length = sizeof(SCSI_PASS_THROUGH);
+	pass_through->CdbLength = 6;
+	pass_through->DataIn = SCSI_IOCTL_DATA_UNSPECIFIED;
+	pass_through->DataTransferLength = 0;
+	pass_through->TimeOutValue = (cmd->timeout_ms > 0) ?
+		((cmd->timeout_ms + 999) / 1000) : 300;
+	pass_through->DataBufferOffset = 0;
+
+	/*
+	 * Build the Sanitize CDB (6 bytes)
+	 * Byte 0: Operation code (0x48)
+	 * Byte 1: Service Action + Immediate bit
+	 *   Bits 7-5: Reserved
+	 *   Bits 4-3: Service action
+	 *     00 = Block Erase
+	 *     01 = Crypto Scramble
+	 *     10 = Overwrite
+	 *   Bit 2: Ancillary (reserved)
+	 *   Bit 1: IMMED (Immediate)
+	 *   Bit 0: Reserved
+	 * Bytes 2-5: Reserved
+	 *
+	 * For NVMe User Data Erase, use Block Erase (service action 00)
+	 */
+	pass_through->Cdb[0] = SCSIOP_SANITIZE;
+	pass_through->Cdb[1] = 0x00; /* Block Erase, non-immediate */
+	pass_through->Cdb[2] = 0;    /* Reserved */
+	pass_through->Cdb[3] = 0;    /* Reserved */
+	pass_through->Cdb[4] = 0;    /* Reserved */
+	pass_through->Cdb[5] = 0;    /* Reserved */
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+				IOCTL_SCSI_PASS_THROUGH,
+				buffer,
+				buffer_len,
+				buffer,
+				buffer_len,
+				&returned_len,
+				NULL);
+		if (result)
+			break;
+
+		if (!result)
+			err = get_last_error_as_errno();
+		else
+			err = -EIO;
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	cmd->result = 0;
+
+out_free_buffer:
+	free(buffer);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+static int nvme_submit_admin_format_nvm_crypto_erase(
+		struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	BOOL result = FALSE;
+	ULONG returned_len = 0;
+	void *user_data;
+	int err = 0;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+				IOCTL_STORAGE_REINITIALIZE_MEDIA,
+				NULL,
+				0,
+				NULL,
+				0,
+				&returned_len,
+				NULL);
+		if (result)
+			break;
+		err = get_last_error_as_errno();
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	cmd->result = 0;
+
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+static int nvme_submit_admin_format_nvm(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	__u8 ses;
+
+	/* Namespace-specific format is not supported on Windows */
+	if (cmd->nsid != NVME_NSID_ALL)
+		return -ENOTSUP;
+
+	/*
+	 * Extract the Secure Erase Settings (SES) from CDW10 and call the
+	 * appropriate implementation based on the requested erase type.
+	 */
+	ses = NVME_FIELD_DECODE(cmd->cdw10,
+			NVME_FORMAT_CDW10_SES_SHIFT,
+			NVME_FORMAT_CDW10_SES_MASK);
+
+	/*
+	 * Per Microsoft StorNVMe documentation:
+	 * - SES=0 (No Erase): Not supported on Windows
+	 * - SES=1 (User Data Erase): Use IOCTL_SCSI_PASS_THROUGH with SANITIZE
+	 * - SES=2 (Cryptographic Erase): Use IOCTL_STORAGE_REINITIALIZE_MEDIA
+	 */
+	switch (ses) {
+	case NVME_FORMAT_SES_NONE:
+		return -ENOTSUP;	/* Not supported on Windows */
+	case NVME_FORMAT_SES_USER_DATA_ERASE:
+		return nvme_submit_admin_format_nvm_user_data_erase(hdl, cmd);
+	case NVME_FORMAT_SES_CRYPTO_ERASE:
+		return nvme_submit_admin_format_nvm_crypto_erase(hdl, cmd);
+	default:
+		return -EINVAL;
+	}
+}
+
+/* SCSI operation codes for security commands - from ddk/scsi.h */
+#define SCSIOP_SECURITY_PROTOCOL_IN      0xA2
+#define SCSIOP_SECURITY_PROTOCOL_OUT     0xB5
+
+static int nvme_submit_admin_security_send_receive(
+		struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	PSCSI_PASS_THROUGH pass_through = NULL;
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	PUCHAR buffer = NULL;
+	void *user_data;
+	int err = 0;
+	bool is_send = (cmd->opcode == nvme_admin_security_send);
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	/* Allocate buffer for SCSI_PASS_THROUGH + data */
+	buffer_len = sizeof(SCSI_PASS_THROUGH) + cmd->data_len;
+	buffer = (PUCHAR)malloc(buffer_len);
+	if (!buffer) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(buffer, buffer_len);
+
+	pass_through = (PSCSI_PASS_THROUGH)buffer;
+	pass_through->Length = sizeof(SCSI_PASS_THROUGH);
+	pass_through->CdbLength = 12;
+	pass_through->DataIn = is_send ? SCSI_IOCTL_DATA_OUT : SCSI_IOCTL_DATA_IN;
+	pass_through->DataTransferLength = cmd->data_len;
+	pass_through->TimeOutValue = (cmd->timeout_ms > 0) ?
+		((cmd->timeout_ms + 999) / 1000) : 30;
+	pass_through->DataBufferOffset = sizeof(SCSI_PASS_THROUGH);
+
+	if (is_send && cmd->data_len > 0) {
+		memcpy(buffer + pass_through->DataBufferOffset,
+			(void *)(uintptr_t)cmd->addr, cmd->data_len);
+	}
+
+	/*
+	 * Build the Security Protocol CDB (12 bytes)
+	 * Per SPC-4: Security Protocol In/Out CDB is 12 bytes:
+	 * Byte 0: Operation code (0xA2/0xB5)
+	 * Byte 1: Security Protocol (SECP)
+	 * Byte 2-3: Security Protocol Specific (SPSP)
+	 * Byte 4: Reserved
+	 * Byte 5: NSSF (NVMe Security Specific Field)
+	 * Byte 6-9: Allocation Length (big-endian)
+	 * Byte 10-11: Reserved
+	 */
+	pass_through->Cdb[0] = is_send ?
+		SCSIOP_SECURITY_PROTOCOL_OUT : SCSIOP_SECURITY_PROTOCOL_IN;
+	pass_through->Cdb[1] = NVME_FIELD_DECODE(cmd->cdw10,
+			NVME_SECURITY_SECP_SHIFT,
+			NVME_SECURITY_SECP_MASK);
+	pass_through->Cdb[2] = NVME_FIELD_DECODE(cmd->cdw10,
+			NVME_SECURITY_SPSP1_SHIFT,
+			NVME_SECURITY_SPSP1_MASK);
+	pass_through->Cdb[3] = NVME_FIELD_DECODE(cmd->cdw10,
+			NVME_SECURITY_SPSP0_SHIFT,
+			NVME_SECURITY_SPSP0_MASK);
+	pass_through->Cdb[4] = 0;  /* Reserved */
+	pass_through->Cdb[5] = NVME_FIELD_DECODE(cmd->cdw10,
+			NVME_SECURITY_NSSF_SHIFT,
+			NVME_SECURITY_NSSF_MASK);
+	/* Transfer/Allocation length (CDW11) in big-endian */
+	pass_through->Cdb[6] = (cmd->cdw11 >> 24) & 0xFF;
+	pass_through->Cdb[7] = (cmd->cdw11 >> 16) & 0xFF;
+	pass_through->Cdb[8] = (cmd->cdw11 >> 8) & 0xFF;
+	pass_through->Cdb[9] = cmd->cdw11 & 0xFF;
+	pass_through->Cdb[10] = 0; /* Reserved */
+	pass_through->Cdb[11] = 0; /* Reserved */
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+				IOCTL_SCSI_PASS_THROUGH,
+				buffer,
+				buffer_len,
+				buffer,
+				buffer_len,
+				&returned_len,
+				NULL);
+		if (result && !pass_through->ScsiStatus)
+			break;
+
+		if (!result)
+			err = get_last_error_as_errno();
+		else
+			err = -EIO;
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	/* Copy returned data to user buffer if this was a receive */
+	if (!is_send && cmd->addr && cmd->data_len > 0) {
+		memcpy((void *)(uintptr_t)cmd->addr,
+			buffer + pass_through->DataBufferOffset,
+			pass_through->DataTransferLength);
+		cmd->data_len = pass_through->DataTransferLength;
+	}
+
+	/* No result data returned by command. */
+	cmd->result = 0;
+
+out_free_buffer:
+	free(buffer);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+/*
+ * Windows only supports a subset of NVMe admin command calls from user space
+ * and uses different IOCTLs for different commands instead of a single
+ * passthru interface.
+ * Passthru is supported using IOCTL_STORAGE_PROTOCOL_COMMAND,
+ * but only for VU commands and a small subset of admin commands.
+ * For supported commands and a mapping to the required IOCTLs, see:
+ * https://learn.microsoft.com/en-us/windows-hardware/drivers/storage/stornvme-command-set-support
+ */
+int nvme_submit_admin_passthru(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	if (!hdl || !cmd)
+		return -EINVAL;
+
+	if (hdl->type != NVME_TRANSPORT_HANDLE_TYPE_DIRECT)
+		return -ENOTSUP;
+
+	/* VU commands */
+	if (cmd->opcode >= 0xC0 && cmd->opcode <= 0xFF)
+		return nvme_submit_storage_protocol_command(hdl, cmd);
+
+	switch (cmd->opcode) {
+	case nvme_admin_get_log_page:
+		return nvme_submit_admin_get_log_page(hdl, cmd);
+	case nvme_admin_identify:
+		return nvme_submit_admin_identify(hdl, cmd);
+	case nvme_admin_set_features:
+		return nvme_submit_admin_set_features(hdl, cmd);
+	case nvme_admin_get_features:
+		return nvme_submit_admin_get_features(hdl, cmd);
+	case nvme_admin_fw_commit:
+		return nvme_submit_admin_fw_commit(hdl, cmd);
+	case nvme_admin_fw_download:
+		return nvme_submit_admin_fw_download(hdl, cmd);
+	case nvme_admin_dev_self_test:
+		return nvme_submit_storage_protocol_command(hdl, cmd);
+	case nvme_admin_format_nvm:
+		return nvme_submit_admin_format_nvm(hdl, cmd);
+	case nvme_admin_security_send:
+	case nvme_admin_security_recv:
+		return nvme_submit_admin_security_send_receive(hdl, cmd);
+	case nvme_admin_sanitize_nvm:
+		return nvme_submit_storage_protocol_command(hdl, cmd);
+	default:
+		return -ENOTSUP;
+	}
+}
diff --git a/libnvme/src/nvme/ioctl.c b/libnvme/src/nvme/ioctl.c
index 353c9fc3cd..f36f6f052a 100644
--- a/libnvme/src/nvme/ioctl.c
+++ b/libnvme/src/nvme/ioctl.c
@@ -24,6 +24,7 @@
 #include "ioctl.h"
 #include "private.h"
 
+#ifndef _WIN32
 static int nvme_verify_chr(struct nvme_transport_handle *hdl)
 {
 	static struct stat nvme_stat;
@@ -91,6 +92,7 @@ int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
 	*nsid = tmp;
 	return 0;
 }
+#endif
 
 void *__nvme_submit_entry(struct nvme_transport_handle *hdl,
 		struct nvme_passthru_cmd *cmd)
@@ -109,6 +111,7 @@ bool __nvme_decide_retry(struct nvme_transport_handle *hdl,
 	return false;
 }
 
+#ifndef _WIN32
 /*
  * The 64 bit version is the preferred version to use, but for backwards
  * compatibility keep a 32 version.
@@ -198,6 +201,7 @@ int nvme_submit_admin_passthru(struct nvme_transport_handle *hdl,
 
 	return -ENOTSUP;
 }
+#endif
 
 static bool force_4k;
 

From 5f5ccd541ad5d9649c58cb39be7c648d9c0b8fee Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Thu, 12 Feb 2026 13:23:56 -0700
Subject: [PATCH 23/83] windows nvme: Updated BufferSize and Offset to use byte
 counts. (#55)

After further research and experimentation, it looks like BufferSize
and Offset need to be byte counts.  Alignment refers to the buffer
alignment in memory.
Experimentation shows that 4K alignment is required.
Evaluation of the code shows that this buffer alignment is already
handled by the code creating the firmware buffer.
---
 libnvme/src/nvme/ioctl-windows.c | 35 +++++++++++++++-----------------
 1 file changed, 16 insertions(+), 19 deletions(-)

diff --git a/libnvme/src/nvme/ioctl-windows.c b/libnvme/src/nvme/ioctl-windows.c
index d23e2aacbb..8da517729e 100644
--- a/libnvme/src/nvme/ioctl-windows.c
+++ b/libnvme/src/nvme/ioctl-windows.c
@@ -173,7 +173,7 @@ static int nvme_submit_storage_protocol_command(
 	protocol_command->CommandLength = STORAGE_PROTOCOL_COMMAND_LENGTH_NVME;
 	protocol_command->ErrorInfoLength = 0;
 	protocol_command->TimeOutValue = (cmd->timeout_ms > 0) ?
-		((cmd->timeout_ms + 999) / 1000) : 10; // Round up to seconds
+		((cmd->timeout_ms + 999) / 1000) : 10; /* Round up to seconds */
 
 	protocol_command->CommandSpecific =
 		STORAGE_PROTOCOL_SPECIFIC_NVME_ADMIN_COMMAND;
@@ -410,8 +410,10 @@ static int nvme_submit_admin_identify(struct nvme_transport_handle *hdl,
 	query = (PSTORAGE_PROPERTY_QUERY)buffer;
 	protocol_data = (PSTORAGE_PROTOCOL_SPECIFIC_DATA)query->AdditionalParameters;
 
-	// NOTE: If testing fails with Identify Specific Namespace, try
-	// StorageDeviceProtocolSpecificProperty for that cns.
+	/*
+	 * NOTE: If testing fails with Identify Specific Namespace, try
+	 * StorageDeviceProtocolSpecificProperty for that cns.
+	 */
 	query->PropertyId = StorageAdapterProtocolSpecificProperty;
 
 	protocol_data->ProtocolType = ProtocolTypeNvme;
@@ -810,33 +812,28 @@ static int nvme_submit_admin_fw_download(struct nvme_transport_handle *hdl,
 	firmware_download = (PSTORAGE_HW_FIRMWARE_DOWNLOAD)buffer;
 	firmware_download->Version = sizeof(STORAGE_HW_FIRMWARE_DOWNLOAD);
 	firmware_download->Size = buffer_len;
+
 	/*
-	 * TODO: Determine whether DWORD alignment or byte alignment is required.
-	 * Windows comments for BufferSize and Offset in winioctl.h
-	 * state that they should be aligned to the "ImagePayloadAlignment"
-	 * value from STORAGE_FIRMWARE_INFO.
-	 * Do we need to issue an IOCTL_STORAGE_FIRMWARE_GET_INFO to get
-	 * the alignment, or will it always be the same for NVMe devices?
-	 * NOTE: swworkbench uses byte alignment for Buffer size and CDW11
-	 * for offset, which should be DWORD aligned. That doesn't seem correct.
-	 * For now, we assume DWORD alignment since that is what is set in
-	 * CDW10 and CDW11 (see ioctl.h/nvme_init_fw_download).
+	 * The NVMe command uses DWORD counts for size and offset.
+	 * The Windows API uses byte counts, so convert accordingly.
+	 * See ioctl.h/nvme_init_fw_download for encoding details.
 	 */
-	firmware_download->BufferSize = cmd->cdw10;	/* Length in DWORDS */
-	firmware_download->Offset = cmd->cdw11;		/* Offset in DWORDS */
+	firmware_download->BufferSize = (DWORDLONG)(cmd->cdw10 + 1) << 2;
+	firmware_download->Offset = (DWORDLONG)cmd->cdw11 << 2;
+
 	/*
 	 * Assuming we need the CONTROLLER flag.
-	 * TODO: Do we need to set the
-	 * STORAGE_HW_FIRMWARE_REQUEST_FLAG_LAST_SEGMENT flag?
+	 * TODO: Do we need to use the LAST_SEGMENT flag?
 	 * If so, we will need a way to communicate in the cmd struct
 	 * whether this is the last segment.
 	 */
 	firmware_download->Flags = STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER;
+
 	/*
 	 * Assuming that slot is not used for NVMe devices since it is not
 	 * part of the NVMe FW Download command. Setting to 0.
-	 * If needed, we will need a way to communicate it in the cmd struct.
-	 * If not needed, just remove this setting completely.
+	 * TODO: If needed, we will need a way to communicate it in the
+	 * cmd struct. If not needed, just remove this setting completely.
 	 */
 	firmware_download->Slot = 0;
 

From 97a39366dbd561f4b9dd1bf92b3308fd3024faaa Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 13 Feb 2026 10:25:57 -0700
Subject: [PATCH 24/83] Merge master into mingw

---
 libnvme/src/nvme/private.h            | 15 ++++++
 libnvme/src/nvme/tree.c               | 41 ++++++---------
 libnvme/src/nvme/util.c               | 12 +++++
 plugins/solidigm/solidigm-telemetry.c | 75 +++++++++++++--------------
 4 files changed, 79 insertions(+), 64 deletions(-)

diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index 22a728fc17..dc34787da9 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -271,6 +271,7 @@ struct nvme_global_ctx {
 	bool create_only;
 	bool dry_run;
 	struct nvme_fabric_options *options;
+	struct ifaddrs *ifaddrs_cache; /* init with nvme_getifaddrs() */
 };
 
 struct nvmf_discovery_ctx {
@@ -550,4 +551,18 @@ static inline char *xstrdup(const char *s)
 	return strdup(s);
 }
 
+/**
+ * nvme_getifaddrs - Cached wrapper around getifaddrs()
+ * @ctx: pointer to the global context
+ *
+ * On the first call, this function invokes the POSIX getifaddrs()
+ * and caches the result in the global context. Subsequent calls
+ * return the cached data. The caller must NOT call freeifaddrs()
+ * on the returned data. The cache will be freed when the global
+ * context is freed.
+ *
+ * Return: Pointer to I/F data, NULL on error (with errno set).
+ */
+const struct ifaddrs *nvme_getifaddrs(struct nvme_global_ctx *ctx);
+
 #endif /* _LIBNVME_PRIVATE_H */
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index a7f64400f0..a7a43162d3 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -50,7 +50,7 @@ struct candidate_args {
 	const char *subsysnqn;
 	const char *host_traddr;
 	const char *host_iface;
-	struct ifaddrs *iface_list;
+	const struct ifaddrs *iface_list;
 	bool (*addreq)(const char *, const char *);
 	bool well_known_nqn;
 };
@@ -520,6 +520,9 @@ void nvme_free_global_ctx(struct nvme_global_ctx *ctx)
 	if (!ctx)
 		return;
 
+	freeifaddrs(ctx->ifaddrs_cache); /* NULL-safe */
+	ctx->ifaddrs_cache = NULL;
+
 	free(ctx->options);
 	nvme_for_each_host_safe(ctx, h, _h)
 		__nvme_free_host(h);
@@ -1751,7 +1754,8 @@ static bool _match_ctrl(struct nvme_ctrl *c, struct candidate_args *candidate)
  * Return: The matching function to use when comparing an existing
  * controller to the candidate controller.
  */
-static ctrl_match_t _candidate_init(struct candidate_args *candidate,
+static ctrl_match_t _candidate_init(struct nvme_global_ctx *ctx,
+				    struct candidate_args *candidate,
 				    const char *transport,
 				    const char *traddr,
 				    const char *trsvcid,
@@ -1781,12 +1785,7 @@ static ctrl_match_t _candidate_init(struct candidate_args *candidate,
 	}
 
 	if (streq0(transport, "tcp")) {
-		/* For TCP we may need to access the interface map.
-		 * Let's retrieve and cache the map.
-		 */
-		if (getifaddrs(&candidate->iface_list) == -1)
-			candidate->iface_list = NULL;
-
+		candidate->iface_list = nvme_getifaddrs(ctx); /* TCP only */
 		candidate->addreq = nvme_ipaddrs_eq;
 		return _tcp_match_ctrl;
 	}
@@ -1801,30 +1800,19 @@ static ctrl_match_t _candidate_init(struct candidate_args *candidate,
 	return _match_ctrl;
 }
 
-/**
- * _candidate_free() - Release resources allocated by _candidate_init()
- *
- * @candidate:	data to free.
- */
-static void _candidate_free(struct candidate_args *candidate)
-{
-	freeifaddrs(candidate->iface_list); /* This is NULL-safe */
-}
-
-#define _cleanup_candidate_ __cleanup__(_candidate_free)
-
 nvme_ctrl_t __nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport,
 			       const char *traddr, const char *host_traddr,
 			       const char *host_iface, const char *trsvcid,
 			       const char *subsysnqn, nvme_ctrl_t p)
 {
-	_cleanup_candidate_ struct candidate_args candidate = {};
+	struct candidate_args candidate = {};
 	struct nvme_ctrl *c, *matching_c = NULL;
 	ctrl_match_t ctrl_match;
 
 	/* Init candidate and get the matching function to use */
-	ctrl_match = _candidate_init(&candidate, transport, traddr, trsvcid,
-				     subsysnqn, host_traddr, host_iface);
+	ctrl_match = _candidate_init(s->h->ctx, &candidate, transport, traddr,
+				     trsvcid, subsysnqn, host_traddr,
+				     host_iface);
 
 	c = p ? nvme_subsystem_next_ctrl(s, p) : nvme_subsystem_first_ctrl(s);
 	for (; c != NULL; c = nvme_subsystem_next_ctrl(s, c)) {
@@ -1842,12 +1830,13 @@ bool nvme_ctrl_config_match(struct nvme_ctrl *c, const char *transport,
 			    const char *subsysnqn, const char *host_traddr,
 			    const char *host_iface)
 {
-	_cleanup_candidate_ struct candidate_args candidate = {};
+	struct candidate_args candidate = {};
 	ctrl_match_t ctrl_match;
 
 	/* Init candidate and get the matching function to use */
-	ctrl_match = _candidate_init(&candidate, transport, traddr, trsvcid,
-				     subsysnqn, host_traddr, host_iface);
+	ctrl_match = _candidate_init(c->ctx, &candidate, transport, traddr,
+				     trsvcid, subsysnqn, host_traddr,
+				     host_iface);
 
 	return ctrl_match(c, &candidate);
 }
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 602995b8c8..6123cb08fe 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -1158,3 +1158,15 @@ void *__nvme_realloc(void *p, size_t len)
 
 	return result;
 }
+
+const struct ifaddrs *nvme_getifaddrs(struct nvme_global_ctx *ctx)
+{
+	if (!ctx->ifaddrs_cache) {
+		struct ifaddrs *p;
+
+		if (!getifaddrs(&p))
+			ctx->ifaddrs_cache = p;
+	}
+
+	return ctx->ifaddrs_cache;
+}
diff --git a/plugins/solidigm/solidigm-telemetry.c b/plugins/solidigm/solidigm-telemetry.c
index 1925253389..53b468043b 100644
--- a/plugins/solidigm/solidigm-telemetry.c
+++ b/plugins/solidigm/solidigm-telemetry.c
@@ -49,7 +49,7 @@ static int read_file2buffer(char *file_name, char **buffer, size_t *length)
 struct config {
 	__u32 host_gen;
 	bool ctrl_init;
-	int  data_area;
+	__u8  data_area;
 	char *cfg_file;
 	char *binary_file;
 	char *jq_filter;
@@ -92,7 +92,7 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *acmd, stru
 	OPT_ARGS(opts) = {
 		OPT_UINT("host-generate",   'g', &cfg.host_gen,  hgen),
 		OPT_FLAG("controller-init", 'c', &cfg.ctrl_init, cgen),
-		OPT_UINT("data-area",       'd', &cfg.data_area, dgen),
+		OPT_BYTE("data-area",       'd', &cfg.data_area, dgen),
 		OPT_FILE("config-file",     'j', &cfg.cfg_file, cfile),
 		OPT_FILE("source-file",     's', &cfg.binary_file, sfile),
 		OPT_STR("jq-filter",        'q', &cfg.jq_filter, jqfilt),
@@ -103,14 +103,18 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *acmd, stru
 	int err = argconfig_parse(argc, argv, desc, opts);
 
 	if (err) {
-		nvme_show_status(err);
 		return err;
 	}
-
 	/* When not selected on the command line, get minimum data area required */
 	if (!argconfig_parse_seen(opts, "data-area"))
 		cfg.data_area = argconfig_parse_seen(opts, "config-file") ? 3 : 1;
 
+	if (cfg.data_area < 1 || cfg.data_area > 4) {
+		errno = EINVAL;
+		nvme_show_perror("data-area = '%d'", cfg.data_area);
+		return -errno;
+	}
+
 	has_binary_file = argconfig_parse_seen(opts, "source-file");
 	if (has_binary_file) {
 		// If a binary file is provided, we don't want to open a device.
@@ -118,42 +122,44 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *acmd, stru
 		// so that eventually all the nonoptions are at the end.
 		if (argc > optind) {
 			errno = EINVAL;
-			err = -errno;
-			nvme_show_status(err);
-			return err;
+			nvme_show_perror(
+			"Device path not allowed when using --source-file");
+			return -errno;
 		}
 		err = read_file2buffer(cfg.binary_file, (char **)&tlog, &tl.log_size);
 	} else {
 		err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	}
-	if (err) {
-		nvme_show_status(err);
-		return err;
+	if (err < 0) {
+		errno = -err;
+		nvme_show_perror("Error");
 	}
+	if (err)
+		return err;
 
 	if (cfg.host_gen > 1) {
-		SOLIDIGM_LOG_WARNING("Invalid host-generate value '%d'", cfg.host_gen);
-		err = -EINVAL;
-		nvme_show_status(err);
-		return err;
+		errno = EINVAL;
+		nvme_show_perror("host-generate = '%d'", cfg.host_gen);
+		return -errno;
 	}
 
 	if (argconfig_parse_seen(opts, "config-file")) {
 		_cleanup_free_ char *conf_str = NULL;
 		size_t length = 0;
+		enum json_tokener_error jerr;
 
 		err = read_file2buffer(cfg.cfg_file, &conf_str, &length);
 		if (err) {
-			nvme_show_status(err);
+			nvme_show_perror("config-file %s", cfg.cfg_file);
 			return err;
 		}
-		configuration = json_tokener_parse(conf_str);
+		configuration = json_tokener_parse_verbose(conf_str, &jerr);
 		if (!configuration) {
-			SOLIDIGM_LOG_WARNING(
-				"Failed to parse JSON configuration file %s",
-				cfg.cfg_file);
-			err = EINVAL;
-			return err;
+			nvme_show_error(
+				"Failed to parse JSON file %s: %s",
+					cfg.cfg_file,
+					json_tokener_error_desc(jerr));
+			return -EINVAL;
 		}
 		tl.configuration = configuration;
 	}
@@ -164,13 +170,8 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *acmd, stru
 		__u8 mdts = 0;
 
 		err = nvme_get_telemetry_max(hdl, NULL, &max_data_tx);
-		if (err < 0) {
-			SOLIDIGM_LOG_WARNING("identify_ctrl: %s",
-					     nvme_strerror(errno));
-			return err;
-		} else if (err > 0) {
-			nvme_show_status(err);
-			SOLIDIGM_LOG_WARNING("Failed to acquire identify ctrl %d!", err);
+		if (err) {
+			nvme_show_err("identify_ctrl", err);
 			return err;
 		}
 		power2 = max_data_tx / NVME_LOG_PAGE_PDU_SIZE;
@@ -181,13 +182,8 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *acmd, stru
 
 		err = sldgm_dynamic_telemetry(hdl, cfg.host_gen, cfg.ctrl_init, true,
 					      mdts, cfg.data_area, &tlog, &tl.log_size);
-		if (err < 0) {
-			SOLIDIGM_LOG_WARNING("get-telemetry-log: %s",
-					     nvme_strerror(errno));
-			return err;
-		} else if (err > 0) {
-			nvme_show_status(err);
-			SOLIDIGM_LOG_WARNING("Failed to acquire telemetry log %d!", err);
+		if (err) {
+			nvme_show_err("get-telemetry-log", err);
 			return err;
 		}
 	}
@@ -221,18 +217,21 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *acmd, stru
 					if (err != 0)
 						err = -EINVAL;
 				} else {
-					SOLIDIGM_LOG_WARNING(
+					errno = ENOENT;
+					nvme_show_perror(
 						"Failed to execute jq command");
 					err = -ENOENT;
 				}
 			} else {
-				SOLIDIGM_LOG_WARNING(
+				errno = EINVAL;
+				nvme_show_perror(
 					"jq filter entry '%s' is not a valid string",
 					cfg.jq_filter);
 				err = -EINVAL;
 			}
 		} else {
-			SOLIDIGM_LOG_WARNING(
+			errno = ENOENT;
+			nvme_show_perror(
 				"jq filter entry '%s' not found in configuration file",
 				cfg.jq_filter);
 			err = -ENOENT;

From 60612b1b65175318f77a13ae277ae625e9cc6b40 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 13 Feb 2026 10:27:28 -0700
Subject: [PATCH 25/83] Fix windows build issues from last merge.

---
 libnvme/src/nvme/util.c          | 2 ++
 libnvme/src/nvme/windows-stubs.c | 7 +++++++
 2 files changed, 9 insertions(+)

diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 6123cb08fe..e2965f2851 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -1159,6 +1159,7 @@ void *__nvme_realloc(void *p, size_t len)
 	return result;
 }
 
+#ifndef _WIN32
 const struct ifaddrs *nvme_getifaddrs(struct nvme_global_ctx *ctx)
 {
 	if (!ctx->ifaddrs_cache) {
@@ -1170,3 +1171,4 @@ const struct ifaddrs *nvme_getifaddrs(struct nvme_global_ctx *ctx)
 
 	return ctx->ifaddrs_cache;
 }
+#endif /* _WIN32 */
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 7ea84e42d2..9ff0d12c9c 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -886,6 +886,13 @@ bool nvme_transport_handle_is_direct(struct nvme_transport_handle *hdl)
 	return false;
 }
 
+bool nvme_transport_handle_is_mi(struct nvme_transport_handle *hdl)
+{
+	stub_log(__func__);
+	(void)hdl;
+	return false;
+}
+
 /* Controller property getters (tree.c) */
 const char *nvme_ctrl_get_cntlid(nvme_ctrl_t c)
 {

From 0d07d4d6828785921b850afd11991d344ee4c948 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Tue, 17 Feb 2026 12:41:48 -0700
Subject: [PATCH 26/83] Merge remote-tracking branch 'origin/master' into mingw

---
 .github/workflows/build.yml                   |   2 +-
 .github/workflows/coverage.yml                |   2 +-
 .github/workflows/coverity.yml                |  77 ++++++
 .github/workflows/libnvme-coverage.yml        |  26 --
 .github/workflows/libnvme-docs.yaml           |  25 --
 .readthedocs.yaml                             |  23 +-
 .../nvme-ocp-get-idle-wakeup-time.txt         |  59 +++++
 fabrics.c                                     |  91 +++----
 libnvme/.readthedocs.yaml                     |  17 ++
 libnvme/libnvme/nvme.i                        |   2 +-
 libnvme/src/libnvme.ld                        |   1 +
 libnvme/src/nvme/fabrics.c                    |  51 ++--
 libnvme/src/nvme/json.c                       |  18 +-
 libnvme/src/nvme/linux.c                      |  16 +-
 libnvme/src/nvme/linux.h                      |  12 +
 libnvme/src/nvme/private.h                    |   3 +-
 libnvme/src/nvme/tree.c                       |  23 +-
 libnvme/src/nvme/tree.h                       |   9 +-
 libnvme/test/config/config-dump.c             |   3 +-
 libnvme/test/config/psk-json.c                |   3 +-
 logging.c                                     |   4 +-
 nvme-print-json.c                             |   4 +-
 nvme-print.c                                  |   2 +-
 nvme-rpmb.c                                   |   6 +-
 nvme.c                                        | 198 +++++++--------
 nvme.h                                        |  35 ++-
 .../udev-rules/70-nvmf-autoconnect.rules.in   |   8 +-
 plugins/amzn/amzn-nvme.c                      |   7 +-
 plugins/dapustor/dapustor-nvme.c              |  15 +-
 plugins/dera/dera-nvme.c                      |   4 +-
 plugins/fdp/fdp.c                             |  71 ++----
 plugins/huawei/huawei-nvme.c                  |  14 +-
 plugins/ibm/ibm-nvme.c                        |  20 +-
 plugins/innogrit/innogrit-nvme.c              |   8 +-
 plugins/inspur/inspur-nvme.c                  |   2 +-
 plugins/intel/intel-nvme.c                    |  54 ++--
 plugins/lm/lm-nvme.c                          |  54 ++--
 plugins/memblaze/memblaze-nvme.c              |  70 ++----
 plugins/micron/micron-nvme.c                  | 142 +++++------
 plugins/nbft/nbft-plugin.c                    |  14 +-
 plugins/netapp/netapp-nvme.c                  |  40 +--
 plugins/ocp/ocp-clear-features.c              |  12 +-
 plugins/ocp/ocp-fw-activation-history.c       |  10 +-
 plugins/ocp/ocp-hardware-component-log.c      |   2 +-
 plugins/ocp/ocp-nvme.c                        | 203 ++++++++-------
 plugins/ocp/ocp-nvme.h                        |   3 +
 plugins/ocp/ocp-smart-extended-log.c          |  20 +-
 plugins/sandisk/sandisk-nvme.c                |  31 +--
 plugins/scaleflux/sfx-nvme.c                  |  76 +++---
 plugins/seagate/seagate-nvme.c                | 149 ++++-------
 plugins/shannon/shannon-nvme.c                |  18 +-
 .../solidigm/solidigm-garbage-collection.c    |  18 +-
 plugins/solidigm/solidigm-get-drive-info.c    |   8 +-
 plugins/solidigm/solidigm-internal-logs.c     |  10 +-
 plugins/solidigm/solidigm-latency-tracking.c  |  16 +-
 plugins/solidigm/solidigm-log-page-dir.c      |  13 +-
 plugins/solidigm/solidigm-market-log.c        |   7 +-
 plugins/solidigm/solidigm-ocp-version.c       |   4 +-
 plugins/solidigm/solidigm-smart.c             |  16 +-
 plugins/solidigm/solidigm-telemetry.c         |   7 +-
 plugins/solidigm/solidigm-temp-stats.c        |   6 +-
 plugins/solidigm/solidigm-workload-tracker.c  |  29 +--
 plugins/ssstc/ssstc-nvme.c                    |   6 +-
 plugins/toshiba/toshiba-nvme.c                |  16 +-
 plugins/transcend/transcend-nvme.c            |   8 +-
 plugins/virtium/virtium-nvme.c                |  10 +-
 plugins/wdc/wdc-nvme.c                        | 234 ++++++------------
 plugins/ymtc/ymtc-nvme.c                      |   6 +-
 plugins/zns/zns.c                             | 119 +++------
 scripts/build.sh                              |  30 ++-
 70 files changed, 999 insertions(+), 1323 deletions(-)
 create mode 100644 .github/workflows/coverity.yml
 delete mode 100644 .github/workflows/libnvme-coverage.yml
 delete mode 100644 .github/workflows/libnvme-docs.yaml
 create mode 100644 Documentation/nvme-ocp-get-idle-wakeup-time.txt
 create mode 100644 libnvme/.readthedocs.yaml

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index e3ad77062c..95b6c9b39f 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -67,7 +67,7 @@ jobs:
     steps:
       - uses: actions/checkout@v5
       - name: enable foreign arch
-        uses: dbhi/qus/action@main
+        uses: docker/setup-qemu-action@v3
       - name: Login to GitHub Container Registry
         uses: docker/login-action@v3
         with:
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index cdcde6d984..e45f3c4191 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -23,4 +23,4 @@ jobs:
       - uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-          fail_ci_if_error: true
+          fail_ci_if_error: false
diff --git a/.github/workflows/coverity.yml b/.github/workflows/coverity.yml
new file mode 100644
index 0000000000..7e596d0587
--- /dev/null
+++ b/.github/workflows/coverity.yml
@@ -0,0 +1,77 @@
+---
+name: coverity
+
+on:
+  schedule:
+    # Run weekly on Mondays at 00:00 UTC
+    - cron: '0 0 * * 1'
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: 'Branch, tag, or ref to check out (leave empty for default branch)'
+        required: false
+        default: ''
+
+jobs:
+  coverity-scan:
+    if: github.repository == 'linux-nvme/nvme-cli'
+    name: coverity scan
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/linux-nvme/debian.python:latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ github.event.inputs.ref || github.ref }}
+          fetch-depth: 0
+
+      - name: Mark repo as safe for git
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+      - name: Get version info
+        id: version
+        run: |
+          VERSION="$(git describe --always --abbrev=12 --dirty)"
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          echo "Building version: ${VERSION}"
+          echo "Current SHA: $(git rev-parse HEAD)"
+
+      - name: Download Coverity Build Tool
+        run: |
+          curl -o coverity_tool.tgz \
+            --form token=${{ secrets.COVERITY_SCAN_TOKEN }} \
+            --form project=linux-nvme/nvme-cli \
+            https://scan.coverity.com/download/linux64
+          mkdir coverity-tools
+          tar xzf coverity_tool.tgz --strip 1 -C coverity-tools
+
+      - name: Configure build
+        run: |
+          meson setup .build
+
+      - name: Build with Coverity
+        run: |
+          export PATH="$PWD/coverity-tools/bin:$PATH"
+          cov-build --dir cov-int ninja -C .build
+
+      - name: Create Coverity tarball
+        run: |
+          tar czvf nvme-cli-coverity.tgz cov-int
+
+      - name: Upload to Coverity Scan
+        run: |
+          curl --form token=${{ secrets.COVERITY_SCAN_TOKEN }} \
+            --form email=${{ secrets.COVERITY_SCAN_EMAIL }} \
+            --form file=@nvme-cli-coverity.tgz \
+            --form version="${{ steps.version.outputs.version }}" \
+            --form description="Automated Coverity Scan from ${{ github.event_name }}" \
+            https://scan.coverity.com/builds?project=linux-nvme%2Fnvme-cli
+
+      - uses: actions/upload-artifact@v5
+        name: upload coverity artifacts
+        if: failure()
+        with:
+          name: coverity-results
+          path: |
+            cov-int/
+            nvme-cli-coverity.tgz
diff --git a/.github/workflows/libnvme-coverage.yml b/.github/workflows/libnvme-coverage.yml
deleted file mode 100644
index 4554435782..0000000000
--- a/.github/workflows/libnvme-coverage.yml
+++ /dev/null
@@ -1,26 +0,0 @@
----
-name: libnvme coverage
-
-on:
-  push:
-    branches: [master]
-
-jobs:
-  code-coverage:
-    if: github.repository == 'linux-nvme/libnvme'
-    name: code coverage
-    runs-on: ubuntu-latest
-    continue-on-error: true
-    container:
-      image: ghcr.io/linux-nvme/debian.python:latest
-    steps:
-      - uses: actions/checkout@v5
-      - name: Mark repo as safe for git
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: build
-        run: |
-          libnvme/scripts/build.sh coverage
-      - uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          fail_ci_if_error: true
diff --git a/.github/workflows/libnvme-docs.yaml b/.github/workflows/libnvme-docs.yaml
deleted file mode 100644
index 665b166fd9..0000000000
--- a/.github/workflows/libnvme-docs.yaml
+++ /dev/null
@@ -1,25 +0,0 @@
----
-name: libnvme docs
-
-on:
-  push:
-    branches: [master]
-  pull_request:
-    branches: [master]
-
-  workflow_dispatch:
-
-jobs:
-  build-docs:
-    name: build documentation
-    runs-on: ubuntu-latest
-    container:
-      image: ghcr.io/linux-nvme/debian:latest
-    steps:
-      - uses: actions/checkout@v5
-      - name: Mark repo as safe for git
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: build
-        run: |
-          scripts/build.sh docs
-#          libnvme/scripts/build.sh docs
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index 6cfc289a62..6b9f0c8237 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -1,23 +1,20 @@
 # SPDX-License-Identifier: Apache-2.0
-
 version: 2
 
 build:
   os: ubuntu-24.04
   tools:
-    python: "3"
+    python: "3.14"
   apt_packages:
     - meson
-    - python3-lxml
-    - docbook-xsl
-    - xsltproc
-    - pandoc
   jobs:
-    post_install:
-      - pip3 install lxml
-    pre_build:
-      - meson setup .build -Ddocs=rst -Ddocs-build=true -Dnvme=disabled -Dlibnvme=disabled -Dpython=disabled || cat .build/meson-logs/meson-log.txt
-      - meson compile -C .build
+    install:
+      - pip install asciidoc sphinx
+    build:
+      html:
+        - scripts/build.sh html_docs
+        - mkdir -p $READTHEDOCS_OUTPUT/html/
+        - cp .build-ci/Documentation/*.html $READTHEDOCS_OUTPUT/html/
+        - mv $READTHEDOCS_OUTPUT/html/nvme.html $READTHEDOCS_OUTPUT/html/index.html
 
-sphinx:
-  configuration: .build/libnvme/doc/conf.py
+formats: []
diff --git a/Documentation/nvme-ocp-get-idle-wakeup-time.txt b/Documentation/nvme-ocp-get-idle-wakeup-time.txt
new file mode 100644
index 0000000000..7749ab8a5b
--- /dev/null
+++ b/Documentation/nvme-ocp-get-idle-wakeup-time.txt
@@ -0,0 +1,59 @@
+nvme-ocp-get-idle-wakeup-time(1)
+=========================================
+
+NAME
+----
+nvme-ocp-get-idle-wakeup-time - Define and print idle-wakeup-time value
+
+SYNOPSIS
+--------
+[verse]
+'nvme ocp get-idle-wakeup-time' <device> [--sel=<select> | -s <select>] [--namespace-id=<nsid> | -n <namespace-id>]
+
+DESCRIPTION
+-----------
+Define get-idle-wakeup-time.
+No argument prints current mode.
+
+The <device> parameter is mandatory and may be either the NVMe character
+device (ex: /dev/nvme0) or block device (ex: /dev/nvme0n1).
+
+This will only work on OCP compliant devices supporting this feature.
+Results for any other device are undefined.
+
+On success it returns 0, error code otherwise.
+
+OPTIONS
+-------
+
+-s <select>::
+--sel=<select>::
+	Select (SEL): This field specifies which value of the attributes
+	to return in the provided data:
+
+-n <namespace-id>::
+--namespace-id=<namespace-id>::
+	namespace-id (namespace-id): This field specifies which value of the attributes
+	to return in the provided data:
++
+[]
+|==================
+|Select|Description
+|0|Current
+|1|Default
+|2|Saved
+|3|Supported capabilities
+|4-7|Reserved
+|==================
+
+EXAMPLES
+--------
+* Has the program issue a get-idle-wakeup-time to retrieve the 0xCA get features.
++
+------------
+# nvme ocp get-idle-wakeup-time /dev/nvme0
+------------
+
+NVME
+----
+Part of the nvme-user suite.
diff --git a/fabrics.c b/fabrics.c
index 4930862fa5..d29b572ad2 100644
--- a/fabrics.c
+++ b/fabrics.c
@@ -94,7 +94,7 @@ static const char *nvmf_concat		= "enable secure concatenation";
 static const char *nvmf_config_file	= "Use specified JSON configuration file or 'none' to disable";
 static const char *nvmf_context		= "execution context identification string";
 
-struct fabric_args {
+struct nvmf_args {
 	const char *subsysnqn;
 	const char *transport;
 	const char *traddr;
@@ -111,7 +111,7 @@ struct fabric_args {
 };
 
 #define NVMF_ARGS(n, f, c, ...)                                                                  \
-	struct argconfig_commandline_options n[] = {                                             \
+	NVME_ARGS(n,                                                                              \
 		OPT_STRING("transport",       't', "STR", &f.transport,     nvmf_tport),         \
 		OPT_STRING("nqn",             'n', "STR", &f.subsysnqn,     nvmf_nqn),           \
 		OPT_STRING("traddr",          'a', "STR", &f.traddr,        nvmf_traddr),        \
@@ -141,9 +141,9 @@ struct fabric_args {
 		OPT_FLAG("data-digest",       'G', &c.data_digest,        nvmf_data_digest),     \
 		OPT_FLAG("tls",                 0, &c.tls,                nvmf_tls),             \
 		OPT_FLAG("concat",              0, &c.concat,             nvmf_concat),          \
-		__VA_ARGS__,                                                                     \
-		OPT_END()                                                                        \
-	}
+		##__VA_ARGS__                                                                    \
+	)
+
 
 static void save_discovery_log(char *raw, struct nvmf_discovery_log *log)
 {
@@ -169,7 +169,7 @@ static void save_discovery_log(char *raw, struct nvmf_discovery_log *log)
 }
 
 static int setup_common_context(struct nvmf_context *fctx,
-		struct fabric_args *fa);
+		struct nvmf_args *fa);
 
 struct cb_fabrics_data {
 	struct nvme_fabrics_config *cfg;
@@ -272,7 +272,7 @@ static int cb_parser_next_line(struct nvmf_context *fctx, void *user_data)
 {
 	struct cb_fabrics_data *cfd = user_data;
 	struct nvme_fabrics_config cfg;
-	struct fabric_args fa = {};
+	struct nvmf_args fa = {};
 	char *ptr, *p, line[4096];
 	int argc, ret = 0;
 	bool force = false;
@@ -317,7 +317,7 @@ static int cb_parser_next_line(struct nvmf_context *fctx, void *user_data)
 }
 
 static int setup_common_context(struct nvmf_context *fctx,
-		struct fabric_args *fa)
+		struct nvmf_args *fa)
 {
 	int err;
 
@@ -344,7 +344,7 @@ static int setup_common_context(struct nvmf_context *fctx,
 }
 
 static int create_common_context(struct nvme_global_ctx *ctx,
-		bool persistent, struct fabric_args *fa,
+		bool persistent, struct nvmf_args *fa,
 		struct nvme_fabrics_config *cfg,
 		void *user_data, struct nvmf_context **fctxp)
 {
@@ -390,7 +390,7 @@ static int create_common_context(struct nvme_global_ctx *ctx,
 
 static int create_discovery_context(struct nvme_global_ctx *ctx,
 		bool persistent, const char *device,
-		struct fabric_args *fa,
+		struct nvmf_args *fa,
 		struct nvme_fabrics_config *cfg,
 		void *user_data, struct nvmf_context **fctxp)
 {
@@ -476,11 +476,9 @@ int fabrics_discovery(const char *desc, int argc, char **argv, bool connect)
 	nvme_print_flags_t flags;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_free_ struct nvmf_context *fctx = NULL;
-	unsigned int verbose = 0;
 	int ret;
-	char *format = "normal";
 	struct nvme_fabrics_config cfg;
-	struct fabric_args fa = { .subsysnqn = NVME_DISC_SUBSYS_NAME };
+	struct nvmf_args fa = { .subsysnqn = NVME_DISC_SUBSYS_NAME };
 	char *device = NULL;
 	bool force = false;
 	bool json_config = false;
@@ -489,12 +487,10 @@ int fabrics_discovery(const char *desc, int argc, char **argv, bool connect)
 
 	NVMF_ARGS(opts, fa, cfg,
 		  OPT_STRING("device",     'd', "DEV", &device,       "use existing discovery controller device"),
-		  OPT_FMT("output-format", 'o', &format,              output_format),
 		  OPT_FILE("raw",          'r', &raw,                 "save raw output to file"),
 		  OPT_FLAG("persistent",   'p', &persistent,          "persistent discovery connection"),
 		  OPT_FLAG("quiet",          0, &quiet,               "suppress already connected errors"),
 		  OPT_STRING("config",     'J', "FILE", &config_file, nvmf_config_file),
-		  OPT_INCR("verbose",      'v', &verbose,             "Increase logging verbosity"),
 		  OPT_FLAG("dump-config",  'O', &dump_config,         "Dump configuration file to stdout"),
 		  OPT_FLAG("force",          0, &force,               "Force persistent discovery controller creation"),
 		  OPT_FLAG("nbft",           0, &nbft,                "Only look at NBFT tables"),
@@ -508,7 +504,7 @@ int fabrics_discovery(const char *desc, int argc, char **argv, bool connect)
 	if (ret)
 		return ret;
 
-	ret = validate_output_format(format, &flags);
+	ret = validate_output_format(nvme_args.output_format, &flags);
 	if (ret < 0) {
 		nvme_show_error("Invalid output format");
 		return ret;
@@ -517,7 +513,7 @@ int fabrics_discovery(const char *desc, int argc, char **argv, bool connect)
 	if (!strcmp(config_file, "none"))
 		config_file = NULL;
 
-	log_level = map_log_level(verbose, quiet);
+	log_level = map_log_level(nvme_args.verbose, quiet);
 
 	ctx = nvme_create_global_ctx(stderr, log_level);
 	if (!ctx) {
@@ -579,7 +575,7 @@ int fabrics_discovery(const char *desc, int argc, char **argv, bool connect)
 
 out_free:
 	if (dump_config)
-		nvme_dump_config(ctx, NULL);
+		nvme_dump_config(ctx, STDOUT_FILENO);
 
 	return ret;
 }
@@ -590,21 +586,17 @@ int fabrics_connect(const char *desc, int argc, char **argv)
 	_cleanup_free_ char *hid = NULL;
 	char *config_file = NULL;
 	char *context = NULL;
-	unsigned int verbose = 0;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_free_ struct nvmf_context *fctx = NULL;
 	_cleanup_nvme_ctrl_ nvme_ctrl_t c = NULL;
 	int ret;
 	nvme_print_flags_t flags;
 	struct nvme_fabrics_config cfg = { 0 };
-	struct fabric_args fa = { 0 };
-	char *format = "normal";
+	struct nvmf_args fa = { 0 };
 
 	NVMF_ARGS(opts, fa, cfg,
 		  OPT_STRING("config",             'J', "FILE", &config_file, nvmf_config_file),
-		  OPT_INCR("verbose",              'v', &verbose,             "Increase logging verbosity"),
 		  OPT_FLAG("dump-config",          'O', &dump_config,             "Dump JSON configuration to stdout"),
-		  OPT_FMT("output-format",         'o', &format,       "Output format: normal|json"),
 		  OPT_STRING("context",              0, "STR", &context,  nvmf_context));
 
 	nvmf_default_config(&cfg);
@@ -613,7 +605,7 @@ int fabrics_connect(const char *desc, int argc, char **argv)
 	if (ret)
 		return ret;
 
-	ret = validate_output_format(format, &flags);
+	ret = validate_output_format(nvme_args.output_format, &flags);
 	if (ret < 0) {
 		nvme_show_error("Invalid output format");
 		return ret;
@@ -644,7 +636,7 @@ int fabrics_connect(const char *desc, int argc, char **argv)
 	}
 
 do_connect:
-	log_level = map_log_level(verbose, quiet);
+	log_level = map_log_level(nvme_args.verbose, quiet);
 
 	ctx = nvme_create_global_ctx(stderr, log_level);
 	if (!ctx) {
@@ -686,7 +678,7 @@ int fabrics_connect(const char *desc, int argc, char **argv)
 	}
 
 	if (dump_config)
-		nvme_dump_config(ctx, NULL);
+		nvme_dump_config(ctx, STDERR_FILENO);
 
 	return 0;
 }
@@ -746,17 +738,13 @@ int fabrics_disconnect(const char *desc, int argc, char **argv)
 	struct config {
 		char *nqn;
 		char *device;
-		unsigned int verbose;
 	};
 
 	struct config cfg = { 0 };
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_STRING("nqn",        'n', "NAME", &cfg.nqn,    nvmf_nqn),
-		OPT_STRING("device",     'd', "DEV",  &cfg.device, device),
-		OPT_INCR("verbose",      'v', &cfg.verbose, "Increase logging verbosity"),
-		OPT_END()
-	};
+		OPT_STRING("device",     'd', "DEV",  &cfg.device, device));
 
 	ret = argconfig_parse(argc, argv, desc, opts);
 	if (ret)
@@ -773,7 +761,7 @@ int fabrics_disconnect(const char *desc, int argc, char **argv)
 		return -EINVAL;
 	}
 
-	log_level = map_log_level(cfg.verbose, false);
+	log_level = map_log_level(nvme_args.verbose, false);
 
 	ctx = nvme_create_global_ctx(stderr, log_level);
 	if (!ctx) {
@@ -834,22 +822,18 @@ int fabrics_disconnect_all(const char *desc, int argc, char **argv)
 
 	struct config {
 		char *transport;
-		unsigned int verbose;
 	};
 
 	struct config cfg = { 0 };
 
-	OPT_ARGS(opts) = {
-		OPT_STRING("transport", 'r', "STR", (char *)&cfg.transport, nvmf_tport),
-		OPT_INCR("verbose",  'v', &cfg.verbose, "Increase logging verbosity"),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_STRING("transport", 'r', "STR", (char *)&cfg.transport, nvmf_tport));
 
 	ret = argconfig_parse(argc, argv, desc, opts);
 	if (ret)
 		return ret;
 
-	log_level = map_log_level(cfg.verbose, false);
+	log_level = map_log_level(nvme_args.verbose, false);
 
 	ctx = nvme_create_global_ctx(stderr, log_level);
 	if (!ctx) {
@@ -900,13 +884,11 @@ int fabrics_config(const char *desc, int argc, char **argv)
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	char *config_file = PATH_NVMF_CONFIG;
 	struct nvme_fabrics_config cfg;
-	struct fabric_args fa = { };
-	unsigned int verbose = 0;
+	struct nvmf_args fa = { };
 	int ret;
 
 	NVMF_ARGS(opts, fa, cfg,
 		  OPT_STRING("config",             'J', "FILE", &config_file, nvmf_config_file),
-		  OPT_INCR("verbose",              'v', &verbose,             "Increase logging verbosity"),
 		  OPT_FLAG("scan",                 'R', &scan_tree,           "Scan current NVMeoF topology"),
 		  OPT_FLAG("modify",               'M', &modify_config,       "Modify JSON configuration file"),
 		  OPT_FLAG("dump",                 'O', &dump_config,         "Dump JSON configuration to stdout"),
@@ -921,7 +903,7 @@ int fabrics_config(const char *desc, int argc, char **argv)
 	if (!strcmp(config_file, "none"))
 		config_file = NULL;
 
-	log_level = map_log_level(verbose, quiet);
+	log_level = map_log_level(nvme_args.verbose, quiet);
 
 	ctx = nvme_create_global_ctx(stderr, log_level);
 	if (!ctx) {
@@ -969,11 +951,16 @@ int fabrics_config(const char *desc, int argc, char **argv)
 		}
 	}
 
-	if (update_config)
-		nvme_dump_config(ctx, config_file);
+	if (update_config) {
+		_cleanup_fd_ int fd = -1;
+
+		fd = open(config_file, O_RDONLY, 0);
+		if (fd != -1)
+			nvme_dump_config(ctx, fd);
+	}
 
 	if (dump_config)
-		nvme_dump_config(ctx, NULL);
+		nvme_dump_config(ctx, STDOUT_FILENO);
 
 	return 0;
 }
@@ -1015,16 +1002,12 @@ int fabrics_dim(const char *desc, int argc, char **argv)
 		char *nqn;
 		char *device;
 		char *tas;
-		unsigned int verbose;
 	} cfg = { 0 };
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_STRING("nqn",    'n', "NAME", &cfg.nqn,    "Comma-separated list of DC nqn"),
 		OPT_STRING("device", 'd', "DEV",  &cfg.device, "Comma-separated list of DC nvme device handle."),
-		OPT_STRING("task",   't', "TASK", &cfg.tas,    "[register|deregister]"),
-		OPT_INCR("verbose",  'v', &cfg.verbose, "Increase logging verbosity"),
-		OPT_END()
-	};
+		OPT_STRING("task",   't', "TASK", &cfg.tas,    "[register|deregister]"));
 
 	ret = argconfig_parse(argc, argv, desc, opts);
 	if (ret)
@@ -1052,7 +1035,7 @@ int fabrics_dim(const char *desc, int argc, char **argv)
 		return -EINVAL;
 	}
 
-	log_level = map_log_level(cfg.verbose, false);
+	log_level = map_log_level(nvme_args.verbose, false);
 
 	ctx = nvme_create_global_ctx(stderr, log_level);
 	if (!ctx) {
diff --git a/libnvme/.readthedocs.yaml b/libnvme/.readthedocs.yaml
new file mode 100644
index 0000000000..b83c53b372
--- /dev/null
+++ b/libnvme/.readthedocs.yaml
@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: Apache-2.0
+version: 2
+
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.14"
+  apt_packages:
+    - meson
+  jobs:
+    install:
+      - pip install asciidoc sphinx
+    pre_build:
+      - scripts/build.sh rst_docs
+
+sphinx:
+  configuration: .build-ci/libnvme/doc/conf.py
diff --git a/libnvme/libnvme/nvme.i b/libnvme/libnvme/nvme.i
index a8851edf86..e658ebafa0 100644
--- a/libnvme/libnvme/nvme.i
+++ b/libnvme/libnvme/nvme.i
@@ -529,7 +529,7 @@ struct nvme_ns {
 		nvme_refresh_topology($self);
 	}
 	void dump_config() {
-		nvme_dump_config($self, NULL);
+		nvme_dump_config($self, STDERR_FILENO);
 	}
 }
 
diff --git a/libnvme/src/libnvme.ld b/libnvme/src/libnvme.ld
index 67748349c8..818a2072cd 100644
--- a/libnvme/src/libnvme.ld
+++ b/libnvme/src/libnvme.ld
@@ -237,6 +237,7 @@ LIBNVME_2_0 {
 		nvme_set_application;
 		nvme_set_dry_run;
 		nvme_set_etdas;
+		nvme_set_ioctl_probing;
 		nvme_set_keyring;
 		nvme_set_property;
 		nvme_set_root;
diff --git a/libnvme/src/nvme/fabrics.c b/libnvme/src/nvme/fabrics.c
index 06336dbc1f..09aecb8e05 100644
--- a/libnvme/src/nvme/fabrics.c
+++ b/libnvme/src/nvme/fabrics.c
@@ -622,7 +622,7 @@ static int inet6_pton(struct nvme_global_ctx *ctx, const char *src, uint16_t por
 
 /**
  * inet_pton_with_scope - convert an IPv4/IPv6 to socket address
- * @r: nvme_root_t object
+ * @ctx: Global context
  * @af: address family, AF_INET, AF_INET6 or AF_UNSPEC for either
  * @src: the start of the address string
  * @trsvcid: transport service identifier
@@ -2371,8 +2371,9 @@ static int nvmf_create_discovery_ctrl(struct nvme_global_ctx *ctx,
 	/* Find out the name of discovery controller */
 	ret = nvme_ctrl_identify(c, id);
 	if (ret)  {
-		fprintf(stderr,	"failed to identify controller, error %s\n",
-			nvme_strerror(-ret));
+		nvme_msg(ctx, LOG_ERR,
+			 "failed to identify controller, error %s\n",
+			 nvme_strerror(-ret));
 		nvme_disconnect_ctrl(c);
 		nvme_free_ctrl(c);
 		return ret;
@@ -2426,7 +2427,7 @@ int _discovery_config_json(struct nvme_global_ctx *ctx,
 	/* ignore if no host_traddr for fc */
 	if (!strcmp(transport, "fc")) {
 		if (!host_traddr) {
-			fprintf(stderr, "host_traddr required for fc\n");
+			nvme_msg(ctx, LOG_ERR, "host_traddr required for fc\n");
 			return 0;
 		}
 	}
@@ -2434,8 +2435,8 @@ int _discovery_config_json(struct nvme_global_ctx *ctx,
 	/* ignore if host_iface set for any transport other than tcp */
 	if (!strcmp(transport, "rdma") || !strcmp(transport, "fc")) {
 		if (host_iface) {
-			fprintf(stderr,
-				"host_iface not permitted for rdma or fc\n");
+			nvme_msg(ctx, LOG_ERR,
+				 "host_iface not permitted for rdma or fc\n");
 			return 0;
 		}
 	}
@@ -2575,11 +2576,11 @@ int nvmf_connect_config_json(struct nvme_global_ctx *ctx,
 					if (err == -ENVME_CONNECT_ALREADY)
 						continue;
 
-					fprintf(stderr,
-						"failed to connect to hostnqn=%s,nqn=%s,%s\n",
-						nvme_host_get_hostnqn(h),
-						nvme_subsystem_get_name(s),
-						nvme_ctrl_get_address(c));
+					nvme_msg(ctx, LOG_ERR,
+						 "failed to connect to hostnqn=%s,nqn=%s,%s\n",
+						 nvme_host_get_hostnqn(h),
+						 nvme_subsystem_get_name(s),
+						 nvme_ctrl_get_address(c));
 
 					if (!ret)
 						ret = err;
@@ -2759,25 +2760,26 @@ void nvmf_nbft_free(struct nvme_global_ctx *ctx, struct nbft_file_entry *head)
 	}
 }
 
-static bool validate_uri(struct nbft_info_discovery *dd,
+static bool validate_uri(struct nvme_global_ctx *ctx,
+			 struct nbft_info_discovery *dd,
 			 struct nvme_fabrics_uri *uri)
 {
 	if (!uri) {
-		fprintf(stderr,
-			"Discovery Descriptor %d: failed to parse URI %s\n",
-			dd->index, dd->uri);
+		nvme_msg(ctx, LOG_ERR,
+			 "Discovery Descriptor %d: failed to parse URI %s\n",
+			 dd->index, dd->uri);
 		return false;
 	}
 	if (strcmp(uri->scheme, "nvme") != 0) {
-		fprintf(stderr,
-			"Discovery Descriptor %d: unsupported scheme '%s'\n",
-			dd->index, uri->scheme);
+		nvme_msg(ctx, LOG_ERR,
+			 "Discovery Descriptor %d: unsupported scheme '%s'\n",
+			 dd->index, uri->scheme);
 		return false;
 	}
 	if (!uri->protocol || strcmp(uri->protocol, "tcp") != 0) {
-		fprintf(stderr,
-			"Discovery Descriptor %d: unsupported transport '%s'\n",
-			dd->index, uri->protocol);
+		nvme_msg(ctx, LOG_ERR,
+			 "Discovery Descriptor %d: unsupported transport '%s'\n",
+			 dd->index, uri->protocol);
 		return false;
 	}
 
@@ -3104,7 +3106,7 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 			ret = nvme_parse_uri((*dd)->uri, &uri);
 			if (ret)
 				continue;
-			if (!validate_uri(*dd, uri))
+			if (!validate_uri(ctx, *dd, uri))
 				continue;
 
 			host_traddr = NULL;
@@ -3228,8 +3230,9 @@ static int nvmf_create_discover_ctrl(struct nvme_global_ctx *ctx,
 	/* Find out the name of discovery controller */
 	ret = nvme_ctrl_identify(c, id);
 	if (ret) {
-		fprintf(stderr, "failed to identify controller, error %s\n",
-			nvme_strerror(-ret));
+		nvme_msg(ctx, LOG_ERR,
+			 "failed to identify controller, error %s\n",
+			 nvme_strerror(-ret));
 		nvme_disconnect_ctrl(c);
 		nvme_free_ctrl(c);
 		return ret;
diff --git a/libnvme/src/nvme/json.c b/libnvme/src/nvme/json.c
index 41f7862b25..3121cece8c 100644
--- a/libnvme/src/nvme/json.c
+++ b/libnvme/src/nvme/json.c
@@ -386,7 +386,7 @@ static void json_update_subsys(struct json_object *subsys_array,
 	}
 }
 
-int json_update_config(struct nvme_global_ctx *ctx, const char *config_file)
+int json_update_config(struct nvme_global_ctx *ctx, int fd)
 {
 	nvme_host_t h;
 	struct json_object *json_root, *host_obj;
@@ -432,18 +432,12 @@ int json_update_config(struct nvme_global_ctx *ctx, const char *config_file)
 			json_object_put(host_obj);
 		}
 	}
-	if (!config_file) {
-		ret = json_object_to_fd(1, json_root,
-					JSON_C_TO_STRING_PRETTY |
-					JSON_C_TO_STRING_NOSLASHESCAPE);
-		printf("\n");
-	} else
-		ret = json_object_to_file_ext(config_file, json_root,
-					      JSON_C_TO_STRING_PRETTY |
-					      JSON_C_TO_STRING_NOSLASHESCAPE);
+	ret = json_object_to_fd(fd, json_root,
+				JSON_C_TO_STRING_PRETTY |
+				JSON_C_TO_STRING_NOSLASHESCAPE);
+	write(fd, "\n", 1);
 	if (ret < 0) {
-		nvme_msg(ctx, LOG_ERR, "Failed to write to %s, %s\n",
-			 config_file ? "stdout" : config_file,
+		nvme_msg(ctx, LOG_ERR, "Failed to write JSON config file: %s\n",
 			 json_util_get_last_err());
 		ret = -EIO;
 	}
diff --git a/libnvme/src/nvme/linux.c b/libnvme/src/nvme/linux.c
index e9c6989d79..ad4834c9f1 100644
--- a/libnvme/src/nvme/linux.c
+++ b/libnvme/src/nvme/linux.c
@@ -43,6 +43,11 @@ 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)
+{
+	ctx->ioctl_probing = enable;
+}
+
 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))
@@ -105,9 +110,11 @@ static int __nvme_transport_handle_open_direct(struct nvme_transport_handle *hdl
 		return -EINVAL;
 	}
 
-	ret = ioctl(hdl->fd, NVME_IOCTL_ADMIN64_CMD, &dummy);
-	if (ret > 0)
-		hdl->ioctl64 = true;
+	if (hdl->ctx->ioctl_probing) {
+		ret = ioctl(hdl->fd, NVME_IOCTL_ADMIN64_CMD, &dummy);
+		if (ret > 0)
+			hdl->ioctl64 = true;
+	}
 
 	return 0;
 }
@@ -316,7 +323,8 @@ int nvme_get_uuid_list(struct nvme_transport_handle *hdl, struct nvme_id_uuid_li
 	nvme_init_identify_ctrl(&cmd, &ctrl);
 	err = nvme_submit_admin_passthru(hdl, &cmd);
 	if (err) {
-		fprintf(stderr, "ERROR: nvme_identify_ctrl() failed 0x%x\n", err);
+		nvme_msg(hdl->ctx, LOG_ERR,
+			 "ERROR: nvme_identify_ctrl() failed 0x%x\n", err);
 		return err;
 	}
 
diff --git a/libnvme/src/nvme/linux.h b/libnvme/src/nvme/linux.h
index 4702d58b03..fc80b8f8fa 100644
--- a/libnvme/src/nvme/linux.h
+++ b/libnvme/src/nvme/linux.h
@@ -742,4 +742,16 @@ int nvme_import_tls_key_versioned(struct nvme_global_ctx *ctx,
  */
 void nvme_set_dry_run(struct nvme_global_ctx *ctx, bool enable);
 
+/**
+ * nvme_set_ioctl_probing() - Enable/disable 64-bit IOCTL probing
+ * @ctx:	struct nvme_global_ctx object
+ * @enable:	Enable/disable 64-bit IOCTL probing
+ *
+ * When IOCTL probing is enabled, a 64-bit IOCTL command is issued to
+ * figure out if the passthru interface supports it.
+ *
+ * IOCTL probing is enabled per default.
+ */
+void nvme_set_ioctl_probing(struct nvme_global_ctx *ctx, bool enable);
+
 #endif /* _LIBNVME_LINUX_H */
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index dc34787da9..aacb365e24 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -268,6 +268,7 @@ struct nvme_global_ctx {
 	struct list_head hosts;
 	struct nvme_log log;
 	bool mi_probe_enabled;
+	bool ioctl_probing;
 	bool create_only;
 	bool dry_run;
 	struct nvme_fabric_options *options;
@@ -386,7 +387,7 @@ int nvme_set_attr(const char *dir, const char *attr, const char *value);
 
 int json_read_config(struct nvme_global_ctx *ctx, const char *config_file);
 
-int json_update_config(struct nvme_global_ctx *ctx, const char *config_file);
+int json_update_config(struct nvme_global_ctx *ctx, int fd);
 
 int json_dump_tree(struct nvme_global_ctx *ctx);
 
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index a7a43162d3..25e48d9f3f 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -330,7 +330,7 @@ struct nvme_global_ctx *nvme_create_global_ctx(FILE *fp, int log_level)
 	int fd;
 
 	ctx = calloc(1, sizeof(*ctx));
-	if (!ctx) 
+	if (!ctx)
 		return NULL;
 
 	if (fp) {
@@ -348,6 +348,8 @@ struct nvme_global_ctx *nvme_create_global_ctx(FILE *fp, int log_level)
 	list_head_init(&ctx->hosts);
 	list_head_init(&ctx->endpoints);
 
+	ctx->ioctl_probing = true;
+
 	return ctx;
 }
 
@@ -399,9 +401,9 @@ int nvme_scan(const char *config_file, struct nvme_global_ctx **ctxp)
 	return ret;
 }
 
-int nvme_dump_config(struct nvme_global_ctx *ctx, const char *config_file)
+int nvme_dump_config(struct nvme_global_ctx *ctx, int fd)
 {
-	return json_update_config(ctx, config_file);
+	return json_update_config(ctx, fd);
 }
 
 int nvme_dump_tree(struct nvme_global_ctx *ctx)
@@ -630,11 +632,18 @@ nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p)
 
 static void __nvme_free_ns(struct nvme_ns *n)
 {
+	struct nvme_path *p, *_p;
+
 	list_del_init(&n->entry);
 	nvme_ns_release_transport_handle(n);
 	free(n->generic_name);
 	free(n->name);
 	free(n->sysfs_dir);
+	nvme_namespace_for_each_path_safe(n, p, _p) {
+		list_del_init(&p->nentry);
+		p->n = NULL;
+	}
+	list_head_init(&n->head->paths);
 	free(n->head->sysfs_dir);
 	free(n->head);
 	free(n);
@@ -2985,16 +2994,8 @@ static int nvme_subsystem_scan_namespace(struct nvme_global_ctx *ctx, nvme_subsy
 		return ret;
 	}
 	nvme_subsystem_for_each_ns_safe(s, _n, __n) {
-		struct nvme_path *p, *_p;
-
 		if (strcmp(n->name, _n->name))
 			continue;
-		/* Detach paths */
-		nvme_namespace_for_each_path_safe(_n, p, _p) {
-			list_del_init(&p->nentry);
-			p->n = NULL;
-		}
-		list_head_init(&_n->head->paths);
 		__nvme_free_ns(_n);
 	}
 	n->s = s;
diff --git a/libnvme/src/nvme/tree.h b/libnvme/src/nvme/tree.h
index 94197872b8..416821a7d4 100644
--- a/libnvme/src/nvme/tree.h
+++ b/libnvme/src/nvme/tree.h
@@ -1398,15 +1398,14 @@ void nvme_refresh_topology(struct nvme_global_ctx *ctx);
 /**
  * nvme_dump_config() - Print the JSON configuration
  * @ctx:		&struct nvme_global_ctx object
- * @config_file:	JSON configuration file.
+ * @fd:			File descriptor to write the JSON configuration.
  *
- * Prints the current contents of the JSON configuration
- * file to the config_file. If connfig_file is not provided it prints
- * to stdout.
+ * Writes the current contents of the JSON configuration
+ * to the file descriptor fd.
  *
  * Return: 0 on success, or negative error code otherwise.
  */
-int nvme_dump_config(struct nvme_global_ctx *ctx, const char *config_file);
+int nvme_dump_config(struct nvme_global_ctx *ctx, int fd);
 
 /**
  * nvme_dump_tree() - Dump internal object tree
diff --git a/libnvme/test/config/config-dump.c b/libnvme/test/config/config-dump.c
index d9e8d27032..1adc3348a1 100644
--- a/libnvme/test/config/config-dump.c
+++ b/libnvme/test/config/config-dump.c
@@ -7,6 +7,7 @@
 #include <string.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <unistd.h>
 #include <errno.h>
 
 #include <libnvme.h>
@@ -29,7 +30,7 @@ static bool config_dump(const char *file)
 	if (err)
 		goto out;
 
-	err = nvme_dump_config(ctx, NULL);
+	err = nvme_dump_config(ctx, STDOUT_FILENO);
 	if (err)
 		goto out;
 
diff --git a/libnvme/test/config/psk-json.c b/libnvme/test/config/psk-json.c
index 65801397c6..35fc67ee4a 100644
--- a/libnvme/test/config/psk-json.c
+++ b/libnvme/test/config/psk-json.c
@@ -9,6 +9,7 @@
 #include <string.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <unistd.h>
 #include <errno.h>
 
 #include <libnvme.h>
@@ -69,7 +70,7 @@ static bool psk_json_test(char *file)
 				if (!import_export_key(ctx, c))
 					goto out;
 
-	err = nvme_dump_config(ctx, NULL);
+	err = nvme_dump_config(ctx, STDOUT_FILENO);
 	if (err)
 		goto out;
 
diff --git a/logging.c b/logging.c
index 4d1c8e65f6..8bfd2397c2 100644
--- a/logging.c
+++ b/logging.c
@@ -32,7 +32,7 @@ static struct submit_data sb;
 bool is_printable_at_level(int level)
 {
 	return ((log_level >= level) &&
-		(strcmp(nvme_cfg.output_format, "normal") == 0));
+		(strcmp(nvme_args.output_format, "normal") == 0));
 }
 
 int map_log_level(int verbose, bool quiet)
@@ -134,7 +134,7 @@ void nvme_submit_exit(struct nvme_transport_handle *hdl,
 bool nvme_decide_retry(struct nvme_transport_handle *hdl,
 		struct nvme_passthru_cmd *cmd, int err)
 {
-	if (!nvme_cfg.no_retries)
+	if (!nvme_args.no_retries)
 		return false;
 
 	if (err != -EAGAIN ||
diff --git a/nvme-print-json.c b/nvme-print-json.c
index 73b0c52e0a..045e62a568 100644
--- a/nvme-print-json.c
+++ b/nvme-print-json.c
@@ -202,7 +202,7 @@ static void json_id_iocs_iocsc(struct json_object *obj_iocsc, __u64 iocsc)
 
 static bool verbose_mode(void)
 {
-	return json_print_ops.flags & VERBOSE || nvme_cfg.output_format_ver == 2;
+	return json_print_ops.flags & VERBOSE || nvme_args.output_format_ver == 2;
 }
 
 static void json_id_iocs(struct nvme_id_iocs *iocs)
@@ -4893,7 +4893,7 @@ static void json_list_item(nvme_ns_t n, struct table *t)
 static void json_print_list_items(struct nvme_global_ctx *ctx)
 {
 	if (json_print_ops.flags & VERBOSE) {
-		if (nvme_cfg.output_format_ver == 2)
+		if (nvme_args.output_format_ver == 2)
 			json_detail_list_v2(ctx);
 		else
 			json_detail_list(ctx);
diff --git a/nvme-print.c b/nvme-print.c
index 5776b020db..b388ff0880 100644
--- a/nvme-print.c
+++ b/nvme-print.c
@@ -20,7 +20,7 @@
 #define nvme_print(name, flags, ...)				\
 	do {							\
 		struct print_ops *ops = nvme_print_ops(flags);	\
-		if (ops && ops->name && !nvme_cfg.dry_run)	\
+		if (ops && ops->name && !nvme_args.dry_run)	\
 			ops->name(__VA_ARGS__);			\
 	} while (false)
 
diff --git a/nvme-rpmb.c b/nvme-rpmb.c
index 5e955846c7..42a67c6b4a 100644
--- a/nvme-rpmb.c
+++ b/nvme-rpmb.c
@@ -855,7 +855,7 @@ int rpmb_cmd_option(int argc, char **argv, struct command *acmd, struct plugin *
 		.target  = 0,
 	};
 	
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_STRING("cmd",     'c', "command", &cfg.cmd,     opt),
 		OPT_STRING("msgfile", 'f', "FILE",    &cfg.msgfile, mfile),
 		OPT_STRING("keyfile", 'g', "FILE",    &cfg.keyfile, kfile),
@@ -863,9 +863,7 @@ int rpmb_cmd_option(int argc, char **argv, struct command *acmd, struct plugin *
 		OPT_STRING("msg",     'd', "data",    &cfg.msg,     msg),
 		OPT_UINT("address",   'o', &cfg.address,  address),
 		OPT_UINT("blocks",    'b', &cfg.blocks,   blocks),
-		OPT_UINT("target",    't', &cfg.target,   target),
-		OPT_END()
-	};
+		OPT_UINT("target",    't', &cfg.target,   target));
 	
 	_cleanup_free_ unsigned char *key_buf = NULL;
 	_cleanup_free_ unsigned char *msg_buf = NULL;
diff --git a/nvme.c b/nvme.c
index 332cc7c303..ef85ce5797 100644
--- a/nvme.c
+++ b/nvme.c
@@ -189,14 +189,6 @@ static struct program nvme = {
 	.extensions = &builtin,
 };
 
-#ifdef CONFIG_JSONC
-const char *output_format = "Output format: normal|json|binary";
-#else /* CONFIG_JSONC */
-const char *output_format = "Output format: normal|binary";
-#endif /* CONFIG_JSONC */
-const char *timeout = "timeout value, in milliseconds";
-const char *verbose = "Increase output verbosity";
-const char *dry_run = "show command instead of sending";
 const char *uuid_index = "UUID index";
 
 static const char *app_tag = "app tag for end-to-end PI";
@@ -266,7 +258,7 @@ static const char *pmrmscl = "PMRMSCL=0xe14 register offset";
 static const char *pmrmscu = "PMRMSCU=0xe18 register offset";
 static const char *ish = "Ignore Shutdown (for NVMe-MI command)";
 
-struct nvme_config nvme_cfg = {
+struct nvme_args nvme_args = {
 	.output_format = "normal",
 	.output_format_ver = 1,
 	.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
@@ -381,7 +373,7 @@ static int parse_args(int argc, char *argv[], const char *desc,
 	if (ret)
 		return ret;
 
-	log_level = map_log_level(nvme_cfg.verbose, false);
+	log_level = map_log_level(nvme_args.verbose, false);
 
 	return 0;
 }
@@ -402,6 +394,9 @@ int parse_and_open(struct nvme_global_ctx **ctx,
 	if (!ctx_new)
 		return -ENOMEM;
 
+	nvme_set_ioctl_probing(ctx_new,
+		!argconfig_parse_seen(opts, "no-ioctl-probing"));
+
 	ret = get_transport_handle(ctx_new, argc, argv, O_RDONLY, &hdl_new);
 	if (ret) {
 		nvme_free_global_ctx(ctx_new);
@@ -511,7 +506,7 @@ bool nvme_is_output_format_json(void)
 {
 	nvme_print_flags_t flags;
 
-	if (validate_output_format(nvme_cfg.output_format, &flags))
+	if (validate_output_format(nvme_args.output_format, &flags))
 		return false;
 
 	return flags == JSON;
@@ -551,7 +546,7 @@ static int get_smart_log(int argc, char **argv, struct command *acmd, struct plu
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -611,7 +606,7 @@ static int get_ana_log(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -891,7 +886,7 @@ static int get_telemetry_log(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1034,7 +1029,7 @@ static int get_endurance_log(int argc, char **argv, struct command *acmd, struct
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1114,7 +1109,7 @@ static int get_effects_log(int argc, char **argv, struct command *acmd, struct p
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1189,7 +1184,7 @@ static int get_supported_log_pages(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1247,7 +1242,7 @@ static int get_error_log(int argc, char **argv, struct command *acmd, struct plu
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1313,7 +1308,7 @@ static int get_fw_log(int argc, char **argv, struct command *acmd, struct plugin
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1366,7 +1361,7 @@ static int get_changed_ns_list_log(int argc, char **argv, bool alloc)
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1442,7 +1437,7 @@ static int get_pred_lat_per_nvmset_log(int argc, char **argv,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1505,7 +1500,7 @@ static int get_pred_lat_event_agg_log(int argc, char **argv,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1589,7 +1584,7 @@ static int get_persistent_event_log(int argc, char **argv,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1701,7 +1696,7 @@ static int get_endurance_event_agg_log(int argc, char **argv,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1777,7 +1772,7 @@ static int get_lba_status_log(int argc, char **argv,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1825,7 +1820,7 @@ static int get_resv_notif_log(int argc, char **argv,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1882,7 +1877,7 @@ static int get_boot_part_log(int argc, char **argv, struct command *acmd, struct
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1972,7 +1967,7 @@ static int get_phy_rx_eom_log(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -2057,7 +2052,7 @@ static int get_media_unit_stat_log(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -2110,7 +2105,7 @@ static int get_supp_cap_config_log(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -2411,7 +2406,7 @@ static int get_log(int argc, char **argv, struct command *acmd, struct plugin *p
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -2535,7 +2530,7 @@ static int sanitize_log(int argc, char **argv, struct command *acmd, struct plug
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -2589,7 +2584,7 @@ static int get_fid_support_effects_log(int argc, char **argv, struct command *ac
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -2641,7 +2636,7 @@ static int get_mi_cmd_support_effects_log(int argc, char **argv, struct command
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -2697,7 +2692,7 @@ static int list_ctrl(int argc, char **argv, struct command *acmd, struct plugin
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0 || (flags != JSON && flags != NORMAL)) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -2760,7 +2755,7 @@ static int list_ns(int argc, char **argv, struct command *acmd, struct plugin *p
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0 || (flags != JSON && flags != NORMAL)) {
 		nvme_show_error("Invalid output format");
 		return -EINVAL;
@@ -2829,7 +2824,7 @@ static int id_ns_lba_format(int argc, char **argv, struct command *acmd, struct
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -2884,7 +2879,7 @@ static int id_endurance_grp_list(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0 || (flags != JSON && flags != NORMAL)) {
 		nvme_show_error("invalid output format");
 		return -EINVAL;
@@ -2978,7 +2973,7 @@ static int delete_ns(int argc, char **argv, struct command *acmd, struct plugin
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -3040,7 +3035,7 @@ static int nvme_attach_ns(int argc, char **argv, int attach, const char *desc, s
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -3315,7 +3310,7 @@ static int create_ns(int argc, char **argv, struct command *acmd, struct plugin
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -3514,7 +3509,7 @@ static int list_subsys(int argc, char **argv, struct command *acmd,
 	if (optind < argc)
 		devname = basename(argv[optind++]);
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0 || (flags != JSON && flags != NORMAL)) {
 		nvme_show_error("Invalid output format");
 		return -EINVAL;
@@ -3566,7 +3561,7 @@ static int list(int argc, char **argv, struct command *acmd, struct plugin *plug
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0 || (flags != JSON && flags != NORMAL)) {
 		nvme_show_error("Invalid output format");
 		return -EINVAL;
@@ -3628,7 +3623,7 @@ int __id_ctrl(int argc, char **argv, struct command *acmd, struct plugin *plugin
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -3683,7 +3678,7 @@ static int nvm_id_ctrl(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -3740,7 +3735,7 @@ static int nvm_id_ns(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -3814,7 +3809,7 @@ static int nvm_id_ns_lba_format(int argc, char **argv, struct command *acmd, str
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -3882,7 +3877,7 @@ static int ns_descs(int argc, char **argv, struct command *acmd, struct plugin *
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -3960,7 +3955,7 @@ static int id_ns(int argc, char **argv, struct command *acmd, struct plugin *plu
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4039,7 +4034,7 @@ static int cmd_set_independent_id_ns(int argc, char **argv, struct command *acmd
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4095,7 +4090,7 @@ static int id_ns_granularity(int argc, char **argv, struct command *acmd, struct
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4146,7 +4141,7 @@ static int id_nvmset(int argc, char **argv, struct command *acmd, struct plugin
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4201,7 +4196,7 @@ static int id_uuid(int argc, char **argv, struct command *acmd, struct plugin *p
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4257,7 +4252,7 @@ static int id_iocs(int argc, char **argv, struct command *acmd, struct plugin *p
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4312,7 +4307,7 @@ static int id_domain(int argc, char **argv, struct command *acmd, struct plugin
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4352,7 +4347,7 @@ static int get_ns_id(int argc, char **argv, struct command *acmd, struct plugin
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4461,7 +4456,7 @@ static int primary_ctrl_caps(int argc, char **argv, struct command *acmd, struct
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4519,7 +4514,7 @@ static int list_secondary_ctrl(int argc, char **argv, struct command *acmd, stru
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4692,7 +4687,7 @@ static int device_self_test(int argc, char **argv, struct command *acmd, struct
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4783,7 +4778,7 @@ static int self_test_log(int argc, char **argv, struct command *acmd, struct plu
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -4851,7 +4846,7 @@ static void get_feature_id_print(struct feat_cfg cfg, int err, __u64 result,
 			nvme_feature_show(cfg.feature_id, cfg.sel, result);
 			if (NVME_CHECK(cfg.sel, GET_FEATURES_SEL, SUPPORTED))
 				nvme_show_select_result(cfg.feature_id, result);
-			else if (verbose || !strcmp(nvme_cfg.output_format, "json"))
+			else if (verbose || !strcmp(nvme_args.output_format, "json"))
 				nvme_feature_show_fields(cfg.feature_id, result, buf);
 			else if (buf)
 				d(buf, cfg.data_len, 16, 1);
@@ -4992,7 +4987,7 @@ static int get_feature(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -5180,7 +5175,7 @@ static int fw_download(int argc, char **argv, struct command *acmd, struct plugi
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -5392,7 +5387,7 @@ static int fw_commit(int argc, char **argv, struct command *acmd, struct plugin
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -5522,7 +5517,7 @@ static int ns_rescan(int argc, char **argv, struct command *acmd, struct plugin
 		return -EINVAL;
 	}
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -5600,7 +5595,7 @@ static int sanitize_cmd(int argc, char **argv, struct command *acmd, struct plug
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -5708,7 +5703,7 @@ static int sanitize_ns_cmd(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -5885,7 +5880,7 @@ static int show_registers(int argc, char **argv, struct command *acmd, struct pl
 		return -EINVAL;
 	}
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -6162,7 +6157,7 @@ static int get_register(int argc, char **argv, struct command *acmd, struct plug
 		return -EINVAL;
 	}
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -6508,7 +6503,7 @@ static int get_property(int argc, char **argv, struct command *acmd, struct plug
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -6554,7 +6549,7 @@ static int set_property(int argc, char **argv, struct command *acmd, struct plug
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -6644,8 +6639,8 @@ static int format_cmd(int argc, char **argv, struct command *acmd, struct plugin
 		.bs		= 0,
 	};
 
-	if (nvme_cfg.timeout != NVME_DEFAULT_IOCTL_TIMEOUT)
-		timeout_ms = nvme_cfg.timeout;
+	if (nvme_args.timeout != NVME_DEFAULT_IOCTL_TIMEOUT)
+		timeout_ms = nvme_args.timeout;
 
 	NVME_ARGS(opts,
 		  OPT_FLAG("ish",         'I', &cfg.ish,          ish),
@@ -6676,7 +6671,7 @@ static int format_cmd(int argc, char **argv, struct command *acmd, struct plugin
 		return err;
 	}
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -6920,7 +6915,7 @@ static int set_feature(int argc, char **argv, struct command *acmd, struct plugi
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -7063,7 +7058,7 @@ static int sec_send(int argc, char **argv, struct command *acmd, struct plugin *
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -7672,7 +7667,7 @@ static int dsm(int argc, char **argv, struct command *acmd, struct plugin *plugi
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -8037,7 +8032,7 @@ static int resv_acquire(int argc, char **argv, struct command *acmd, struct plug
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -8113,7 +8108,7 @@ static int resv_register(int argc, char **argv, struct command *acmd, struct plu
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -8196,7 +8191,7 @@ static int resv_release(int argc, char **argv, struct command *acmd, struct plug
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -8268,7 +8263,7 @@ static int resv_report(int argc, char **argv, struct command *acmd, struct plugi
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -8437,7 +8432,6 @@ static int submit_io(int opcode, char *command, const char *desc, int argc, char
 		  OPT_SHRT("dir-spec",          'S', &cfg.dspec,             dspec),
 		  OPT_BYTE("dsm",               'D', &cfg.dsmgmt,            dsm),
 		  OPT_FLAG("show-command",      'V', &cfg.show,              show),
-		  OPT_FLAG("dry-run",           'w', &nvme_cfg.dry_run,      dry_run),
 		  OPT_FLAG("latency",           't', &cfg.latency,           latency),
 		  OPT_FLAG("force",               0, &cfg.force,             force));
 
@@ -8592,7 +8586,7 @@ static int submit_io(int opcode, char *command, const char *desc, int argc, char
 		}
 	}
 
-	if (cfg.show || nvme_cfg.dry_run) {
+	if (cfg.show || nvme_args.dry_run) {
 		printf("opcode       : %02x\n", opcode);
 		printf("nsid         : %02x\n", cfg.nsid);
 		printf("flags        : %02x\n", 0);
@@ -8610,7 +8604,7 @@ static int submit_io(int opcode, char *command, const char *desc, int argc, char
 		printf("pif             : %02x\n", pif);
 		printf("sts             : %02x\n", sts);
 	}
-	if (nvme_cfg.dry_run)
+	if (nvme_args.dry_run)
 		return 0;
 
 	nvme_init_io(&cmd, opcode, cfg.nsid, cfg.start_block, buffer,
@@ -8840,7 +8834,7 @@ static int sec_recv(int argc, char **argv, struct command *acmd, struct plugin *
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -8927,7 +8921,7 @@ static int get_lba_status(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -9009,7 +9003,7 @@ static int capacity_mgmt(int argc, char **argv, struct command *acmd, struct plu
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -9354,7 +9348,6 @@ static int passthru(int argc, char **argv, bool admin,
 		  OPT_FILE("metadata",     'M', &cfg.metadata,     metadata),
 		  OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw_dump),
 		  OPT_FLAG("show-command", 's', &cfg.show_command, show),
-		  OPT_FLAG("dry-run",      'd', &nvme_cfg.dry_run, dry_run),
 		  OPT_FLAG("read",         'r', &cfg.read,         re),
 		  OPT_FLAG("write",        'w', &cfg.write,        wr),
 		  OPT_FLAG("latency",      'T', &cfg.latency,      latency));
@@ -9363,7 +9356,7 @@ static int passthru(int argc, char **argv, bool admin,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags_t);
+	err = validate_output_format(nvme_args.output_format, &flags_t);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -9438,7 +9431,7 @@ static int passthru(int argc, char **argv, bool admin,
 		}
 	}
 
-	if (cfg.show_command || nvme_cfg.dry_run) {
+	if (cfg.show_command || nvme_args.dry_run) {
 		printf("opcode       : %02x\n", cfg.opcode);
 		printf("flags        : %02x\n", cfg.flags);
 		printf("rsvd1        : %04x\n", cfg.rsvd);
@@ -9455,9 +9448,9 @@ static int passthru(int argc, char **argv, bool admin,
 		printf("cdw13        : %08x\n", cfg.cdw13);
 		printf("cdw14        : %08x\n", cfg.cdw14);
 		printf("cdw15        : %08x\n", cfg.cdw15);
-		printf("timeout_ms   : %08x\n", nvme_cfg.timeout);
+		printf("timeout_ms   : %08x\n", nvme_args.timeout);
 	}
-	if (nvme_cfg.dry_run)
+	if (nvme_args.dry_run)
 		return 0;
 
 	gettimeofday(&start_time, NULL);
@@ -9478,7 +9471,7 @@ static int passthru(int argc, char **argv, bool admin,
 		.cdw13		= cfg.cdw13,
 		.cdw14		= cfg.cdw14,
 		.cdw15		= cfg.cdw15,
-		.timeout_ms 	= nvme_cfg.timeout,
+		.timeout_ms 	= nvme_args.timeout,
 	};
 	if (admin)
 		err = nvme_submit_admin_passthru(hdl, &cmd);
@@ -10355,7 +10348,6 @@ static int tls_key(int argc, char **argv, struct command *acmd, struct plugin *p
 static int show_topology_cmd(int argc, char **argv, struct command *acmd, struct plugin *plugin)
 {
 	const char *desc = "Show the topology\n";
-	const char *output_format = "Output format: normal|json|binary|tabular";
 	const char *ranking = "Ranking order: namespace|ctrl|multipath";
 	nvme_print_flags_t flags;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
@@ -10379,7 +10371,7 @@ static int show_topology_cmd(int argc, char **argv, struct command *acmd, struct
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -10640,7 +10632,7 @@ static int get_mgmt_addr_list_log(int argc, char **argv, struct command *acmd, s
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -10687,7 +10679,7 @@ static int get_rotational_media_info_log(int argc, char **argv, struct command *
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -10773,7 +10765,7 @@ static int get_dispersed_ns_participating_nss_log(int argc, char **argv, struct
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -10922,7 +10914,7 @@ static int get_reachability_groups_log(int argc, char **argv, struct command *ac
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -11033,7 +11025,7 @@ static int get_reachability_associations_log(int argc, char **argv, struct comma
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -11114,7 +11106,7 @@ static int get_host_discovery_log(int argc, char **argv, struct command *acmd, s
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -11188,7 +11180,7 @@ static int get_ave_discovery_log(int argc, char **argv, struct command *acmd, st
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -11264,7 +11256,7 @@ static int get_pull_model_ddc_req_log(int argc, char **argv, struct command *acm
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
diff --git a/nvme.h b/nvme.h
index df38f39979..6703ed3233 100644
--- a/nvme.h
+++ b/nvme.h
@@ -54,29 +54,42 @@ enum nvme_cli_topo_ranking {
 
 #define SYS_NVME "/sys/class/nvme"
 
-struct nvme_config {
+struct nvme_args {
 	char *output_format;
 	int verbose;
 	__u32 timeout;
 	bool dry_run;
 	bool no_retries;
+	bool no_ioctl_probing;
 	unsigned int output_format_ver;
 };
 
+#ifdef CONFIG_JSONC
+#define DESC_OUTPUT_FORMAT "Output format: normal|json|binary|tabular"
+#else /* CONFIG_JSONC */
+#define DESC_OUTPUT_FORMAT "Output format: normal|binary|tabular"
+#endif /* CONFIG_JSONC */
+
 /*
  * the ordering of the arguments matters, as the argument parser uses the first match, thus any
  * command which defines -t shorthand will match first.
  */
 #define NVME_ARGS(n, ...)                                                              \
 	struct argconfig_commandline_options n[] = {                                   \
-		OPT_INCR("verbose",      'v', &nvme_cfg.verbose,       verbose),       \
-		OPT_FMT("output-format", 'o', &nvme_cfg.output_format, output_format), \
+		OPT_INCR("verbose",      'v', &nvme_args.verbose,                      \
+                         "Increase output verbosity"),                                 \
+		OPT_FMT("output-format", 'o', &nvme_args.output_format,                \
+                         DESC_OUTPUT_FORMAT),                                          \
 		##__VA_ARGS__,                                                         \
-		OPT_UINT("timeout",      't', &nvme_cfg.timeout,       timeout),       \
-		OPT_FLAG("dry-run",        0, &nvme_cfg.dry_run,       dry_run),       \
-		OPT_FLAG("no-retries",     0, &nvme_cfg.no_retries,                    \
-			 "disable retry logic on errors\n"),                           \
-		OPT_UINT("output-format-version", 0, &nvme_cfg.output_format_ver,      \
+		OPT_UINT("timeout",      't', &nvme_args.timeout,                      \
+                         "timeout value, in milliseconds"),                            \
+		OPT_FLAG("dry-run",        0, &nvme_args.dry_run,                      \
+                         "show command instead of executing"),                         \
+		OPT_FLAG("no-retries",     0, &nvme_args.no_retries,                   \
+			 "disable retry logic on errors"),                             \
+		OPT_FLAG("no-ioctl-probing", 0, &nvme_args.no_ioctl_probing,           \
+			 "disable 64-bit IOCTL support probing"),                      \
+		OPT_UINT("output-format-version", 0, &nvme_args.output_format_ver,     \
 			 "output format version: 1|2"),                                \
 		OPT_END()                                                              \
 	}
@@ -107,12 +120,8 @@ static inline DEFINE_CLEANUP_FUNC(
 	cleanup_nvme_transport_handle, struct nvme_transport_handle *, nvme_close)
 #define _cleanup_nvme_transport_handle_ __cleanup__(cleanup_nvme_transport_handle)
 
-extern const char *output_format;
-extern const char *timeout;
-extern const char *verbose;
-extern const char *dry_run;
 extern const char *uuid_index;
-extern struct nvme_config nvme_cfg;
+extern struct nvme_args nvme_args;
 
 int validate_output_format(const char *format, nvme_print_flags_t *flags);
 bool nvme_is_output_format_json(void);
diff --git a/nvmf-autoconnect/udev-rules/70-nvmf-autoconnect.rules.in b/nvmf-autoconnect/udev-rules/70-nvmf-autoconnect.rules.in
index d353dc897a..3890263ec6 100644
--- a/nvmf-autoconnect/udev-rules/70-nvmf-autoconnect.rules.in
+++ b/nvmf-autoconnect/udev-rules/70-nvmf-autoconnect.rules.in
@@ -7,24 +7,24 @@
 ACTION!="change", GOTO="autoconnect_end"
 
 # For backwards compatibility. Make sure HOST_IFACE is not an empty string.
-ENV{NVME_HOST_IFACE}=="", ENV{NVME_HOST_IFACE}="none"
+SUBSYSTEM=="nvme", ENV{NVME_HOST_IFACE}=="", ENV{NVME_HOST_IFACE}="none"
 
 # Events from persistent discovery controllers or nvme-fc transport events
 # NVME_AEN:
 #   type 0x2 (NOTICE) info 0xf0 (DISCOVERY_LOG_CHANGE) log-page-id 0x70 (DISCOVERY_LOG_PAGE)
-ACTION=="change", SUBSYSTEM=="nvme", ENV{NVME_AEN}=="0x70f002", \
+SUBSYSTEM=="nvme", ENV{NVME_AEN}=="0x70f002", \
   ENV{NVME_TRTYPE}=="*", ENV{NVME_TRADDR}=="*", \
   ENV{NVME_TRSVCID}=="*", ENV{NVME_HOST_TRADDR}=="*", ENV{NVME_HOST_IFACE}=="*", \
   RUN+="@SYSTEMCTL@ --no-block restart nvmf-connect@--device\x3d$kernel\t--transport\x3d$env{NVME_TRTYPE}\t--traddr\x3d$env{NVME_TRADDR}\t--trsvcid\x3d$env{NVME_TRSVCID}\t--host-traddr\x3d$env{NVME_HOST_TRADDR}\t--host-iface\x3d$env{NVME_HOST_IFACE}.service"
 
 # nvme-fc transport generated events (old-style for compatibility)
-ACTION=="change", SUBSYSTEM=="fc", ENV{FC_EVENT}=="nvmediscovery", \
+SUBSYSTEM=="fc", ENV{FC_EVENT}=="nvmediscovery", \
   ENV{NVMEFC_HOST_TRADDR}=="*",  ENV{NVMEFC_TRADDR}=="*", \
   RUN+="@SYSTEMCTL@ --no-block restart nvmf-connect@--device\x3dnone\t--transport\x3dfc\t--traddr\x3d$env{NVMEFC_TRADDR}\t--trsvcid\x3dnone\t--host-traddr\x3d$env{NVMEFC_HOST_TRADDR}.service"
 
 # A discovery controller just (re)connected, re-read the discovery log change to
 # check if there were any changes since it was last connected.
-ACTION=="change", SUBSYSTEM=="nvme", ENV{NVME_EVENT}=="rediscover", ATTR{cntrltype}=="discovery", \
+SUBSYSTEM=="nvme", ENV{NVME_EVENT}=="rediscover", ATTR{cntrltype}=="discovery", \
   ENV{NVME_TRTYPE}=="*", ENV{NVME_TRADDR}=="*", \
   ENV{NVME_TRSVCID}=="*", ENV{NVME_HOST_TRADDR}=="*", ENV{NVME_HOST_IFACE}=="*", \
   RUN+="@SYSTEMCTL@ --no-block restart nvmf-connect@--device\x3d$kernel\t--transport\x3d$env{NVME_TRTYPE}\t--traddr\x3d$env{NVME_TRADDR}\t--trsvcid\x3d$env{NVME_TRSVCID}\t--host-traddr\x3d$env{NVME_HOST_TRADDR}\t--host-iface\x3d$env{NVME_HOST_IFACE}.service"
diff --git a/plugins/amzn/amzn-nvme.c b/plugins/amzn/amzn-nvme.c
index 014a3c3ad8..fdb48b2a71 100644
--- a/plugins/amzn/amzn-nvme.c
+++ b/plugins/amzn/amzn-nvme.c
@@ -485,11 +485,8 @@ static int get_stats(int argc, char **argv, struct command *acmd,
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format,
-			"Output Format: normal|json"),
-		OPT_FLAG("details", 'd', &detail, "Detail IO histogram of each block size ranges"),
-		OPT_END()};
+	NVME_ARGS(opts,
+		OPT_FLAG("details", 'd', &detail, "Detail IO histogram of each block size ranges"));
 
 	rc = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (rc)
diff --git a/plugins/dapustor/dapustor-nvme.c b/plugins/dapustor/dapustor-nvme.c
index 268f45c101..894c9f7d17 100644
--- a/plugins/dapustor/dapustor-nvme.c
+++ b/plugins/dapustor/dapustor-nvme.c
@@ -513,6 +513,7 @@ static int dapustor_additional_smart_log(int argc, char **argv, struct command *
 	struct nvme_extended_additional_smart_log ext_smart_log;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	struct nvme_additional_smart_log smart_log;
+	nvme_print_flags_t flags;
 	bool has_ext = false;
 	int err;
 
@@ -526,21 +527,25 @@ static int dapustor_additional_smart_log(int argc, char **argv, struct command *
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace),
 		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw),
-		OPT_FLAG_JSON("json",    'j', &cfg.json,         json),
-		OPT_END()
-	};
+		OPT_FLAG_JSON("json",    'j', &cfg.json,         json));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
+	err = validate_output_format(nvme_args.output_format, &flags);
+	if (err < 0) {
+		nvme_show_error("Invalid output format");
+		return err;
+	}
+
 	err = dapustor_additional_smart_log_data(hdl, &smart_log,
 						 &ext_smart_log, &has_ext);
 	if (!err) {
-		if (cfg.json)
+		if (flags & JSON || cfg.json)
 			show_dapustor_smart_log_jsn(&smart_log, &ext_smart_log,
 						    cfg.namespace_id,
 						    nvme_transport_handle_get_name(hdl),
diff --git a/plugins/dera/dera-nvme.c b/plugins/dera/dera-nvme.c
index 0ffe0e4cb5..ba03d4682b 100644
--- a/plugins/dera/dera-nvme.c
+++ b/plugins/dera/dera-nvme.c
@@ -123,9 +123,7 @@ static int get_status(int argc, char **argv, struct command *acmd, struct plugin
 	struct nvme_dera_smart_info_log log;
 	int err;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
diff --git a/plugins/fdp/fdp.c b/plugins/fdp/fdp.c
index 61f86880e0..a6c4f8b90c 100644
--- a/plugins/fdp/fdp.c
+++ b/plugins/fdp/fdp.c
@@ -36,30 +36,25 @@ static int fdp_configs(int argc, char **argv, struct command *acmd,
 
 	struct config {
 		__u16	egid;
-		char	*output_format;
 		bool	human_readable;
 		bool	raw_binary;
 	};
 
 	struct config cfg = {
 		.egid		= 0,
-		.output_format	= "normal",
 		.raw_binary	= false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("endgrp-id",      'e', &cfg.egid,           egid),
-		OPT_FMT("output-format",   'o', &cfg.output_format,  output_format),
 		OPT_FLAG("raw-binary",     'b', &cfg.raw_binary,     raw),
-		OPT_FLAG("human-readable", 'H', &cfg.human_readable, human_readable),
-		OPT_END()
-	};
+		OPT_FLAG("human-readable", 'H', &cfg.human_readable, human_readable));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0)
 		return err;
 
@@ -118,22 +113,18 @@ static int fdp_usage(int argc, char **argv, struct command *acmd, struct plugin
 
 	struct config cfg = {
 		.egid		= 0,
-		.output_format	= "normal",
 		.raw_binary	= false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("endgrp-id",    'e', &cfg.egid,          egid),
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,    raw),
-		OPT_END()
-	};
+		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,    raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0)
 		return err;
 
@@ -188,12 +179,9 @@ static int fdp_stats(int argc, char **argv, struct command *acmd, struct plugin
 		.raw_binary	= false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("endgrp-id",    'e', &cfg.egid,          egid),
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,    raw),
-		OPT_END()
-	};
+		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,    raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -240,30 +228,25 @@ static int fdp_events(int argc, char **argv, struct command *acmd, struct plugin
 	struct config {
 		__u16	egid;
 		bool	host_events;
-		char	*output_format;
 		bool	raw_binary;
 	};
 
 	struct config cfg = {
 		.egid		= 0,
 		.host_events =	false,
-		.output_format	= "normal",
 		.raw_binary	= false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("endgrp-id",    'e', &cfg.egid,          egid),
 		OPT_FLAG("host-events",  'E', &cfg.host_events,   host_events),
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,    raw),
-		OPT_END()
-	};
+		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,    raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0)
 		return err;
 
@@ -306,27 +289,22 @@ static int fdp_status(int argc, char **argv, struct command *acmd, struct plugin
 
 	struct config {
 		__u32	nsid;
-		char	*output_format;
 		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.output_format	= "normal",
 		.raw_binary	= false,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_UINT("namespace-id", 'n', &cfg.nsid,			namespace_id),
-		OPT_FMT("output-format", 'o', &cfg.output_format,	output_format),
-		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,		raw),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_UINT("namespace-id", 'n', &cfg.nsid,	namespace_id),
+		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,	raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0)
 		return err;
 
@@ -390,11 +368,9 @@ static int fdp_update(int argc, char **argv, struct command *acmd, struct plugin
 		.pids = "",
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id",  'n', &cfg.nsid,	namespace_id),
-		OPT_LIST("pids",          'p', &cfg.pids,	_pids),
-		OPT_END()
-	};
+		OPT_LIST("pids",          'p', &cfg.pids,	_pids));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -461,14 +437,12 @@ static int fdp_set_events(int argc, char **argv, struct command *acmd, struct pl
 		.sv	= false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id",     'n', &cfg.nsid,         nsid),
 		OPT_SHRT("placement-handle", 'p', &cfg.ph,           ph),
 		OPT_FLAG("enable",           'e', &cfg.enable,       enable),
 		OPT_FLAG("save",             's', &cfg.sv,		     sv),
-		OPT_LIST("event-types",      't', &cfg.event_types,  event_types),
-		OPT_END()
-	};
+		OPT_LIST("event-types",      't', &cfg.event_types,  event_types));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -539,13 +513,10 @@ static int fdp_feature(int argc, char **argv, struct command *acmd, struct plugi
 		.endgid = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_SHRT("endgrp-id", 'e', &cfg.endgid, endurance_group),
 		OPT_BYTE("enable-conf-idx", 'c', &cfg.fdpcidx, enable_conf_idx),
-		OPT_FLAG("disable", 'd', &cfg.disable, disable),
-		OPT_INCR("verbose",      'v', &nvme_cfg.verbose, verbose),
-		OPT_END()
-	};
+		OPT_FLAG("disable", 'd', &cfg.disable, disable));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
diff --git a/plugins/huawei/huawei-nvme.c b/plugins/huawei/huawei-nvme.c
index 8ae01c49c1..8f55909386 100644
--- a/plugins/huawei/huawei-nvme.c
+++ b/plugins/huawei/huawei-nvme.c
@@ -303,18 +303,8 @@ static int huawei_list(int argc, char **argv, struct command *acmd,
 	unsigned int huawei_num = 0;
 	nvme_print_flags_t fmt;
 	const char *desc = "Retrieve basic information for the given huawei device";
-	struct config {
-		char *output_format;
-	};
 
-	struct config cfg = {
-		.output_format = "normal",
-	};
-
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "Output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	if (!ctx)
 		return -ENOMEM;
@@ -323,7 +313,7 @@ static int huawei_list(int argc, char **argv, struct command *acmd,
 	if (ret)
 		return ret;
 
-	ret = validate_output_format(cfg.output_format, &fmt);
+	ret = validate_output_format(nvme_args.output_format, &fmt);
 	if (ret < 0 || (fmt != JSON && fmt != NORMAL))
 		return ret;
 
diff --git a/plugins/ibm/ibm-nvme.c b/plugins/ibm/ibm-nvme.c
index d0c2107ce9..2407049a76 100644
--- a/plugins/ibm/ibm-nvme.c
+++ b/plugins/ibm/ibm-nvme.c
@@ -4,6 +4,7 @@
 #include <unistd.h>
 
 #include "common.h"
+#include "nvme.h"
 #include "nvme-print.h"
 #include "plugin.h"
 
@@ -236,10 +237,8 @@ static int get_ibm_addi_smart_log(int argc, char **argv, struct command *cmd, st
 		.raw_binary = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -368,10 +367,8 @@ static int get_ibm_vpd_log(int argc, char **argv, struct command *cmd, struct pl
 		.raw_binary = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err < 0)
@@ -549,13 +546,10 @@ static int get_ibm_persistent_event_log(int argc, char **argv,
 		.raw_binary	= false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("action",       'a', &cfg.action,        action),
 		OPT_UINT("log_len",	 'l', &cfg.log_len,	  log_len),
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,    raw_use),
-		OPT_END()
-	};
+		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,    raw_use));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
diff --git a/plugins/innogrit/innogrit-nvme.c b/plugins/innogrit/innogrit-nvme.c
index 6b7fe4206a..957a2fc9d4 100644
--- a/plugins/innogrit/innogrit-nvme.c
+++ b/plugins/innogrit/innogrit-nvme.c
@@ -181,9 +181,7 @@ static int innogrit_geteventlog(int argc, char **argv,
 	time_t timep;
 	int ret = -1;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -228,9 +226,7 @@ static int innogrit_vsc_getcdump(int argc, char **argv, struct command *acmd,
 	time_t timep;
 	int ret = -1;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
diff --git a/plugins/inspur/inspur-nvme.c b/plugins/inspur/inspur-nvme.c
index 041a0dede8..b4bf161e14 100644
--- a/plugins/inspur/inspur-nvme.c
+++ b/plugins/inspur/inspur-nvme.c
@@ -212,7 +212,7 @@ static int nvme_get_vendor_log(int argc, char **argv, struct command *acmd, stru
 	__u8 local_mem[BYTE_OF_4K];
 	int err;
 
-	OPT_ARGS(opts) = { OPT_END() };
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
diff --git a/plugins/intel/intel-nvme.c b/plugins/intel/intel-nvme.c
index b3ee75973f..8eade70504 100644
--- a/plugins/intel/intel-nvme.c
+++ b/plugins/intel/intel-nvme.c
@@ -344,6 +344,7 @@ static int get_additional_smart_log(int argc, char **argv, struct command *acmd,
 	struct nvme_additional_smart_log smart_log;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
+	nvme_print_flags_t flags;
 	int err;
 
 	struct config {
@@ -356,20 +357,24 @@ static int get_additional_smart_log(int argc, char **argv, struct command *acmd,
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace),
 		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw),
-		OPT_FLAG_JSON("json",    'j', &cfg.json,         json),
-		OPT_END()
-	};
+		OPT_FLAG_JSON("json",    'j', &cfg.json,         json));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
+	err = validate_output_format(nvme_args.output_format, &flags);
+	if (err < 0) {
+		nvme_show_error("Invalid output format");
+		return err;
+	}
+
 	err = nvme_get_log_simple(hdl, 0xca, &smart_log, sizeof(smart_log));
 	if (!err) {
-		if (cfg.json)
+		if (flags & JSON || cfg.json)
 			show_intel_smart_log_jsn(&smart_log, cfg.namespace_id,
 						 nvme_transport_handle_get_name(hdl));
 		else if (!cfg.raw_binary)
@@ -399,10 +404,8 @@ static int get_market_log(int argc, char **argv, struct command *acmd, struct pl
 	struct config cfg = {
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -461,10 +464,8 @@ static int get_temp_stats_log(int argc, char **argv, struct command *acmd, struc
 	struct config cfg = {
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1030,6 +1031,7 @@ static int get_lat_stats_log(int argc, char **argv, struct command *acmd, struct
 	__u8 data[NAND_LAT_STATS_LEN];
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
+	nvme_print_flags_t flags;
 	int err;
 
 	const char *desc = "Get Intel Latency Statistics log and show it.";
@@ -1048,17 +1050,21 @@ static int get_lat_stats_log(int argc, char **argv, struct command *acmd, struct
 	struct config cfg = {
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FLAG("write",	'w', &cfg.write,	write),
 		OPT_FLAG("raw-binary",	'b', &cfg.raw_binary,	raw),
-		OPT_FLAG_JSON("json",	'j', &cfg.json,		json),
-		OPT_END()
-	};
+		OPT_FLAG_JSON("json",	'j', &cfg.json,		json));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
+	err = validate_output_format(nvme_args.output_format, &flags);
+	if (err < 0) {
+		nvme_show_error("Invalid output format");
+		return err;
+	}
+
 	/* For optate, latency stats are deleted every time their LID is pulled.
 	 * Therefore, we query the longest lat_stats log page first.
 	 */
@@ -1105,7 +1111,7 @@ static int get_lat_stats_log(int argc, char **argv, struct command *acmd, struct
 		       sizeof(struct intel_lat_stats));
 	}
 
-	if (cfg.json)
+	if (flags & JSON || cfg.json)
 		json_lat_stats(cfg.write);
 	else if (!cfg.raw_binary)
 		show_lat_stats(cfg.write);
@@ -1367,15 +1373,13 @@ static int get_internal_log(int argc, char **argv, struct command *acmd,
 		.core = -1
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("log",          'l', &cfg.log,          log),
 		OPT_INT("region",        'r', &cfg.core,         core),
 		OPT_INT("nlognum",       'm', &cfg.lnum,         nlognum),
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
 		OPT_FILE("output-file",  'o', &cfg.file,         file),
-		OPT_FLAG("verbose-nlog", 'v', &cfg.verbose,      verbose),
-		OPT_END()
-	};
+		OPT_FLAG("verbose-nlog", 'v', &cfg.verbose,      verbose));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -1633,12 +1637,10 @@ static int set_lat_stats_thresholds(int argc, char **argv,
 		.bucket_thresholds = "",
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FLAG("write",      'w', &cfg.write, write),
 		OPT_LIST("bucket-thresholds", 't', &cfg.bucket_thresholds,
-			 bucket_thresholds),
-		OPT_END()
-	};
+			 bucket_thresholds));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 
diff --git a/plugins/lm/lm-nvme.c b/plugins/lm/lm-nvme.c
index a8041e15dc..0e9a7a296a 100644
--- a/plugins/lm/lm-nvme.c
+++ b/plugins/lm/lm-nvme.c
@@ -80,13 +80,11 @@ static int lm_create_cdq(int argc, char **argv, struct command *acmd, struct plu
 		.file = NULL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("size",	's', &cfg.sz,		sz),
 		OPT_SHRT("cntlid",	'c', &cfg.cntlid,	cntlid),
 		OPT_BYTE("queue-type",	'q', &cfg.qt,		qt),
-		OPT_FLAG("consent",	  0, &cfg.consent,	consent),
-		OPT_END()
-	};
+		OPT_FLAG("consent",	  0, &cfg.consent,	consent));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -138,10 +136,8 @@ static int lm_delete_cdq(int argc, char **argv, struct command *acmd, struct plu
 		.cdqid = 0
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_SHRT("cdqid", 'C', &cfg.cdqid, cdqid),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_SHRT("cdqid", 'C', &cfg.cdqid, cdqid));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -198,14 +194,12 @@ static int lm_track_send(int argc, char **argv, struct command *acmd, struct plu
 		.stop = false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("sel",		's', &cfg.sel,   sel),
 		OPT_BYTE("mos",		'm', &cfg.mos,   mos),
 		OPT_SHRT("cdqid",	'C', &cfg.cdqid, cdqid),
 		OPT_FLAG("start",	  0, &cfg.start, start),
-		OPT_FLAG("stop",	  0, &cfg.stop,  stop),
-		OPT_END()
-	};
+		OPT_FLAG("stop",	  0, &cfg.stop,  stop));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -313,7 +307,7 @@ static int lm_migration_send(int argc, char **argv, struct command *acmd, struct
 		.dudmq = false
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("sel",		's', &cfg.sel, sel),
 		OPT_SHRT("cntlid",	'c', &cfg.cntlid, cntlid),
 		OPT_BYTE("stype",	't', &cfg.stype, stype),
@@ -324,9 +318,7 @@ static int lm_migration_send(int argc, char **argv, struct command *acmd, struct
 		OPT_BYTE("uidx",	'u', &cfg.uidx, uidx),
 		OPT_LONG("offset",	'o', &cfg.offset, offset),
 		OPT_UINT("numd",	'n', &cfg.numd, numd),
-		OPT_FILE("input-file",	'f', &cfg.input, input),
-		OPT_END()
-	};
+		OPT_FILE("input-file",	'f', &cfg.input, input));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -431,7 +423,6 @@ static int lm_migration_recv(int argc, char **argv, struct command *acmd, struct
 		__u64 offset;
 		__u32 numd;
 		char  *output;
-		char  *output_format;
 		bool  human_readable;
 	};
 
@@ -444,11 +435,10 @@ static int lm_migration_recv(int argc, char **argv, struct command *acmd, struct
 		.offset = 0,
 		.numd = 0,
 		.output = NULL,
-		.output_format = "normal",
 		.human_readable = false
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("sel",			's', &cfg.sel, sel),
 		OPT_SHRT("cntlid",		'c', &cfg.cntlid, cntlid),
 		OPT_BYTE("csuuidi",		'U', &cfg.csuuidi, csuuidi),
@@ -457,22 +447,19 @@ static int lm_migration_recv(int argc, char **argv, struct command *acmd, struct
 		OPT_LONG("offset",		'o', &cfg.offset, offset),
 		OPT_UINT("numd",		'n', &cfg.numd, numd),
 		OPT_FILE("output-file",		'f', &cfg.output, output),
-		OPT_FMT("output-format",	  0,   &cfg.output_format, output_format),
-		OPT_FLAG("human-readable",	'H', &cfg.human_readable, human_readable_info),
-		OPT_END()
-	};
+		OPT_FLAG("human-readable",	'H', &cfg.human_readable, human_readable_info));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
 	}
 
-	if (cfg.output_format && cfg.offset != 0 && !(flags & BINARY)) {
+	if (nvme_args.output_format && cfg.offset != 0 && !(flags & BINARY)) {
 		nvme_show_error("cannot parse non-zero offset");
 		return -EINVAL;
 	}
@@ -552,12 +539,10 @@ static int lm_set_cdq(int argc, char **argv, struct command *acmd, struct plugin
 		.tpt = -1,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_SHRT("cdqid",	'C', &cfg.cdqid, cdqid),
 		OPT_UINT("hp",		'H', &cfg.hp, hp),
-		OPT_UINT("tpt",		'T', &cfg.tpt, tpt),
-		OPT_END()
-	};
+		OPT_UINT("tpt",		'T', &cfg.tpt, tpt));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -589,25 +574,20 @@ static int lm_get_cdq(int argc, char **argv, struct command *acmd, struct plugin
 
 	struct config {
 		__u16 cdqid;
-		char *output_format;
 	};
 
 	struct config cfg = {
 		.cdqid = 0,
-		.output_format  = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_SHRT("cdqid",	 'C', &cfg.cdqid,	  cdqid),
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_SHRT("cdqid",	 'C', &cfg.cdqid,	  cdqid));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
diff --git a/plugins/memblaze/memblaze-nvme.c b/plugins/memblaze/memblaze-nvme.c
index 58e9dc3dbe..3b9b047f7d 100644
--- a/plugins/memblaze/memblaze-nvme.c
+++ b/plugins/memblaze/memblaze-nvme.c
@@ -432,11 +432,9 @@ static int mb_get_additional_smart_log(int argc, char **argv, struct command *ac
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace),
-		OPT_FLAG("raw-binary",	 'b', &cfg.raw_binary,	  raw),
-		OPT_END()
-	};
+		OPT_FLAG("raw-binary",	 'b', &cfg.raw_binary,	  raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -482,9 +480,7 @@ static int mb_get_powermanager_status(int argc, char **argv, struct command *acm
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	int err;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -525,11 +521,9 @@ static int mb_set_powermanager_status(int argc, char **argv, struct command *acm
 		.save		  = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("value",		 'v', &cfg.value,		 value),
-		OPT_FLAG("save",		 's', &cfg.save,		 save),
-		OPT_END()
-	};
+		OPT_FLAG("save",		 's', &cfg.save,		 save));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -578,10 +572,8 @@ static int mb_set_high_latency_log(int argc, char **argv, struct command *acmd,
 		.value = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_LIST("param", 'p', &cfg.param, param),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_LIST("param", 'p', &cfg.param, param));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -708,9 +700,7 @@ static int mb_high_latency_log_print(int argc, char **argv, struct command *acmd
 	FILE *fdi = NULL;
 	int err;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -780,11 +770,9 @@ static int mb_selective_download(int argc, char **argv, struct command *acmd, st
 		.select = "\0",
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_STRING("fw", 'f', "FILE", &cfg.fw, fw),
-		OPT_STRING("select", 's', "flag", &cfg.select, select),
-		OPT_END()
-	};
+		OPT_STRING("select", 's', "flag", &cfg.select, select));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -984,10 +972,8 @@ static int mb_lat_stats_log_print(int argc, char **argv, struct command *acmd, s
 		.write = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("write", 'w', &cfg.write, write),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FLAG("write", 'w', &cfg.write, write));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1027,9 +1013,7 @@ static int memblaze_clear_error_log(int argc, char **argv, struct command *acmd,
 		.save		= 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1563,9 +1547,8 @@ static int mb_get_smart_log_add(int argc, char **argv, struct command *acmd, str
 
 	struct config cfg = {0};
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, "dump the whole log buffer in binary format"),
-		OPT_END()};
+	NVME_ARGS(opts,
+		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, "dump the whole log buffer in binary format"));
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
@@ -1710,7 +1693,7 @@ static int mb_set_latency_feature(int argc, char **argv, struct command *acmd, s
 
 	struct config cfg = {0};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("sel-perf-log", 's', &cfg.perf_monitor,
 			 "Select features to turn on, default: Disable\n"
 			 "    bit 0: latency statistics\n"
@@ -1726,8 +1709,7 @@ static int mb_set_latency_feature(int argc, char **argv, struct command *acmd, s
 		OPT_UINT("set-write-threshold", 'w', &cfg.write_threshold,
 		  "set write high latency log threshold, it's a 0-based value and unit is 10ms"),
 		OPT_UINT("set-trim-threshold", 't', &cfg.de_allocate_trim_threshold,
-		  "set trim high latency log threshold, it's a 0-based value and unit is 10ms"),
-		OPT_END()};
+		  "set trim high latency log threshold, it's a 0-based value and unit is 10ms"));
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
@@ -1766,8 +1748,7 @@ static int mb_get_latency_feature(int argc, char **argv, struct command *acmd, s
 
 	// Get the configuration
 
-	OPT_ARGS(opts) = {
-		OPT_END()};
+	NVME_ARGS(opts);
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
@@ -1914,12 +1895,11 @@ static int mb_get_latency_stats(int argc, char **argv, struct command *acmd, str
 
 	struct config cfg = {0};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FLAG("raw-binary",
 			'b',
 			&cfg.raw_binary,
-			"dump the whole log buffer in binary format"),
-		OPT_END()};
+			"dump the whole log buffer in binary format"));
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
@@ -2020,12 +2000,11 @@ static int mb_get_high_latency_log(int argc, char **argv, struct command *acmd,
 
 	struct config cfg = {0};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FLAG("raw-binary",
 			'b',
 			&cfg.raw_binary,
-			"dump the whole log buffer in binary format"),
-		OPT_END()};
+			"dump the whole log buffer in binary format"));
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
@@ -2263,7 +2242,7 @@ static int mb_get_performance_stats(int argc, char **argv, struct command *acmd,
 
 	struct config cfg = {.duration = 1, .raw_binary = false};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("duration",
 			'd',
 			&cfg.duration,
@@ -2271,8 +2250,7 @@ static int mb_get_performance_stats(int argc, char **argv, struct command *acmd,
 		OPT_FLAG("raw-binary",
 			'b',
 			&cfg.raw_binary,
-			"dump the whole log buffer in binary format"),
-		OPT_END()};
+			"dump the whole log buffer in binary format"));
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
diff --git a/plugins/micron/micron-nvme.c b/plugins/micron/micron-nvme.c
index 40a8cee84d..e9399baf36 100644
--- a/plugins/micron/micron-nvme.c
+++ b/plugins/micron/micron-nvme.c
@@ -594,11 +594,9 @@ static int micron_selective_download(int argc, char **argv,
 		.select = "\0",
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_STRING("fw", 'f', "FILE", &cfg.fw, fw),
-		OPT_STRING("select", 's', "flag", &cfg.select, select),
-		OPT_END()
-	};
+		OPT_STRING("select", 's', "flag", &cfg.select, select));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -719,12 +717,10 @@ static int micron_smbus_option(int argc, char **argv,
 		.status = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_STRING("option", 'o', "option", &opt.option, option),
 		OPT_UINT("value", 'v',	&opt.value, value),
-		OPT_UINT("save", 's', &opt.save, save),
-		OPT_END()
-	};
+		OPT_UINT("save", 's', &opt.save, save));
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &model);
 	if (err < 0)
@@ -777,6 +773,7 @@ static int micron_temp_stats(int argc, char **argv, struct command *acmd,
 	unsigned int tempSensors[SensorCount] = { 0 };
 	const char *desc = "Retrieve Micron temperature info for the given device ";
 	const char *fmt = "output format normal|json";
+	nvme_print_flags_t flags;
 	struct format {
 		char *fmt;
 	};
@@ -788,10 +785,8 @@ static int micron_temp_stats(int argc, char **argv, struct command *acmd,
 	struct json_object *logPages;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	OPT_ARGS(opts) = {
-		OPT_FMT("format", 'f', &cfg.fmt, fmt),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -799,7 +794,13 @@ static int micron_temp_stats(int argc, char **argv, struct command *acmd,
 		return -1;
 	}
 
-	if (!strcmp(cfg.fmt, "json"))
+	err = validate_output_format(nvme_args.output_format, &flags);
+	if (err < 0) {
+		nvme_show_error("Invalid output format");
+		return err;
+	}
+
+	if (!strcmp(cfg.fmt, "json") || flags & JSON)
 		is_json = true;
 
 	err = nvme_get_log_smart(hdl, NVME_NSID_ALL, &smart_log);
@@ -909,6 +910,7 @@ static int micron_pcie_stats(int argc, char **argv,
 	char strTempFile[1024], strTempFile2[1024], cmdbuf[1024];
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
+	nvme_print_flags_t flags;
 	char *businfo = NULL;
 	char *devicename = NULL;
 	char tdevice[NAME_MAX] = { 0 };
@@ -933,10 +935,8 @@ static int micron_pcie_stats(int argc, char **argv,
 	__u32 correctable_errors;
 	__u32 uncorrectable_errors;
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("format", 'f', &cfg.fmt, fmt),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -944,6 +944,12 @@ static int micron_pcie_stats(int argc, char **argv,
 		return -1;
 	}
 
+	err = validate_output_format(nvme_args.output_format, &flags);
+	if (err < 0) {
+		nvme_show_error("Invalid output format");
+		return err;
+	}
+
 	/* pull log details based on the model name */
 	if (sscanf(argv[optind], "/dev/nvme%d", &ctrlIdx) != 1)
 		ctrlIdx = 0;
@@ -953,7 +959,7 @@ static int micron_pcie_stats(int argc, char **argv,
 		goto out;
 	}
 
-	if (!strcmp(cfg.fmt, "normal"))
+	if (!strcmp(cfg.fmt, "normal") || flags & NORMAL)
 		is_json = false;
 
 	if (eModel == M5407) {
@@ -1106,9 +1112,7 @@ static int micron_clear_pcie_correctable_errors(int argc, char **argv,
 	__u64 result = 0;
 	__u8 fid = MICRON_FEATURE_CLEAR_PCI_CORRECTABLE_ERRORS;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &model);
 	if (err < 0)
@@ -1820,10 +1824,8 @@ static int micron_nand_stats(int argc, char **argv,
 		.fmt = "json",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("format", 'f', &cfg.fmt, fmt),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -1965,10 +1967,8 @@ static int micron_smart_ext_log(int argc, char **argv,
 	struct format cfg = {
 		.fmt = "json",
 	};
-	OPT_ARGS(opts) = {
-		OPT_FMT("format", 'f', &cfg.fmt, fmt),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -2018,10 +2018,8 @@ static int micron_work_load_log(int argc, char **argv, struct command *acmd, str
 	struct format cfg = {
 		.fmt = "json",
 	};
-	OPT_ARGS(opts) = {
-		OPT_FMT("format", 'f', &cfg.fmt, fmt),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -2070,10 +2068,8 @@ static int micron_vendor_telemetry_log(int argc, char **argv,
 	struct format cfg = {
 		.fmt = "json",
 	};
-	OPT_ARGS(opts) = {
-		OPT_FMT("format", 'f', &cfg.fmt, fmt),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -2477,10 +2473,8 @@ static int micron_drive_info(int argc, char **argv, struct command *acmd,
 		.fmt = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("format", 'f', &cfg.fmt, fmt),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &model);
 	if (err < 0)
@@ -2796,10 +2790,8 @@ static int micron_fw_activation_history(int argc, char **argv, struct command *a
 		.fmt = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("format", 'f', &cfg.fmt, fmt),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &eModel);
 	if (err < 0)
@@ -2904,12 +2896,10 @@ static int micron_latency_stats_track(int argc, char **argv, struct command *acm
 		.threshold = 0
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_STRING("option", 'o', "option", &opt.option, option),
 		OPT_STRING("command", 'c', "command", &opt.command, cmdstr),
-		OPT_UINT("threshold", 't', &opt.threshold, thrtime),
-		OPT_END()
-	};
+		OPT_UINT("threshold", 't', &opt.threshold, thrtime));
 
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &model);
@@ -3036,9 +3026,7 @@ static int micron_latency_stats_logs(int argc, char **argv, struct command *acmd
 	int err = -1;
 	const char *desc = "Display Latency tracking log information";
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &model);
 	if (err)
@@ -3108,10 +3096,8 @@ static int micron_latency_stats_info(int argc, char **argv, struct command *acmd
 	uint64_t *cmd_stats = &log.all_cmds[0];
 	char *cmd_str = "All";
 
-	OPT_ARGS(opts) = {
-		OPT_STRING("command", 'c', "command", &opt.command, cmdstr),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_STRING("command", 'c', "command", &opt.command, cmdstr));
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &model);
 	if (err < 0)
@@ -3180,10 +3166,8 @@ static int micron_ocp_smart_health_logs(int argc, char **argv, struct command *a
 	};
 	int err = 0;
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("format", 'f', &cfg.fmt, fmt),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &eModel);
 	if (err < 0)
@@ -3242,9 +3226,7 @@ static int micron_clr_fw_activation_history(int argc, char **argv,
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 	int err = 0;
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &model);
@@ -3291,11 +3273,9 @@ static int micron_telemetry_cntrl_option(int argc, char **argv,
 		.select = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_STRING("option", 'o', "option", &opt.option, option),
-		OPT_UINT("select", 's', &opt.select, select),
-		OPT_END()
-	};
+		OPT_UINT("select", 's', &opt.select, select));
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &model);
 	if (err < 0)
@@ -3685,12 +3665,10 @@ static int micron_internal_logs(int argc, char **argv, struct command *acmd,
 		.log = 0x07,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_STRING("type", 't', "log type", &cfg.type, type),
 		OPT_STRING("package", 'p', "FILE", &cfg.package, package),
-		OPT_UINT("data_area", 'd', &cfg.data_area, data_area),
-		OPT_END()
-	};
+		OPT_UINT("data_area", 'd', &cfg.data_area, data_area));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -3970,9 +3948,7 @@ static int micron_logpage_dir(int argc, char **argv, struct command *acmd,
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	int i;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &model);
 	if (err < 0)
@@ -4044,10 +4020,8 @@ static int micron_cloud_boot_SSD_version(int argc, char **argv,
 		.fmt = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("format", 'f', &cfg.fmt, fmt),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &eModel);
 	if (err < 0)
@@ -4108,10 +4082,8 @@ static int micron_device_waf(int argc, char **argv, struct command *acmd,
 			.fmt = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-			OPT_FMT("format", 'f', &cfg.fmt, fmt),
-			OPT_END()
-	};
+	NVME_ARGS(opts,
+			OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &eModel);
 	if (err < 0)
@@ -4169,10 +4141,8 @@ static int micron_cloud_log(int argc, char **argv, struct command *acmd,
 		.fmt = "json",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("format", 'f', &cfg.fmt, fmt),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FMT("format", 'f', &cfg.fmt, fmt));
 
 	err = micron_parse_options(&ctx, &hdl, argc, argv, desc, opts, &eModel);
 	if (err < 0)
diff --git a/plugins/nbft/nbft-plugin.c b/plugins/nbft/nbft-plugin.c
index 8a1739d2f9..95afa6723c 100644
--- a/plugins/nbft/nbft-plugin.c
+++ b/plugins/nbft/nbft-plugin.c
@@ -540,29 +540,23 @@ int show_nbft(int argc, char **argv, struct command *acmd, struct plugin *plugin
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	struct nbft_file_entry *head = NULL;
 	struct list_head nbft_list;
-	char *format = "normal";
 	char *nbft_path = NBFT_SYSFS_PATH;
 	nvme_print_flags_t flags;
 	int ret;
-	unsigned int verbose = 0;
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &format, "Output format: normal|json"),
+	NVME_ARGS(opts,
 		OPT_FLAG("subsystem", 's', &show_subsys, "show NBFT subsystems"),
 		OPT_FLAG("hfi", 'H', &show_hfi, "show NBFT HFIs"),
 		OPT_FLAG("discovery", 'd', &show_discovery, "show NBFT discovery controllers"),
-		OPT_STRING("nbft-path", 0, "STR", &nbft_path, "user-defined path for NBFT tables"),
-		OPT_INCR("verbose", 'v', &verbose, "Increase logging verbosity"),
-		OPT_END()
-	};
+		OPT_STRING("nbft-path", 0, "STR", &nbft_path, "user-defined path for NBFT tables"));
 
 	ret = argconfig_parse(argc, argv, desc, opts);
 	if (ret)
 		return ret;
 
-	log_level = map_log_level(verbose, false /* quiet */);
+	log_level = map_log_level(nvme_args.verbose, false /* quiet */);
 
-	ret = validate_output_format(format, &flags);
+	ret = validate_output_format(nvme_args.output_format, &flags);
 	if (ret < 0)
 		return ret;
 
diff --git a/plugins/netapp/netapp-nvme.c b/plugins/netapp/netapp-nvme.c
index 05ee21cd57..a736d1ae05 100644
--- a/plugins/netapp/netapp-nvme.c
+++ b/plugins/netapp/netapp-nvme.c
@@ -901,20 +901,7 @@ static int netapp_smdevices(int argc, char **argv, struct command *acmd,
 	int num_smdevices = 0;
 	struct nvme_transport_handle *hdl;
 
-	struct config {
-		bool verbose;
-		char *output_format;
-	};
-
-	struct config cfg = {
-		.output_format = "normal",
-	};
-
-	OPT_ARGS(opts) = {
-		OPT_FLAG("verbose", 'v', &cfg.verbose, "Increase output verbosity"),
-		OPT_FMT("output-format", 'o', &cfg.output_format, "Output Format: normal|json|column"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	if (!ctx)
 		return -ENOMEM;
@@ -923,9 +910,10 @@ static int netapp_smdevices(int argc, char **argv, struct command *acmd,
 	if (ret < 0)
 		return ret;
 
-	fmt = netapp_output_format(cfg.output_format);
+	fmt = netapp_output_format(nvme_args.output_format);
 	if (fmt != NNORMAL && fmt != NCOLUMN && fmt != NJSON) {
-		fprintf(stderr, "Unrecognized output format: %s\n", cfg.output_format);
+		fprintf(stderr, "Unrecognized output format: %s\n",
+			nvme_args.output_format);
 		return -EINVAL;
 	}
 
@@ -1012,20 +1000,7 @@ static int netapp_ontapdevices(int argc, char **argv, struct command *acmd,
 	int num_ontapdevices = 0;
 	struct nvme_transport_handle *hdl;
 
-	struct config {
-		bool verbose;
-		char *output_format;
-	};
-
-	struct config cfg = {
-		.output_format = "normal",
-	};
-
-	OPT_ARGS(opts) = {
-		OPT_FLAG("verbose", 'v', &cfg.verbose, "Increase output verbosity"),
-		OPT_FMT("output-format", 'o', &cfg.output_format, "Output Format: normal|json|column"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	if (!ctx)
 		return -ENOMEM;
@@ -1034,9 +1009,10 @@ static int netapp_ontapdevices(int argc, char **argv, struct command *acmd,
 	if (ret < 0)
 		return ret;
 
-	fmt = netapp_output_format(cfg.output_format);
+	fmt = netapp_output_format(nvme_args.output_format);
 	if (fmt != NNORMAL && fmt != NCOLUMN && fmt != NJSON) {
-		fprintf(stderr, "Unrecognized output format: %s\n", cfg.output_format);
+		fprintf(stderr, "Unrecognized output format: %s\n",
+			nvme_args.output_format);
 		return -EINVAL;
 	}
 
diff --git a/plugins/ocp/ocp-clear-features.c b/plugins/ocp/ocp-clear-features.c
index 2b5b8cb046..76cb35f3ad 100644
--- a/plugins/ocp/ocp-clear-features.c
+++ b/plugins/ocp/ocp-clear-features.c
@@ -22,11 +22,9 @@ static int ocp_clear_feature(int argc, char **argv, const char *desc, const __u8
 	bool uuid = true;
 	int err;
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FLAG("no-uuid", 'n', NULL,
-			 "Skip UUID index search (UUID index not required for OCP 1.0)"),
-		OPT_END()
-	};
+			 "Skip UUID index search (UUID index not required for OCP 1.0)"));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -82,12 +80,10 @@ int get_ocp_error_counters(int argc, char **argv, struct command *acmd,
 		.nsid = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("sel", 's', &cfg.sel, sel),
 		OPT_UINT("namespace-id", 'n', &cfg.nsid, nsid),
-		OPT_FLAG("no-uuid", 'u', NULL, no_uuid),
-		OPT_END()
-	};
+		OPT_FLAG("no-uuid", 'u', NULL, no_uuid));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
diff --git a/plugins/ocp/ocp-fw-activation-history.c b/plugins/ocp/ocp-fw-activation-history.c
index efe64528b9..f7a2707bc2 100644
--- a/plugins/ocp/ocp-fw-activation-history.c
+++ b/plugins/ocp/ocp-fw-activation-history.c
@@ -29,12 +29,7 @@ int ocp_fw_activation_history_log(int argc, char **argv, struct command *acmd,
 {
 	const char *desc = "Retrieves the OCP firmware activation history log.";
 
-	char *format = "normal";
-
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &format, "output format : normal | json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
@@ -74,7 +69,8 @@ int ocp_fw_activation_history_log(int argc, char **argv, struct command *acmd,
 	if (!err) {
 		nvme_print_flags_t print_flag;
 
-		err = validate_output_format(format, &print_flag);
+		err = validate_output_format(nvme_args.output_format,
+			&print_flag);
 		if (err < 0) {
 			fprintf(stderr, "Error: Invalid output format.\n");
 			return err;
diff --git a/plugins/ocp/ocp-hardware-component-log.c b/plugins/ocp/ocp-hardware-component-log.c
index 8339a11d84..2c76c7dafa 100644
--- a/plugins/ocp/ocp-hardware-component-log.c
+++ b/plugins/ocp/ocp-hardware-component-log.c
@@ -248,7 +248,7 @@ static int get_hwcomp_log(struct nvme_transport_handle *hdl, __u32 id, bool list
 		.desc = NULL,
 	};
 
-	ret = validate_output_format(nvme_cfg.output_format, &fmt);
+	ret = validate_output_format(nvme_args.output_format, &fmt);
 	if (ret < 0) {
 		fprintf(stderr, "error: ocp: invalid output format\n");
 		return ret;
diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index a162eae465..ee7667def9 100644
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -267,25 +267,13 @@ static int ocp_latency_monitor_log(int argc, char **argv,
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	int ret = 0;
 
-	struct config {
-		char *output_format;
-	};
-
-	struct config cfg = {
-		.output_format = "normal",
-	};
-
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format,
-			"output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
 		return ret;
 
-	ret = get_c3_log_page(hdl, cfg.output_format);
+	ret = get_c3_log_page(hdl, nvme_args.output_format);
 	if (ret)
 		fprintf(stderr,
 			"ERROR : OCP : Failure reading the C3 Log Page, ret = %d\n",
@@ -343,7 +331,7 @@ int ocp_set_latency_monitor_feature(int argc, char **argv, struct command *acmd,
 		.latency_monitor_feature_enable = 0x1,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("active_bucket_timer_threshold", 't', &cfg.active_bucket_timer_threshold, active_bucket_timer_threshold),
 		OPT_UINT("active_threshold_a", 'a', &cfg.active_threshold_a, active_threshold_a),
 		OPT_UINT("active_threshold_b", 'b', &cfg.active_threshold_b, active_threshold_b),
@@ -353,9 +341,7 @@ int ocp_set_latency_monitor_feature(int argc, char **argv, struct command *acmd,
 		OPT_UINT("active_latency_minimum_window", 'w', &cfg.active_latency_minimum_window, active_latency_minimum_window),
 		OPT_UINT("debug_log_trigger_enable", 'r', &cfg.debug_log_trigger_enable, debug_log_trigger_enable),
 		OPT_UINT("discard_debug_log", 'l', &cfg.discard_debug_log, discard_debug_log),
-		OPT_UINT("latency_monitor_feature_enable", 'e', &cfg.latency_monitor_feature_enable, latency_monitor_feature_enable),
-		OPT_END()
-	};
+		OPT_UINT("latency_monitor_feature_enable", 'e', &cfg.latency_monitor_feature_enable, latency_monitor_feature_enable));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -438,12 +424,10 @@ static int ocp_get_latency_monitor_feature(int argc, char **argv, struct command
 		.nsid = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("sel", 's', &cfg.sel, sel),
 		OPT_UINT("namespace-id", 'n', &cfg.nsid, nsid),
-		OPT_FLAG("no-uuid", 'u', NULL, no_uuid),
-		OPT_END()
-	};
+		OPT_FLAG("no-uuid", 'u', NULL, no_uuid));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1431,7 +1415,6 @@ static int ocp_telemetry_log(int argc, char **argv, struct command *acmd, struct
 	const char *output_file = "Output file name with path;\n"
 			"e.g. '-f ./path/name'\n'-f ./path1/path2/';\n"
 			"If requested path does not exist, the directory will be newly created.";
-	const char *output_format = "output format normal|json";
 	const char *data_area = "Telemetry Data Area; 1, 2, 3, or 4;\n"
 			"e.g. '-a 1 for Data Area 1.'\n"
 			"e.g. '-a 2 for Data Areas 1 and 2.'\n"
@@ -1456,15 +1439,12 @@ static int ocp_telemetry_log(int argc, char **argv, struct command *acmd, struct
 	const char *tele_log_suffix = "telemetry.bin";
 	bool host_behavior_changed = false;
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_STR("telemetry-log", 'l', &opt.telemetry_log, telemetry_log),
 		OPT_STR("string-log", 's', &opt.string_log, string_log),
 		OPT_FILE("output-file", 'f', &opt.output_file, output_file),
-		OPT_FMT("output-format", 'o', &opt.output_format, output_format),
 		OPT_INT("data-area", 'a', &opt.data_area, data_area),
-		OPT_STR("telemetry-type", 't', &opt.telemetry_type, telemetry_type),
-		OPT_END()
-	};
+		OPT_STR("telemetry-type", 't', &opt.telemetry_type, telemetry_type));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1708,10 +1688,7 @@ static int ocp_unsupported_requirements_log(int argc, char **argv, struct comman
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -1812,10 +1789,7 @@ static int ocp_error_recovery_log(int argc, char **argv, struct command *acmd, s
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "output Format: normal|json|binary"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -1915,10 +1889,7 @@ static int ocp_device_capabilities_log(int argc, char **argv, struct command *ac
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "output Format: normal|json|binary"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -1982,10 +1953,8 @@ static int ocp_set_telemetry_profile_feature(int argc, char **argv, struct comma
 		.tps = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_BYTE("telemetry-profile-select", 't', &cfg.tps, tps),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_BYTE("telemetry-profile-select", 't', &cfg.tps, tps));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -2029,12 +1998,10 @@ static int ocp_get_telemetry_profile_feature(int argc, char **argv, struct comma
 		.nsid = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("sel", 's', &cfg.sel, sel),
 		OPT_UINT("namespace-id", 'n', &cfg.nsid, nsid),
-		OPT_FLAG("no-uuid", 'u', NULL, no_uuid),
-		OPT_END()
-	};
+		OPT_FLAG("no-uuid", 'u', NULL, no_uuid));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -2128,12 +2095,10 @@ static int set_dssd_power_state_feature(int argc, char **argv, struct command *a
 		.save = false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("power-state", 'p', &cfg.power_state, power_state),
 		OPT_FLAG("save", 's', &cfg.save, save),
-		OPT_FLAG("no-uuid", 'n', NULL, no_uuid),
-		OPT_END()
-	};
+		OPT_FLAG("no-uuid", 'n', NULL, no_uuid));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -2204,12 +2169,10 @@ static int get_dssd_power_state_feature(int argc, char **argv, struct command *a
 		.all = false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("sel", 'S', &cfg.sel, sel),
 		OPT_FLAG("all", 'a', NULL, all),
-		OPT_FLAG("no-uuid", 'n', NULL, no_uuid),
-		OPT_END()
-	};
+		OPT_FLAG("no-uuid", 'n', NULL, no_uuid));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -2261,12 +2224,10 @@ static int set_plp_health_check_interval(int argc, char **argv, struct command *
 		.sv = false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("plp_health_interval", 'p', &cfg.plp_health_interval, plp_health_interval),
 		OPT_FLAG("save", 's', &cfg.sv, sv),
-		OPT_FLAG("no-uuid", 'n', NULL, no_uuid),
-		OPT_END()
-	};
+		OPT_FLAG("no-uuid", 'n', NULL, no_uuid));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -2318,10 +2279,8 @@ static int get_plp_health_check_interval(int argc, char **argv, struct command *
 		.sel = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_BYTE("sel", 'S', &cfg.sel, sel),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_BYTE("sel", 'S', &cfg.sel, sel));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -2372,11 +2331,9 @@ static int set_dssd_async_event_config(int argc, char **argv, struct command *ac
 		.sv = false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FLAG("enable-panic-notices", 'e', &cfg.epn, epn),
-		OPT_FLAG("save", 's', &cfg.sv, sv),
-		OPT_END()
-	};
+		OPT_FLAG("save", 's', &cfg.sv, sv));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -2425,10 +2382,8 @@ static int get_dssd_async_event_config(int argc, char **argv, struct command *ac
 		.sel = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_BYTE("sel", 'S', &cfg.sel, sel),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_BYTE("sel", 'S', &cfg.sel, sel));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -2505,12 +2460,8 @@ static int ocp_telemetry_str_log_format(int argc, char **argv, struct command *a
 		.output_file = NULL,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format,
-				"output Format:normal|json|binary"),
-		OPT_FILE("output-file", 'f', &cfg.output_file, output_file),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FILE("output-file", 'f', &cfg.output_file, output_file));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -2619,10 +2570,7 @@ static int ocp_tcg_configuration_log(int argc, char **argv, struct command *acmd
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -2734,12 +2682,10 @@ static int get_error_injection(int argc, char **argv, struct command *acmd, stru
 	struct config cfg = { 0 };
 
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("sel", 's', &cfg.sel, sel),
 		OPT_FLAG("no-uuid", 'n', NULL, no_uuid),
-		OPT_FLAG("all-ns", 'a', NULL, all_ns),
-		OPT_END()
-	};
+		OPT_FLAG("all-ns", 'a', NULL, all_ns));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -2897,11 +2843,9 @@ static int get_enable_ieee1667_silo(int argc, char **argv, struct command *acmd,
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("sel", 's', &cfg.sel, sel),
-		OPT_FLAG("no-uuid", 'n', NULL, no_uuid),
-		OPT_END()
-	};
+		OPT_FLAG("no-uuid", 'n', NULL, no_uuid));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -2957,12 +2901,10 @@ static int set_enable_ieee1667_silo(int argc, char **argv, struct command *acmd,
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FLAG("enable", 'e', NULL, no_uuid),
 		OPT_FLAG("save", 's', NULL, save),
-		OPT_FLAG("no-uuid", 'n', NULL, no_uuid),
-		OPT_END()
-	};
+		OPT_FLAG("no-uuid", 'n', NULL, no_uuid));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, enable_ieee1667_silo, opts);
 	if (err)
@@ -3016,7 +2958,7 @@ static int ocp_get_persistent_event_log(int argc, char **argv,
 	if (err)
 		return err;
 
-	err = validate_output_format(nvme_cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -3097,3 +3039,74 @@ static int ocp_get_persistent_event_log(int argc, char **argv,
 
 	return err;
 }
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+/// Idle Wake Up Time Configuration (Feature Identifier CAh) Get Feature
+static int ocp_get_idle_wakeup_time_config_feature(int argc, char **argv,
+						    struct command *acmd,
+						    struct plugin *plugin)
+{
+	const char *desc = "Define Issue Get Feature cmd (FID: 0xCA) IWUT";
+	const char *sel = "[0-3]: current/default/saved/supported/";
+	const char *nsid = "Byte[04-07]: NSID Valid/Invalid/Inactive";
+
+	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
+	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
+
+
+	__u64 result;
+	int err;
+	bool uuid;
+	__u8 uuid_index = 0;
+
+	struct config {
+		__u8 sel;
+		__u32 nsid;
+	};
+
+	struct config cfg = {
+		.sel = 0,
+		.nsid = 0,
+	};
+
+	NVME_ARGS(opts,
+		OPT_BYTE("sel", 's', &cfg.sel, sel),
+		OPT_UINT("namespace-id", 'n', &cfg.nsid, nsid),
+		OPT_FLAG("no-uuid", 'u', NULL, no_uuid));
+
+	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
+	if (err)
+		return err;
+
+	uuid = !argconfig_parse_seen(opts, "no-uuid");
+
+	if (uuid) {
+		/* OCP 2.0 requires UUID index support */
+		err = ocp_get_uuid_index(hdl, &uuid_index);
+		if (err || !uuid_index) {
+			nvme_show_error("ERROR: No OCP UUID index found");
+			return err;
+		}
+	}
+
+	err = nvme_get_features(hdl, cfg.nsid, OCP_FID_IWTC, cfg.sel, 0,
+			uuid_index, NULL, 0, &result);
+	if (!err) {
+		if (result == 0) {
+			printf("get-feature:CAh,SEL=%s,IWUT Disabled: %#016"PRIx64"\n",
+			nvme_select_to_string(cfg.sel), (uint64_t)result);
+		} else {
+			printf("get-feature:CAh SEL=%s,IWUT is: %#016"PRIx64"\n",
+			nvme_select_to_string(cfg.sel), (uint64_t)result);
+		}
+		if (cfg.sel == NVME_GET_FEATURES_SEL_SUPPORTED)
+			nvme_show_select_result(0xCA, result);
+	} else {
+		nvme_show_error("Could not get feature: 0xCA");
+	}
+
+	return err;
+}
diff --git a/plugins/ocp/ocp-nvme.h b/plugins/ocp/ocp-nvme.h
index 1f38353965..d43cfb5bbe 100644
--- a/plugins/ocp/ocp-nvme.h
+++ b/plugins/ocp/ocp-nvme.h
@@ -50,6 +50,8 @@ PLUGIN(NAME("ocp", "OCP cloud SSD extensions", OCP_PLUGIN_VERSION),
 		      ocp_get_telemetry_profile_feature)
 		ENTRY("persistent-event-log", "Retrieve Persistent Event Log with OCP events",
 		      ocp_get_persistent_event_log)
+		ENTRY("get-idle-wakeup-time", "Get Idle Wake Up Time Config",
+		      ocp_get_idle_wakeup_time_config_feature)
 	)
 );
 
@@ -281,6 +283,7 @@ enum ocp_dssd_feature_id {
 	OCP_FID_DSSDPS, /* DSSD Power State */
 	OCP_FID_TEL_CFG, /* Telemetry Profile */
 	OCP_FID_DAEC, /* DSSD Asynchronous Event Configuration */
+	OCP_FID_IWTC, /* Idle Wake Up Time Configuration */
 };
 
 /*
diff --git a/plugins/ocp/ocp-smart-extended-log.c b/plugins/ocp/ocp-smart-extended-log.c
index 3eef14a9a7..d4625d5d8e 100644
--- a/plugins/ocp/ocp-smart-extended-log.c
+++ b/plugins/ocp/ocp-smart-extended-log.c
@@ -103,28 +103,14 @@ int ocp_smart_add_log(int argc, char **argv, struct command *acmd,
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	int ret = 0;
 
-	struct config {
-		char *output_format;
-		unsigned int output_format_version;
-	};
-
-	struct config cfg = {
-		.output_format = "normal",
-		.output_format_version = 1,
-	};
-
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "output Format: normal|json"),
-		OPT_UINT("output-format-version", 0, &cfg.output_format_version, "output Format version: 1|2"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
 		return ret;
 
-	ret = get_c0_log_page(hdl, cfg.output_format,
-			      cfg.output_format_version);
+	ret = get_c0_log_page(hdl, nvme_args.output_format,
+			      nvme_args.output_format_ver);
 	if (ret)
 		fprintf(stderr, "ERROR : OCP : Failure reading the C0 Log Page, ret = %d\n",
 			ret);
diff --git a/plugins/sandisk/sandisk-nvme.c b/plugins/sandisk/sandisk-nvme.c
index 29d06f08b0..b784099b2b 100644
--- a/plugins/sandisk/sandisk-nvme.c
+++ b/plugins/sandisk/sandisk-nvme.c
@@ -320,7 +320,6 @@ static int sndk_vs_internal_fw_log(int argc, char **argv,
 		"  NONE - Default, capture without using NVMe telemetry.\n" \
 		"  HOST - Host-initiated telemetry.\n" \
 		"  CONTROLLER - Controller-initiated telemetry.";
-	const char *verbose = "Display more debug messages.";
 	char f[PATH_MAX] = {0};
 	char fileSuffix[PATH_MAX] = {0};
 	__u32 xfer_size = 0;
@@ -340,7 +339,6 @@ static int sndk_vs_internal_fw_log(int argc, char **argv,
 		__u64 file_size;
 		__u64 offset;
 		char *type;
-		bool verbose;
 	};
 
 	struct config cfg = {
@@ -350,19 +348,15 @@ static int sndk_vs_internal_fw_log(int argc, char **argv,
 		.file_size = 0,
 		.offset = 0,
 		.type = NULL,
-		.verbose = false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FILE("output-file",   'o', &cfg.file,      file),
 		OPT_UINT("transfer-size", 's', &cfg.xfer_size, size),
 		OPT_UINT("data-area",     'd', &cfg.data_area, data_area),
 		OPT_LONG("file-size",     'f', &cfg.file_size, file_size),
 		OPT_LONG("offset",        'e', &cfg.offset,    offset),
-		OPT_FILE("type",          't', &cfg.type,      type),
-		OPT_FLAG("verbose",       'v', &cfg.verbose,   verbose),
-		OPT_END()
-	};
+		OPT_FILE("type",          't', &cfg.type,      type));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -473,7 +467,7 @@ static int sndk_vs_internal_fw_log(int argc, char **argv,
 			goto out;
 		} else {
 			ret = sndk_do_cap_udui(hdl, f, xfer_size,
-					 cfg.verbose, cfg.file_size,
+					 nvme_args.verbose, cfg.file_size,
 					 cfg.offset);
 			goto out;
 		}
@@ -569,10 +563,8 @@ static int sndk_drive_resize(int argc, char **argv,
 		.size = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_UINT("size", 's', &cfg.size, size),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_UINT("size", 's', &cfg.size, size));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -920,10 +912,7 @@ static int sndk_vs_fw_activate_history(int argc, char **argv,
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "Output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -971,9 +960,7 @@ static int sndk_clear_fw_activate_history(int argc, char **argv,
 	__u64 capabilities = 0;
 	int ret;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -1043,9 +1030,7 @@ static int sndk_capabilities(int argc, char **argv,
 	uint64_t capabilities = 0;
 	int ret;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
diff --git a/plugins/scaleflux/sfx-nvme.c b/plugins/scaleflux/sfx-nvme.c
index 7e87fb578d..7593b261bb 100644
--- a/plugins/scaleflux/sfx-nvme.c
+++ b/plugins/scaleflux/sfx-nvme.c
@@ -336,6 +336,7 @@ static int get_additional_smart_log(int argc, char **argv, struct command *acmd,
 #endif /* CONFIG_JSONC */
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
+	nvme_print_flags_t flags;
 	struct config {
 		__u32 namespace_id;
 		bool  raw_binary;
@@ -347,21 +348,25 @@ static int get_additional_smart_log(int argc, char **argv, struct command *acmd,
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace),
 		OPT_FLAG("raw-binary",	 'b', &cfg.raw_binary,	 raw),
-		OPT_FLAG_JSON("json",	 'j', &cfg.json,	 json),
-		OPT_END()
-	};
+		OPT_FLAG_JSON("json",	 'j', &cfg.json,	 json));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
+	err = validate_output_format(nvme_args.output_format, &flags);
+	if (err < 0) {
+		nvme_show_error("Invalid output format");
+		return err;
+	}
+
 	err = nvme_get_nsid_log(hdl, cfg.namespace_id, false, 0xca,
 				(void *)&smart_log, sizeof(smart_log));
 	if (!err) {
-		if (cfg.json)
+		if (flags & JSON || cfg.json)
 			show_sfx_smart_log_jsn(&smart_log, cfg.namespace_id,
 					       nvme_transport_handle_get_name(hdl));
 		else if (!cfg.raw_binary)
@@ -513,11 +518,9 @@ static int get_lat_stats_log(int argc, char **argv, struct command *acmd, struct
 	struct config cfg = {
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FLAG("write",	   'w', &cfg.write,		 write),
-		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
-		OPT_END()
-	};
+		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -654,9 +657,7 @@ static int sfx_get_bad_block(int argc, char **argv, struct command *acmd, struct
 
 	char *desc = "Get bad block table of sfx block device.";
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -710,10 +711,8 @@ static int query_cap_info(int argc, char **argv, struct command *acmd, struct pl
 	struct config cfg;
 	int err = 0;
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -840,12 +839,10 @@ static int change_cap(int argc, char **argv, struct command *acmd, struct plugin
 	.force = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("cap",			'c',	&cfg.capacity_in_gb,	cap_gb),
 		OPT_SUFFIX("cap-byte",	'z',	&cfg.cap_in_byte,		cap_byte),
-		OPT_FLAG("force",		'f',	&cfg.force,				force),
-		OPT_END()
-	};
+		OPT_FLAG("force",		'f',	&cfg.force,				force));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -952,13 +949,11 @@ static int sfx_set_feature(int argc, char **argv, struct command *acmd, struct p
 		.force = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id",		'n',	&cfg.namespace_id,		namespace_id),
 		OPT_UINT("feature-id",			'f',	&cfg.feature_id,		feature_id),
 		OPT_UINT("value",			'v',	&cfg.value,			value),
-		OPT_FLAG("force",			's',	&cfg.force,			force),
-		OPT_END()
-	};
+		OPT_FLAG("force",			's',	&cfg.force,			force));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1046,11 +1041,9 @@ static int sfx_get_feature(int argc, char **argv, struct command *acmd, struct p
 		.feature_id = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id",		'n',	&cfg.namespace_id,		namespace_id),
-		OPT_UINT("feature-id",			'f',	&cfg.feature_id,		feature_id),
-		OPT_END()
-	};
+		OPT_UINT("feature-id",			'f',	&cfg.feature_id,		feature_id));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1379,14 +1372,12 @@ static int sfx_dump_evtlog(int argc, char **argv, struct command *acmd, struct p
 		.output = NULL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FILE("file",		    'f',	&cfg.file,		file),
 		OPT_UINT("namespace_id",	    'n',	&cfg.namespace_id,	namespace_id),
 		OPT_UINT("storage_medium",	    's',	&cfg.storage_medium,    storage_medium),
 		OPT_FLAG("parse",	            'p',	&cfg.parse,             parse),
-		OPT_FILE("output",                  'o',        &cfg.output,            output),
-		OPT_END()
-	};
+		OPT_FILE("output",                  'o',        &cfg.output,            output));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1502,14 +1493,12 @@ static int sfx_expand_cap(int argc, char **argv, struct command *acmd, struct pl
 		.units = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace_id",	    'n',	&cfg.namespace_id,	namespace_id),
 		OPT_LONG("namespace_size",	    's',	&cfg.namespace_size,    namespace_size),
 		OPT_LONG("namespace_cap",	    'c',	&cfg.namespace_cap,     namespace_cap),
 		OPT_UINT("lbaf",	            'l',	&cfg.lbaf,              lbaf),
-		OPT_UINT("units",	            'u',	&cfg.units,             units),
-		OPT_END()
-	};
+		OPT_UINT("units",	            'u',	&cfg.units,             units));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1562,6 +1551,7 @@ static int sfx_status(int argc, char **argv, struct command *acmd, struct plugin
 	char path[512], numa_node[5], vendor[10], form_factor[15], temperature[10], io_speed[15];
 	char chr_dev[8], serial_number[21], model_number[41], firmware_revision[9], pcie_status[9];
 	struct json_object *root, *dev_stats, *link_stats, *crit_stats;
+	nvme_print_flags_t flags;
 	__u64 get_feat_result;
 	double write_amp;
 
@@ -1572,15 +1562,19 @@ static int sfx_status(int argc, char **argv, struct command *acmd, struct plugin
 		.json = false
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("json-print",	    'j',	&cfg.json,	json_desc),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FLAG("json-print",	    'j',	&cfg.json,	json_desc));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
+	err = validate_output_format(nvme_args.output_format, &flags);
+	if (err < 0) {
+		nvme_show_error("Invalid output format");
+		return err;
+	}
+
 	//Calculate formatted capacity, not concerned with errors, we may have a char device
 	memset(&path, 0, 512);
 	snprintf(path, 512, "/dev/%s", nvme_transport_handle_get_name(hdl));
@@ -1905,7 +1899,7 @@ static int sfx_status(int argc, char **argv, struct command *acmd, struct plugin
 		return err;
 	}
 
-	if (cfg.json) {
+	if (flags & JSON || cfg.json) {
 		root = json_create_object();
 		json_object_add_value_string(root, "ScaleFlux Status", nvme_transport_handle_get_name(hdl));
 
diff --git a/plugins/seagate/seagate-nvme.c b/plugins/seagate/seagate-nvme.c
index 91dca9cb8c..15ca916537 100644
--- a/plugins/seagate/seagate-nvme.c
+++ b/plugins/seagate/seagate-nvme.c
@@ -150,30 +150,26 @@ static int log_pages_supp(int argc, char **argv, struct command *acmd,
 	__u32 i = 0;
 	log_page_map logPageMap;
 	const char *desc = "Retrieve Seagate Supported Log-Page information for the given device ";
-	const char *output_format = "output in binary format";
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
+	nvme_print_flags_t flags;
 	int fmt;
 
-	struct config {
-		char *output_format;
-	};
-
-	struct config cfg = {
-		.output_format = "normal",
-	};
-
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
+
+	err = validate_output_format(nvme_args.output_format, &flags);
+	if (err < 0) {
+		nvme_show_error("Invalid output format");
+		return err;
+	}
+
 	err = nvme_get_log_simple(hdl, 0xc5, &logPageMap, sizeof(logPageMap));
 	if (!err) {
-		if (strcmp(cfg.output_format, "json")) {
+		if (flags & NORMAL) {
 			printf("Seagate Supported Log-pages count :%d\n",
 				le32_to_cpu(logPageMap.NumLogPages));
 			printf("%-15s %-30s\n", "LogPage-Id", "LogPage-Name");
@@ -181,11 +177,11 @@ static int log_pages_supp(int argc, char **argv, struct command *acmd,
 			for (fmt = 0; fmt < 45; fmt++)
 				printf("-");
 			printf("\n");
-		} else
+		} else if (flags & JSON)
 			json_log_pages_supp(&logPageMap);
 
 		for (i = 0; i < le32_to_cpu(logPageMap.NumLogPages); i++) {
-			if (strcmp(cfg.output_format, "json")) {
+			if (flags & NORMAL) {
 				printf("0x%-15X",
 					   le32_to_cpu(logPageMap.LogPageEntry[i].LogPageID));
 				printf("%-30s\n",
@@ -897,22 +893,12 @@ static int vs_smart_log(int argc, char **argv, struct command *acmd, struct plug
 	struct json_object *lbafs_ExtSmart, *lbafs_DramSmart;
 
 	const char *desc = "Retrieve the Firmware Activation History for Seagate NVMe drives";
-	const char *output_format = "output in binary format";
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
+	nvme_print_flags_t flags;
 	int err, index = 0;
-	struct config {
-		char *output_format;
-	};
 
-	struct config cfg = {
-		.output_format = "normal",
-	};
-
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -920,7 +906,13 @@ static int vs_smart_log(int argc, char **argv, struct command *acmd, struct plug
 		return -1;
 	}
 
-	if (strcmp(cfg.output_format, "json"))
+	err = validate_output_format(nvme_args.output_format, &flags);
+	if (err < 0) {
+		nvme_show_error("Invalid output format");
+		return err;
+	}
+
+	if (flags & JSON)
 		printf("Seagate Extended SMART Information :\n");
 
 
@@ -941,7 +933,7 @@ static int vs_smart_log(int argc, char **argv, struct command *acmd, struct plug
 	if (!stx_is_jag_pan(modelNo)) {
 		err = nvme_get_log_simple(hdl, 0xC4, &ExtdSMARTInfo, sizeof(ExtdSMARTInfo));
 		if (!err) {
-			if (strcmp(cfg.output_format, "json")) {
+			if (flags & NORMAL) {
 				printf("%-39s %-15s %-19s\n", "Description", "Ext-Smart-Id", "Ext-Smart-Value");
 				for (index = 0; index < 80; index++)
 					printf("-");
@@ -949,7 +941,7 @@ static int vs_smart_log(int argc, char **argv, struct command *acmd, struct plug
 				for (index = 0; index < NUMBER_EXTENDED_SMART_ATTRIBUTES; index++)
 					print_smart_log(ExtdSMARTInfo.Version, ExtdSMARTInfo.vendorData[index], index == (NUMBER_EXTENDED_SMART_ATTRIBUTES - 1));
 
-			} else {
+			} else if (flags & JSON){
 				lbafs_ExtSmart = json_create_object();
 				json_print_smart_log(lbafs_ExtSmart, &ExtdSMARTInfo);
 
@@ -963,15 +955,15 @@ static int vs_smart_log(int argc, char **argv, struct command *acmd, struct plug
 
 			err = nvme_get_log_simple(hdl, 0xCF, &logPageCF, sizeof(logPageCF));
 			if (!err) {
-				if (strcmp(cfg.output_format, "json")) {
+				if (flags & NORMAL) {
 					print_smart_log_CF(&logPageCF);
-				} else {
+				} else if (flags & JSON) {
 					lbafs_DramSmart = json_create_object();
 					json_print_smart_log_CF(lbafs_DramSmart, &logPageCF);
 					json_array_add_value_object(lbafs, lbafs_DramSmart);
 					json_print_object(root, NULL);
 				}
-			} else if (!strcmp(cfg.output_format, "json")) {
+			} else if (flags & JSON) {
 				json_print_object(root, NULL);
 				json_free_object(root);
 			}
@@ -982,9 +974,9 @@ static int vs_smart_log(int argc, char **argv, struct command *acmd, struct plug
 		err = nvme_get_log_simple(hdl, 0xC0, &ehExtSmart, sizeof(ehExtSmart));
 
 		if (!err) {
-			if (strcmp(cfg.output_format, "json")) {
+			if (flags & NORMAL) {
 				print_stx_smart_log_C0(&ehExtSmart);
-			} else {
+			} else if (flags & JSON){
 				lbafs_ExtSmart = json_create_object();
 				json_print_stx_smart_log_C0(lbafs_ExtSmart, &ehExtSmart);
 
@@ -1003,7 +995,7 @@ static int vs_smart_log(int argc, char **argv, struct command *acmd, struct plug
 	err = nvme_get_log_simple(hdl, 0xC4,
 				  &ExtdSMARTInfo, sizeof(ExtdSMARTInfo));
 	if (!err) {
-		if (strcmp(cfg.output_format, "json")) {
+		if (flags & NORMAL) {
 			printf("%-39s %-15s %-19s\n", "Description", "Ext-Smart-Id", "Ext-Smart-Value");
 			for (index = 0; index < 80; index++)
 				printf("-");
@@ -1011,7 +1003,7 @@ static int vs_smart_log(int argc, char **argv, struct command *acmd, struct plug
 			for (index = 0; index < NUMBER_EXTENDED_SMART_ATTRIBUTES; index++)
 				print_smart_log(ExtdSMARTInfo.Version, ExtdSMARTInfo.vendorData[index], index == (NUMBER_EXTENDED_SMART_ATTRIBUTES - 1));
 
-		} else {
+		} else if (flags & JSON) {
 			lbafs_ExtSmart = json_create_object();
 			json_print_smart_log(lbafs_ExtSmart, &ExtdSMARTInfo);
 
@@ -1026,15 +1018,15 @@ static int vs_smart_log(int argc, char **argv, struct command *acmd, struct plug
 		err = nvme_get_log_simple(hdl, 0xCF,
 					  &logPageCF, sizeof(logPageCF));
 		if (!err) {
-			if (strcmp(cfg.output_format, "json")) {
+			if (flags & NORMAL) {
 				print_smart_log_CF(&logPageCF);
-			} else {
+			} else if (flags & JSON) {
 				lbafs_DramSmart = json_create_object();
 				json_print_smart_log_CF(lbafs_DramSmart, &logPageCF);
 				json_array_add_value_object(lbafs, lbafs_DramSmart);
 				json_print_object(root, NULL);
 			}
-		} else if (!strcmp(cfg.output_format, "json")) {
+		} else if (flags & JSON) {
 			json_print_object(root, NULL);
 		}
 	} else if (err > 0) {
@@ -1077,24 +1069,13 @@ static int temp_stats(int argc, char **argv, struct command *acmd, struct plugin
 	int err, cf_err;
 	int index;
 	const char *desc = "Retrieve Seagate Temperature Stats information for the given device ";
-	const char *output_format = "output in binary format";
 	nvme_print_flags_t flags;
 	unsigned int temperature = 0, PcbTemp = 0, SocTemp = 0, scCurrentTemp = 0, scMaxTemp = 0;
 	unsigned long long maxTemperature = 0, MaxSocTemp = 0;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	struct config {
-		char *output_format;
-	};
-
-	struct config cfg = {
-		.output_format = "normal",
-	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -1102,7 +1083,7 @@ static int temp_stats(int argc, char **argv, struct command *acmd, struct plugin
 		return -1;
 	}
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1254,21 +1235,10 @@ static int vs_pcie_error_log(int argc, char **argv, struct command *acmd, struct
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
 	const char *desc = "Retrieve Seagate PCIe error counters for the given device ";
-	const char *output_format = "output in binary format";
 	int err;
 	nvme_print_flags_t flags;
-	struct config {
-		char *output_format;
-	};
 
-	struct config cfg = {
-		.output_format = "normal",
-	};
-
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -1276,7 +1246,7 @@ static int vs_pcie_error_log(int argc, char **argv, struct command *acmd, struct
 		return -1;
 	}
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1400,21 +1370,10 @@ static int stx_vs_fw_activate_history(int argc, char **argv, struct command *acm
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
 	const char *desc = "Retrieve FW Activate History for Seagate device ";
-	const char *output_format = "output in binary format";
 	int err;
 	nvme_print_flags_t flags;
-	struct config {
-		char *output_format;
-	};
 
-	struct config cfg = {
-		.output_format = "normal",
-	};
-
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err < 0) {
@@ -1422,7 +1381,7 @@ static int stx_vs_fw_activate_history(int argc, char **argv, struct command *acm
 		return -1;
 	}
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
 		return err;
@@ -1465,10 +1424,8 @@ static int clear_fw_activate_history(int argc, char **argv, struct command *acmd
 		.save         = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("save", 's', &cfg.save, save),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FLAG("save", 's', &cfg.save, save));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err < 0) {
@@ -1525,10 +1482,8 @@ static int vs_clr_pcie_correctable_errs(int argc, char **argv, struct command *a
 		.save         = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("save", 's', &cfg.save, save),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FLAG("save", 's', &cfg.save, save));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -1593,12 +1548,10 @@ static int get_host_tele(int argc, char **argv, struct command *acmd, struct plu
 		.log_id       = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
 		OPT_UINT("log_specific", 'i', &cfg.log_id,       log_specific),
-		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw),
-		OPT_END()
-	};
+		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1703,11 +1656,9 @@ static int get_ctrl_tele(int argc, char **argv, struct command *acmd, struct plu
 		.namespace_id = 0xffffffff,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
-		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw),
-		OPT_END()
-	};
+		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1821,11 +1772,9 @@ static int vs_internal_log(int argc, char **argv, struct command *acmd, struct p
 		.file         = "",
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
-		OPT_FILE("dump-file",    'f', &cfg.file,         file),
-		OPT_END()
-	};
+		OPT_FILE("dump-file",    'f', &cfg.file,         file));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
diff --git a/plugins/shannon/shannon-nvme.c b/plugins/shannon/shannon-nvme.c
index cd20800b71..7cfd1d3cc9 100644
--- a/plugins/shannon/shannon-nvme.c
+++ b/plugins/shannon/shannon-nvme.c
@@ -132,11 +132,9 @@ static int get_additional_smart_log(int argc, char **argv, struct command *acmd,
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace),
-		OPT_FLAG("raw-binary",	 'b', &cfg.raw_binary,	  raw),
-		OPT_END()
-	};
+		OPT_FLAG("raw-binary",	 'b', &cfg.raw_binary,	  raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -201,16 +199,14 @@ static int get_additional_feature(int argc, char **argv, struct command *acmd, s
 		.data_len	  = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id",   'n', &cfg.namespace_id,	namespace_id),
 		OPT_UINT("feature-id",	   'f', &cfg.feature_id,	feature_id),
 		OPT_BYTE("sel",		   's', &cfg.sel,		sel),
 		OPT_UINT("data-len",	   'l', &cfg.data_len,		data_len),
 		OPT_FLAG("raw-binary",	   'b', &cfg.raw_binary,	raw),
 		OPT_UINT("cdw11",	   'c', &cfg.cdw11,		cdw11),
-		OPT_FLAG("human-readable", 'H', &cfg.human_readable,	human_readable),
-		OPT_END()
-	};
+		OPT_FLAG("human-readable", 'H', &cfg.human_readable,	human_readable));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -282,15 +278,13 @@ static int set_additional_feature(int argc, char **argv, struct command *acmd, s
 		.save	      = 0,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
 		OPT_UINT("feature-id",	 'f', &cfg.feature_id,	 feature_id),
 		OPT_UINT("value",	 'v', &cfg.value,	 value),
 		OPT_UINT("data-len",	 'l', &cfg.data_len,	 data_len),
 		OPT_FILE("data",	 'd', &cfg.file,	 data),
-		OPT_FLAG("save",	 's', &cfg.save,	 save),
-		OPT_END()
-	};
+		OPT_FLAG("save",	 's', &cfg.save,	 save));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
diff --git a/plugins/solidigm/solidigm-garbage-collection.c b/plugins/solidigm/solidigm-garbage-collection.c
index cfb46db4b6..5bc26b93f4 100644
--- a/plugins/solidigm/solidigm-garbage-collection.c
+++ b/plugins/solidigm/solidigm-garbage-collection.c
@@ -75,26 +75,16 @@ int solidigm_get_garbage_collection_log(int argc, char **argv, struct command *a
 	int err;
 	__u8 uuid_index;
 
-	struct config {
-		char	*output_format;
-	};
-
-	struct config cfg = {
-		.output_format	= "normal",
-	};
-
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format",   'o', &cfg.output_format,  output_format),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err) {
-		fprintf(stderr, "Invalid output format '%s'\n", cfg.output_format);
+		fprintf(stderr, "Invalid output format '%s'\n",
+			nvme_args.output_format);
 		return -EINVAL;
 	}
 
diff --git a/plugins/solidigm/solidigm-get-drive-info.c b/plugins/solidigm/solidigm-get-drive-info.c
index 9e044b987a..729904578e 100644
--- a/plugins/solidigm/solidigm-get-drive-info.c
+++ b/plugins/solidigm/solidigm-get-drive-info.c
@@ -13,7 +13,6 @@ int sldgm_get_drive_info(int argc, char **argv, struct command *acmd, struct plu
 {
 	const char *desc = "Get drive HW information";
 	const char *FTL_unit_size_str = "FTL_unit_size";
-	char *output_format = "normal";
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -25,16 +24,13 @@ int sldgm_get_drive_info(int argc, char **argv, struct command *acmd, struct plu
 	__u16 ftl_unit_size;
 	int err;
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &output_format, "normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
-	err = validate_output_format(output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if ((err < 0) || !(flags == NORMAL || flags == JSON)) {
 		nvme_show_error("Invalid output format");
 		return err;
diff --git a/plugins/solidigm/solidigm-internal-logs.c b/plugins/solidigm/solidigm-internal-logs.c
index 49700353ab..78d3e5b0b6 100644
--- a/plugins/solidigm/solidigm-internal-logs.c
+++ b/plugins/solidigm/solidigm-internal-logs.c
@@ -846,19 +846,15 @@ int solidigm_get_internal_log(int argc, char **argv, struct command *acmd,
 	const char *desc = "Get Debug Firmware Logs and save them.";
 	const char *type = "Log type; Defaults to ALL.";
 	const char *out_dir = "Output directory; defaults to current working directory.";
-	const char *verbose = "To print out verbose info.";
 
 	struct config cfg = {
 		.out_dir = ".",
 		.type = type_ALL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_STRING("type", 't', "ALL|CIT|HIT|NLOG|ASSERT|EVENT|EXTENDED", &cfg.type, type),
-		OPT_STRING("dir-name", 'd', "DIRECTORY", &cfg.out_dir, out_dir),
-		OPT_FLAG("verbose", 'v', &cfg.verbose,      verbose),
-		OPT_END()
-	};
+		OPT_STRING("dir-name", 'd', "DIRECTORY", &cfg.out_dir, out_dir));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -969,7 +965,7 @@ int solidigm_get_internal_log(int argc, char **argv, struct command *acmd,
 	if (ilog.count > 0) {
 		int ret_cmd;
 		_cleanup_free_ char *cmd = NULL;
-		char *quiet = cfg.verbose ? "" : " -q";
+		char *quiet = nvme_args.verbose ? "" : " -q";
 
 		if (asprintf(&zip_name, "%s.zip", unique_folder) < 0)
 			return -errno;
diff --git a/plugins/solidigm/solidigm-latency-tracking.c b/plugins/solidigm/solidigm-latency-tracking.c
index 31a78cbcc0..f8801153e3 100644
--- a/plugins/solidigm/solidigm-latency-tracking.c
+++ b/plugins/solidigm/solidigm-latency-tracking.c
@@ -38,7 +38,6 @@ struct config {
 	bool read;
 	bool write;
 	unsigned char type;
-	char *output_format;
 };
 
 struct latency_tracker {
@@ -355,23 +354,17 @@ int solidigm_get_latency_tracking_log(int argc, char **argv, struct command *acm
 
 	struct latency_tracker lt = {
 		.uuid_index = 0,
-		.cfg = {
-			.output_format	= "normal",
-		},
 		.base_range_bits = BASE_RANGE_BITS_4_1,
 		.bucket_list_size = BUCKET_LIST_SIZE_4_1,
 		.has_average_latency_field = false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FLAG("enable", 'e', &lt.cfg.enable, "Enable Latency Tracking"),
 		OPT_FLAG("disable", 'd', &lt.cfg.disable, "Disable Latency Tracking"),
 		OPT_FLAG("read", 'r', &lt.cfg.read, "Get read statistics"),
 		OPT_FLAG("write", 'w', &lt.cfg.write, "Get write statistics"),
-		OPT_BYTE("type", 't', &lt.cfg.type, "Log type to get"),
-		OPT_FMT("output-format", 'o', &lt.cfg.output_format, output_format),
-		OPT_END()
-	};
+		OPT_BYTE("type", 't', &lt.cfg.type, "Log type to get"));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -379,9 +372,10 @@ int solidigm_get_latency_tracking_log(int argc, char **argv, struct command *acm
 
 	lt.hdl = hdl;
 
-	err = validate_output_format(lt.cfg.output_format, &lt.print_flags);
+	err = validate_output_format(nvme_args.output_format, &lt.print_flags);
 	if (err < 0) {
-		fprintf(stderr, "Invalid output format '%s'\n", lt.cfg.output_format);
+		fprintf(stderr, "Invalid output format '%s'\n",
+			nvme_args.output_format);
 		return -EINVAL;
 	}
 
diff --git a/plugins/solidigm/solidigm-log-page-dir.c b/plugins/solidigm/solidigm-log-page-dir.c
index bffd7361fb..aed7ffdac7 100644
--- a/plugins/solidigm/solidigm-log-page-dir.c
+++ b/plugins/solidigm/solidigm-log-page-dir.c
@@ -184,16 +184,11 @@ int solidigm_get_log_page_directory_log(int argc, char **argv, struct command *a
 	const int NO_UUID_INDEX = 0;
 	const char *description = "Retrieves list of supported log pages for each UUID index.";
 
-	OPT_ARGS(options) = {
-		OPT_FMT("output-format", 'o', &nvme_cfg.output_format,
-			"output format : normal | json"),
-		OPT_INCR("verbose", 'v', &nvme_cfg.verbose, verbose),
-		OPT_END()
-	};
-
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
+	NVME_ARGS(options);
+
 	int err = parse_and_open(&ctx, &hdl, argc, argv, description, options);
 	if (err)
 		return err;
@@ -241,10 +236,10 @@ int solidigm_get_log_page_directory_log(int argc, char **argv, struct command *a
 	if (!err) {
 		nvme_print_flags_t print_flag;
 
-		err = validate_output_format(nvme_cfg.output_format, &print_flag);
+		err = validate_output_format(nvme_args.output_format, &print_flag);
 		if (err) {
 			nvme_show_error("Error: Invalid output format specified: %s.\n",
-					nvme_cfg.output_format);
+					nvme_args.output_format);
 			return err;
 		}
 
diff --git a/plugins/solidigm/solidigm-market-log.c b/plugins/solidigm/solidigm-market-log.c
index 37173cf4b9..cd6efdeef9 100644
--- a/plugins/solidigm/solidigm-market-log.c
+++ b/plugins/solidigm/solidigm-market-log.c
@@ -36,11 +36,8 @@ int sldgm_get_market_log(int argc, char **argv, struct command *acmd,
 	__u8 uuid_idx;
 	bool  raw_binary = false;
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("raw-binary", 'b', &raw_binary, raw),
-		OPT_INCR("verbose", 'v', &nvme_cfg.verbose, verbose),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FLAG("raw-binary", 'b', &raw_binary, raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
diff --git a/plugins/solidigm/solidigm-ocp-version.c b/plugins/solidigm/solidigm-ocp-version.c
index 5904f87c6b..ccd1a391e8 100644
--- a/plugins/solidigm/solidigm-ocp-version.c
+++ b/plugins/solidigm/solidigm-ocp-version.c
@@ -12,9 +12,7 @@ int sldgm_ocp_version(int argc, char **argv, struct command *acmd, struct plugin
 {
 	const char *desc = "Prints OCP extensions version of Solidigm plugin";
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	int err = argconfig_parse(argc, argv, desc, opts);
 
diff --git a/plugins/solidigm/solidigm-smart.c b/plugins/solidigm/solidigm-smart.c
index 7fde264329..54ce0945c2 100644
--- a/plugins/solidigm/solidigm-smart.c
+++ b/plugins/solidigm/solidigm-smart.c
@@ -241,28 +241,24 @@ int solidigm_get_additional_smart_log(int argc, char **argv, struct command *acm
 
 	struct config {
 		__u32	namespace_id;
-		char	*output_format;
 	};
 
 	struct config cfg = {
 		.namespace_id	= NVME_NSID_ALL,
-		.output_format	= "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_UINT("namespace-id",   'n', &cfg.namespace_id,   "(optional) desired namespace"),
-		OPT_FMT("output-format",   'o', &cfg.output_format,  output_format),
-		OPT_INCR("verbose",        'v', &nvme_cfg.verbose, verbose),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_UINT("namespace-id",   'n', &cfg.namespace_id,
+			 "(optional) desired namespace"));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return err;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
-		fprintf(stderr, "Invalid output format '%s'\n", cfg.output_format);
+		fprintf(stderr, "Invalid output format '%s'\n",
+			nvme_args.output_format);
 		return err;
 	}
 
diff --git a/plugins/solidigm/solidigm-telemetry.c b/plugins/solidigm/solidigm-telemetry.c
index 53b468043b..ee8f430816 100644
--- a/plugins/solidigm/solidigm-telemetry.c
+++ b/plugins/solidigm/solidigm-telemetry.c
@@ -89,16 +89,13 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *acmd, stru
 		.ctrl_init  = false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("host-generate",   'g', &cfg.host_gen,  hgen),
 		OPT_FLAG("controller-init", 'c', &cfg.ctrl_init, cgen),
 		OPT_BYTE("data-area",       'd', &cfg.data_area, dgen),
 		OPT_FILE("config-file",     'j', &cfg.cfg_file, cfile),
 		OPT_FILE("source-file",     's', &cfg.binary_file, sfile),
-		OPT_STR("jq-filter",        'q', &cfg.jq_filter, jqfilt),
-		OPT_INCR("verbose",         'v', &nvme_cfg.verbose, verbose),
-		OPT_END()
-	};
+		OPT_STR("jq-filter",        'q', &cfg.jq_filter, jqfilt));
 
 	int err = argconfig_parse(argc, argv, desc, opts);
 
diff --git a/plugins/solidigm/solidigm-temp-stats.c b/plugins/solidigm/solidigm-temp-stats.c
index dd22af2eaf..8ea758b1ce 100644
--- a/plugins/solidigm/solidigm-temp-stats.c
+++ b/plugins/solidigm/solidigm-temp-stats.c
@@ -57,10 +57,8 @@ int sldgm_get_temp_stats_log(int argc, char **argv, struct command *acmd, struct
 		.raw_binary = false,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
diff --git a/plugins/solidigm/solidigm-workload-tracker.c b/plugins/solidigm/solidigm-workload-tracker.c
index 6f16b06974..324755b1ff 100644
--- a/plugins/solidigm/solidigm-workload-tracker.c
+++ b/plugins/solidigm/solidigm-workload-tracker.c
@@ -229,7 +229,7 @@ static void wltracker_print_field_names(struct wltracker *wlt)
 	if (wlt->show_wall_timestamp)
 		printf("%-*s", (int)sizeof("YYYY-MM-DD-hh:mm:ss.uuuuuu"), "wall-time");
 
-	if (nvme_cfg.verbose > 1)
+	if (nvme_args.verbose > 1)
 		printf("%s", "entry# ");
 
 	printf("\n");
@@ -250,7 +250,7 @@ static void wltracker_print_header(struct wltracker *wlt)
 	printf("%-24s %s\n", "Tracker Type:", trk_types[log->config.contentGroup]);
 	printf("%-24s %u\n", "Total log page entries:", le32_to_cpu(log->workloadLogCount));
 	printf("%-24s %u\n", "Trigger count:", log->triggeredEvents);
-	if (nvme_cfg.verbose > 1)
+	if (nvme_args.verbose > 1)
 		printf("%-24s %ld\n", "Poll count:", wlt->poll_count);
 	if (wlt->poll_count != 0)
 		wltracker_print_field_names(wlt);
@@ -302,7 +302,7 @@ static int wltracker_show_newer_entries(struct wltracker *wlt)
 	if (err < 0)
 		return err;
 
-	if (nvme_cfg.verbose)
+	if (nvme_args.verbose)
 		wltracker_print_header(wlt);
 
 	cnt = log->workloadLogCount;
@@ -330,7 +330,7 @@ static int wltracker_show_newer_entries(struct wltracker *wlt)
 			// retrieve fresh timestamp to reconstruct wall time
 			union WorkloadLogEnable we = log->config;
 
-			if (nvme_cfg.verbose > 1) {
+			if (nvme_args.verbose > 1) {
 				printf("Temporarily enabling tracker to find current timestamp\n");
 				printf("Original config value: 0x%08x\n", we.dword);
 			}
@@ -338,7 +338,7 @@ static int wltracker_show_newer_entries(struct wltracker *wlt)
 			we.triggerEnable = false;
 			we.sampleTime = 1;
 
-			if (nvme_cfg.verbose > 1)
+			if (nvme_args.verbose > 1)
 				printf("Modified config value: 0x%08x\n", we.dword);
 
 			err = wltracker_config(wlt, &we);
@@ -356,7 +356,7 @@ static int wltracker_show_newer_entries(struct wltracker *wlt)
 				we = log->config;
 				we.triggerEnable = false;
 				err = wltracker_config(wlt, &we);
-				if (nvme_cfg.verbose > 1)
+				if (nvme_args.verbose > 1)
 					printf("Restored config value: 0x%08x\n",
 					       we.dword);
 			}
@@ -394,7 +394,7 @@ static int wltracker_show_newer_entries(struct wltracker *wlt)
 					       (uint64_t)(epoch_ts_us % 1000000ULL));
 				}
 
-				if (nvme_cfg.verbose > 1)
+				if (nvme_args.verbose > 1)
 					printf("%-*i", (int)sizeof("entry#"), i);
 
 				printf("\n");
@@ -430,7 +430,7 @@ static int wltracker_show_newer_entries(struct wltracker *wlt)
 void wltracker_run_time_update(struct wltracker *wlt)
 {
 	wlt->run_time_us = micros() - wlt->start_time_us;
-	if (nvme_cfg.verbose > 0)
+	if (nvme_args.verbose > 0)
 		printf("run_time: %lluus\n", wlt->run_time_us);
 }
 
@@ -525,7 +525,7 @@ int sldgm_get_workload_tracker(int argc, char **argv, struct command *acmd, stru
 	join_options(type_options, trk_types, ARRAY_SIZE(trk_types));
 	join_options(sample_options, samplet, ARRAY_SIZE(samplet));
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_BYTE("uuid-index",   'U', &wlt.uuid_index, "specify uuid index"),
 		OPT_FLAG("enable", 'e', &cfg.enable, "tracker enable"),
 		OPT_FLAG("disable", 'd', &cfg.disable, "tracker disable"),
@@ -541,10 +541,7 @@ int sldgm_get_workload_tracker(int argc, char **argv, struct command *acmd, stru
 		OPT_FLAG("trigger-on-delta", 'D', &cfg.trigger_on_delta,
 			 "Trigger on delta to stop sampling"),
 		OPT_FLAG("trigger-on-latency", 'L', &cfg.trigger_on_latency,
-			 "Use latency tracker to trigger stop sampling"),
-		OPT_INCR("verbose", 'v', &nvme_cfg.verbose, "Increase logging verbosity"),
-		OPT_END()
-	};
+			 "Use latency tracker to trigger stop sampling"));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -656,7 +653,7 @@ int sldgm_get_workload_tracker(int argc, char **argv, struct command *acmd, stru
 		if (interval > elapsed) {
 			__u64 period_us = min(next_sample_us - wlt.run_time_us,
 					      stop_time_us - wlt.run_time_us);
-			if (nvme_cfg.verbose > 1)
+			if (nvme_args.verbose > 1)
 				printf("Sleeping %lluus..\n", period_us);
 			usleep(period_us);
 			wltracker_run_time_update(&wlt);
@@ -671,7 +668,7 @@ int sldgm_get_workload_tracker(int argc, char **argv, struct command *acmd, stru
 	if (cfg.disable) {
 		union WorkloadLogEnable we2 = wlt.workload_log.config;
 
-		if (nvme_cfg.verbose > 1)
+		if (nvme_args.verbose > 1)
 			printf("Original config value: 0x%08x\n", we2.dword);
 
 		we2.trackerEnable = false;
@@ -684,7 +681,7 @@ int sldgm_get_workload_tracker(int argc, char **argv, struct command *acmd, stru
 			nvme_show_status(err);
 			return err;
 		}
-		if (nvme_cfg.verbose > 1)
+		if (nvme_args.verbose > 1)
 			printf("Modified config value: 0x%08x\n", we2.dword);
 		printf("Tracker disabled\n");
 		return 0;
diff --git a/plugins/ssstc/ssstc-nvme.c b/plugins/ssstc/ssstc-nvme.c
index 76c55c3570..31843ac28e 100644
--- a/plugins/ssstc/ssstc-nvme.c
+++ b/plugins/ssstc/ssstc-nvme.c
@@ -402,12 +402,10 @@ int ssstc_get_add_smart_log(int argc, char **argv, struct command *acmd, struct
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace),
 		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw),
-		OPT_FLAG_JSON("json",    'j', &cfg.json,         json),
-		OPT_END()
-	};
+		OPT_FLAG_JSON("json",    'j', &cfg.json,         json));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
diff --git a/plugins/toshiba/toshiba-nvme.c b/plugins/toshiba/toshiba-nvme.c
index 7d07584c6b..7dfcf2fb3d 100644
--- a/plugins/toshiba/toshiba-nvme.c
+++ b/plugins/toshiba/toshiba-nvme.c
@@ -436,12 +436,10 @@ static int vendor_log(int argc, char **argv, struct command *acmd, struct plugin
 		.log = 0xca
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace),
 		OPT_FILE("output-file",  'o', &cfg.output_file,  output_file),
-		OPT_UINT("log",          'l', &cfg.log,          log),
-		OPT_END()
-	};
+		OPT_UINT("log",          'l', &cfg.log,          log));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -485,11 +483,9 @@ static int internal_log(int argc, char **argv, struct command *acmd, struct plug
 		.prev_log = false
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FILE("output-file", 'o', &cfg.output_file, output_file),
-		OPT_FLAG("prev-log", 'p', &cfg.prev_log, prev_log),
-		OPT_END()
-	};
+		OPT_FLAG("prev-log", 'p', &cfg.prev_log, prev_log));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
@@ -526,9 +522,7 @@ static int clear_correctable_errors(int argc, char **argv, struct command *acmd,
 	__u64 result;
 	int err;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
diff --git a/plugins/transcend/transcend-nvme.c b/plugins/transcend/transcend-nvme.c
index bd088ed526..e62115fc27 100644
--- a/plugins/transcend/transcend-nvme.c
+++ b/plugins/transcend/transcend-nvme.c
@@ -26,9 +26,7 @@ static int getHealthValue(int argc, char **argv, struct command *acmd, struct pl
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	int result;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	result = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (result) {
@@ -61,9 +59,7 @@ static int getBadblock(int argc, char **argv, struct command *acmd, struct plugi
 	unsigned char data[1] = {0};
 	int result;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	result = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (result) {
diff --git a/plugins/virtium/virtium-nvme.c b/plugins/virtium/virtium-nvme.c
index 88ec40db2c..f3fc93251c 100644
--- a/plugins/virtium/virtium-nvme.c
+++ b/plugins/virtium/virtium-nvme.c
@@ -957,13 +957,11 @@ static int vt_save_smart_to_vtview_log(int argc, char **argv,
 		.test_name = NULL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_DOUBLE("run-time",  'r', &cfg.run_time_hrs,             run_time),
 		OPT_DOUBLE("freq",      'f', &cfg.log_record_frequency_hrs, freq),
 		OPT_FILE("output-file", 'o', &cfg.output_file,              output_file),
-		OPT_STRING("test-name", 'n', "NAME", &cfg.test_name,        test_name),
-		OPT_END()
-	};
+		OPT_STRING("test-name", 'n', "NAME", &cfg.test_name,        test_name));
 
 	vt_generate_vtview_log_file_name(vt_default_log_file_name);
 
@@ -1031,9 +1029,7 @@ static int vt_show_identify(int argc, char **argv, struct command *acmd, struct
 	struct nvme_id_ctrl ctrl;
 	int ret, err = 0;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err) {
diff --git a/plugins/wdc/wdc-nvme.c b/plugins/wdc/wdc-nvme.c
index 0937fe6634..46fcc598da 100644
--- a/plugins/wdc/wdc-nvme.c
+++ b/plugins/wdc/wdc-nvme.c
@@ -3912,11 +3912,9 @@ static int wdc_cap_diag(int argc, char **argv, struct command *acmd,
 		.xfer_size = 0x10000
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FILE("output-file",   'o', &cfg.file,      file),
-		OPT_UINT("transfer-size", 's', &cfg.xfer_size, size),
-		OPT_END()
-	};
+		OPT_UINT("transfer-size", 's', &cfg.xfer_size, size));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -4306,7 +4304,6 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *acmd,
 		"  NONE - Default, capture without using NVMe telemetry.\n" \
 		"  HOST - Host-initiated telemetry.\n" \
 		"  CONTROLLER - Controller-initiated telemetry.";
-	const char *verbose = "Display more debug messages.";
 	char f[PATH_MAX] = {0};
 	char fb[PATH_MAX/2] = {0};
 	char fileSuffix[PATH_MAX] = {0};
@@ -4329,7 +4326,6 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *acmd,
 		__u64 file_size;
 		__u64 offset;
 		char *type;
-		bool verbose;
 	};
 
 	struct config cfg = {
@@ -4339,19 +4335,15 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *acmd,
 		.file_size = 0,
 		.offset = 0,
 		.type = NULL,
-		.verbose = false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FILE("output-file",   'o', &cfg.file,      file),
 		OPT_UINT("transfer-size", 's', &cfg.xfer_size, size),
 		OPT_UINT("data-area",     'd', &cfg.data_area, data_area),
 		OPT_LONG("file-size",     'f', &cfg.file_size, file_size),
 		OPT_LONG("offset",        'e', &cfg.offset,    offset),
-		OPT_FILE("type",          't', &cfg.type,      type),
-		OPT_FLAG("verbose",       'v', &cfg.verbose,   verbose),
-		OPT_END()
-	};
+		OPT_FILE("type",          't', &cfg.type,      type));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -4485,7 +4477,7 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *acmd,
 			ret = wdc_do_cap_diag(ctx, hdl, f, xfer_size,
 					telemetry_type, telemetry_data_area);
 		} else {
-			if (cfg.verbose)
+			if (nvme_args.verbose)
 				printf("Creating temp directory...\n");
 
 			ret = mkdir(fb, 0666);
@@ -4494,11 +4486,11 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *acmd,
 				goto out;
 			}
 
-			ret = dump_internal_logs(hdl, fb, cfg.verbose);
+			ret = dump_internal_logs(hdl, fb, nvme_args.verbose);
 			if (ret < 0)
 				perror("vs-internal-log");
 
-			if (cfg.verbose)
+			if (nvme_args.verbose)
 				printf("Archiving...\n");
 
 			if (snprintf(cmd_buf, PATH_MAX,
@@ -4536,7 +4528,7 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *acmd,
 				xfer_size = 0x40000;
 			ret = wdc_do_cap_dui(hdl, f, xfer_size,
 					 cfg.data_area,
-					 cfg.verbose, cfg.file_size,
+					 nvme_args.verbose, cfg.file_size,
 					 cfg.offset);
 			goto out;
 		}
@@ -4555,7 +4547,7 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *acmd,
 		} else {
 			ret = wdc_do_cap_dui(hdl, f, xfer_size,
 					     WDC_NVME_DUI_MAX_DATA_AREA,
-					     cfg.verbose, 0, 0);
+					     nvme_args.verbose, 0, 0);
 			goto out;
 		}
 	}
@@ -4719,10 +4711,8 @@ static int wdc_drive_log(int argc, char **argv, struct command *acmd,
 		.file = NULL
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FILE("output-file", 'o', &cfg.file, file),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FILE("output-file", 'o', &cfg.file, file));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -4767,10 +4757,8 @@ static int wdc_get_crash_dump(int argc, char **argv, struct command *acmd,
 		.file = NULL,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FILE("output-file", 'o', &cfg.file, file),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FILE("output-file", 'o', &cfg.file, file));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -4810,10 +4798,8 @@ static int wdc_get_pfail_dump(int argc, char **argv, struct command *acmd,
 		.file = NULL,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FILE("output-file", 'o', &cfg.file, file),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_FILE("output-file", 'o', &cfg.file, file));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -4892,9 +4878,7 @@ static int wdc_purge(int argc, char **argv,
 	char *err_str;
 	int ret;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -4946,9 +4930,7 @@ static int wdc_purge_monitor(int argc, char **argv,
 	__u64 capabilities;
 	int ret;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -8310,7 +8292,6 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *acmd,
 
 	struct config {
 		uint8_t interval;
-		char *output_format;
 		__u8  log_page_version;
 		char *log_page_mask;
 		__u32 namespace_id;
@@ -8318,20 +8299,16 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *acmd,
 
 	struct config cfg = {
 		.interval = 14,
-		.output_format = "normal",
 		.log_page_version   = 0,
 		.log_page_mask   = "",
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("interval",          'i', &cfg.interval,         interval),
-		OPT_FMT("output-format",      'o', &cfg.output_format,    output_format),
 		OPT_BYTE("log-page-version",  'l', &cfg.log_page_version, log_page_version),
 		OPT_LIST("log-page-mask",     'p', &cfg.log_page_mask,    log_page_mask),
-		OPT_UINT("namespace-id",      'n', &cfg.namespace_id,     namespace_id),
-		OPT_END()
-	};
+		OPT_UINT("namespace-id",      'n', &cfg.namespace_id,     namespace_id));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -8390,16 +8367,19 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *acmd,
 	    (page_mask & WDC_C0_PAGE_MASK)) {
 		/* Get 0xC0 log page if possible. */
 		if (!wdc_is_sn861(device_id)) {
-			ret = wdc_get_c0_log_page(ctx, hdl, cfg.output_format,
-						uuid_index, cfg.namespace_id);
+			ret = wdc_get_c0_log_page(ctx, hdl,
+				nvme_args.output_format,
+				uuid_index, cfg.namespace_id);
 			if (ret)
 				fprintf(stderr,
 					"ERROR: WDC: Failure reading the C0 Log Page, ret = %d\n",
 					ret);
 		} else {
-			ret = validate_output_format(cfg.output_format, &fmt);
+			ret = validate_output_format(nvme_args.output_format,
+				&fmt);
 			if (ret < 0) {
-				fprintf(stderr, "Invalid output format: %s\n", cfg.output_format);
+				fprintf(stderr, "Invalid output format: %s\n",
+					nvme_args.output_format);
 				goto out;
 			}
 
@@ -8413,14 +8393,14 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *acmd,
 	    (page_mask & WDC_CA_PAGE_MASK) &&
 	    (!wdc_is_sn861(device_id))) {
 		/* Get the CA Log Page */
-		ret = wdc_get_ca_log_page(ctx, hdl, cfg.output_format);
+		ret = wdc_get_ca_log_page(ctx, hdl, nvme_args.output_format);
 		if (ret)
 			fprintf(stderr, "ERROR: WDC: Failure reading the CA Log Page, ret = %d\n", ret);
 	}
 	if (((capabilities & WDC_DRIVE_CAP_C1_LOG_PAGE) == WDC_DRIVE_CAP_C1_LOG_PAGE) &&
 	    (page_mask & WDC_C1_PAGE_MASK)) {
 		/* Get the C1 Log Page */
-		ret = wdc_get_c1_log_page(ctx, hdl, cfg.output_format,
+		ret = wdc_get_c1_log_page(ctx, hdl, nvme_args.output_format,
 					  cfg.interval);
 		if (ret)
 			fprintf(stderr, "ERROR: WDC: Failure reading the C1 Log Page, ret = %d\n", ret);
@@ -8428,7 +8408,7 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *acmd,
 	if (((capabilities & WDC_DRIVE_CAP_D0_LOG_PAGE) == WDC_DRIVE_CAP_D0_LOG_PAGE) &&
 	    (page_mask & WDC_D0_PAGE_MASK)) {
 		/* Get the D0 Log Page */
-		ret = wdc_get_d0_log_page(ctx, hdl, cfg.output_format);
+		ret = wdc_get_d0_log_page(ctx, hdl, nvme_args.output_format);
 		if (ret)
 			fprintf(stderr, "ERROR: WDC: Failure reading the D0 Log Page, ret = %d\n", ret);
 	}
@@ -8452,20 +8432,15 @@ static int wdc_cu_smart_log(int argc, char **argv, struct command *acmd,
 	__u8 *data;
 
 	struct config {
-		char *output_format;
 		int uuid_index;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
 		.uuid_index = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format",      'o', &cfg.output_format,    output_format),
-		OPT_UINT("uuid-index",        'u', &cfg.uuid_index,       uuid_index),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_UINT("uuid-index",        'u', &cfg.uuid_index,       uuid_index));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -8486,7 +8461,7 @@ static int wdc_cu_smart_log(int argc, char **argv, struct command *acmd,
 		if (!wdc_check_device(ctx, hdl))
 			return -1;
 
-		ret = validate_output_format(cfg.output_format, &fmt);
+		ret = validate_output_format(nvme_args.output_format, &fmt);
 
 		if (ret < 0) {
 			fprintf(stderr, "ERROR: WDC: invalid output format\n");
@@ -8524,7 +8499,7 @@ static int wdc_cu_smart_log(int argc, char **argv, struct command *acmd,
 			ret = nvme_get_log(hdl, &cmd, false,
 						NVME_LOG_PAGE_PDU_SIZE);
 
-			if (strcmp(cfg.output_format, "json"))
+			if (strcmp(nvme_args.output_format, "json"))
 				nvme_show_status(ret);
 
 			if (!ret) {
@@ -8572,11 +8547,8 @@ static int wdc_vs_cloud_log(int argc, char **argv, struct command *acmd,
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format",      'o', &cfg.output_format,    "Output Format: normal|json"),
-		OPT_UINT("namespace-id",      'n', &cfg.namespace_id,     namespace_id),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_UINT("namespace-id",      'n', &cfg.namespace_id,     namespace_id));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -8642,11 +8614,8 @@ static int wdc_vs_hw_rev_log(int argc, char **argv, struct command *acmd,
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format",      'o', &cfg.output_format,    "Output Format: normal|json"),
-		OPT_UINT("namespace-id",      'n', &cfg.namespace_id,     namespace_id),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_UINT("namespace-id",      'n', &cfg.namespace_id,     namespace_id));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -8733,11 +8702,8 @@ static int wdc_vs_device_waf(int argc, char **argv, struct command *acmd,
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format",      'o', &cfg.output_format,    "Output Format: normal|json"),
-		OPT_UINT("namespace-id",      'n', &cfg.namespace_id,     namespace_id),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_UINT("namespace-id",      'n', &cfg.namespace_id,     namespace_id));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -8841,10 +8807,7 @@ static int wdc_get_latency_monitor_log(int argc, char **argv, struct command *ac
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format",      'o', &cfg.output_format,    "Output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -8886,10 +8849,7 @@ static int wdc_get_error_recovery_log(int argc, char **argv, struct command *acm
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format",      'o', &cfg.output_format,    "Output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -8932,10 +8892,7 @@ static int wdc_get_dev_capabilities_log(int argc, char **argv, struct command *a
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format",      'o', &cfg.output_format,    "Output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -8978,10 +8935,7 @@ static int wdc_get_unsupported_reqs_log(int argc, char **argv, struct command *a
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format",      'o', &cfg.output_format,    "Output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -9057,9 +9011,7 @@ static int wdc_clear_pcie_correctable_errors(int argc, char **argv, struct comma
 	__u64 capabilities = 0;
 	int ret;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -9105,9 +9057,7 @@ static int wdc_drive_status(int argc, char **argv, struct command *acmd,
 	__u64 capabilities = 0;
 	struct nvme_id_uuid_list uuid_list;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -9251,9 +9201,7 @@ static int wdc_clear_assert_dump(int argc, char **argv, struct command *acmd,
 	__u64 capabilities = 0;
 	struct nvme_passthru_cmd admin_cmd;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -9476,10 +9424,7 @@ static int wdc_vs_fw_activate_history(int argc, char **argv, struct command *acm
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "Output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -9562,9 +9507,7 @@ static int wdc_clear_fw_activate_history(int argc, char **argv, struct command *
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	int ret;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -9617,12 +9560,10 @@ static int wdc_vs_telemetry_controller_option(int argc, char **argv, struct comm
 		.status = false,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FLAG("disable",       'd', &cfg.disable,   disable),
 		OPT_FLAG("enable",        'e', &cfg.enable,    enable),
-		OPT_FLAG("status",        's', &cfg.status,    status),
-		OPT_END()
-	};
+		OPT_FLAG("status",        's', &cfg.status,    status));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -10410,10 +10351,8 @@ static int wdc_drive_essentials(int argc, char **argv, struct command *acmd,
 		.dirName = NULL,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_STRING("dir-name", 'd', "DIRECTORY", &cfg.dirName, dirName),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_STRING("dir-name", 'd', "DIRECTORY", &cfg.dirName, dirName));
 
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
@@ -10509,10 +10448,8 @@ static int wdc_drive_resize(int argc, char **argv,
 		.size = 0,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_UINT("size", 's', &cfg.size, size),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_UINT("size", 's', &cfg.size, size));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -10559,11 +10496,9 @@ static int wdc_namespace_resize(int argc, char **argv,
 		.op_option = 0xF,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
-		OPT_UINT("op-option", 'o', &cfg.op_option, op_option),
-		OPT_END()
-	};
+		OPT_UINT("op-option", 'o', &cfg.op_option, op_option));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -10621,11 +10556,9 @@ static int wdc_reason_identifier(int argc, char **argv,
 		.file = NULL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("log-id", 'i', &cfg.log_id, log_id),
-		OPT_FILE("file",   'o', &cfg.file,   fname),
-		OPT_END()
-	};
+		OPT_FILE("file",   'o', &cfg.file,   fname));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 
@@ -10883,10 +10816,7 @@ static int wdc_log_page_directory(int argc, char **argv, struct command *acmd,
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "Output Format: normal|json|binary"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -11636,10 +11566,7 @@ static int wdc_vs_nand_stats(int argc, char **argv, struct command *acmd,
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "Output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -11716,10 +11643,7 @@ static int wdc_vs_pcie_stats(int argc, char **argv, struct command *acmd,
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "Output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -11806,10 +11730,7 @@ static int wdc_vs_drive_info(int argc, char **argv,
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "Output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -12059,10 +11980,7 @@ static int wdc_vs_temperature_stats(int argc, char **argv,
 		.output_format = "normal",
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, "Output Format: normal|json"),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -12164,9 +12082,7 @@ static int wdc_capabilities(int argc, char **argv, struct command *acmd, struct
 	uint64_t capabilities = 0;
 	int ret;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -12271,9 +12187,7 @@ static int wdc_cloud_ssd_plugin_version(int argc, char **argv, struct command *a
 	uint64_t capabilities = 0;
 	int ret;
 
-	OPT_ARGS(opts) = {
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -12317,10 +12231,8 @@ static int wdc_cloud_boot_SSD_version(int argc, char **argv, struct command *acm
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
-		OPT_UINT("namespace-id",      'n', &cfg.namespace_id,     namespace_id),
-		OPT_END()
-	};
+	NVME_ARGS(opts,
+		OPT_UINT("namespace-id",      'n', &cfg.namespace_id,     namespace_id));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (ret)
@@ -12383,12 +12295,10 @@ static int wdc_enc_get_log(int argc, char **argv, struct command *acmd, struct p
 		.log_id = 0xffffffff,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_FILE("output-file",   'o', &cfg.file,  file),
 		OPT_UINT("transfer-size", 's', &cfg.xfer_size, size),
-		OPT_UINT("log-id",        'l', &cfg.log_id, log),
-		OPT_END()
-	};
+		OPT_UINT("log-id",        'l', &cfg.log_id, log));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -12679,7 +12589,7 @@ int wdc_set_latency_monitor_feature(int argc, char **argv, struct command *acmd,
 		.latency_monitor_feature_enable = 0x7,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("active_bucket_timer_threshold", 't',
 			&cfg.active_bucket_timer_threshold,
 			active_bucket_timer_threshold),
@@ -12702,9 +12612,7 @@ int wdc_set_latency_monitor_feature(int argc, char **argv, struct command *acmd,
 			discard_debug_log),
 		OPT_UINT("latency_monitor_feature_enable", 'e',
 			&cfg.latency_monitor_feature_enable,
-			latency_monitor_feature_enable),
-		OPT_END()
-	};
+			latency_monitor_feature_enable));
 
 	ret = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 
diff --git a/plugins/ymtc/ymtc-nvme.c b/plugins/ymtc/ymtc-nvme.c
index 69d57cf2de..f65ce037cd 100644
--- a/plugins/ymtc/ymtc-nvme.c
+++ b/plugins/ymtc/ymtc-nvme.c
@@ -135,11 +135,9 @@ static int get_additional_smart_log(int argc, char **argv, struct command *acmd,
 		.namespace_id = NVME_NSID_ALL,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace),
-		OPT_FLAG("raw-binary",	 'b', &cfg.raw_binary,	  raw),
-		OPT_END()
-	};
+		OPT_FLAG("raw-binary",	 'b', &cfg.raw_binary,	  raw));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
diff --git a/plugins/zns/zns.c b/plugins/zns/zns.c
index bac0ad4aa4..9c1c1155ae 100644
--- a/plugins/zns/zns.c
+++ b/plugins/zns/zns.c
@@ -136,24 +136,13 @@ static int id_ctrl(int argc, char **argv, struct command *acmd, struct plugin *p
 	nvme_print_flags_t flags;
 	int err = -1;
 
-	struct config {
-		char *output_format;
-	};
-
-	struct config cfg = {
-		.output_format = "normal",
-	};
-
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_END()
-	};
+	NVME_ARGS(opts);
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return errno;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0)
 		return err;
 
@@ -185,29 +174,23 @@ static int id_ns(int argc, char **argv, struct command *acmd, struct plugin *plu
 	int err = -1;
 
 	struct config {
-		char *output_format;
 		__u32 namespace_id;
 		bool human_readable;
 		bool vendor_specific;
 	};
 
-	struct config cfg = {
-		.output_format = "normal",
-	};
+	struct config cfg = { };
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace_id),
 		OPT_FLAG("vendor-specific", 'v', &cfg.vendor_specific, vendor_specific),
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_FLAG("human-readable", 'H', &cfg.human_readable, human_readable),
-		OPT_END()
-	};
+		OPT_FLAG("human-readable", 'H', &cfg.human_readable, human_readable));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return errno;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0)
 		return err;
 	if (cfg.vendor_specific)
@@ -245,7 +228,6 @@ static int zns_mgmt_send(int argc, char **argv, struct command *acmd, struct plu
 {
 	const char *zslba = "starting LBA of the zone for this command";
 	const char *select_all = "send command to all zones";
-	const char *timeout = "timeout value, in milliseconds";
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -256,18 +238,14 @@ static int zns_mgmt_send(int argc, char **argv, struct command *acmd, struct plu
 		__u64	zslba;
 		__u32	namespace_id;
 		bool	select_all;
-		__u32	timeout;
 	};
 
 	struct config cfg = {};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace_id),
 		OPT_SUFFIX("start-lba",  's', &cfg.zslba,         zslba),
-		OPT_FLAG("select-all",   'a', &cfg.select_all,    select_all),
-		OPT_UINT("timeout",      't', &cfg.timeout,       timeout),
-		OPT_END()
-	};
+		OPT_FLAG("select-all",   'a', &cfg.select_all,    select_all));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -344,7 +322,6 @@ static int zone_mgmt_send(int argc, char **argv, struct command *acmd, struct pl
 	const char *zsa = "zone send action";
 	const char *data_len = "buffer length if data required";
 	const char *data = "optional file for data (default stdin)";
-	const char *timeout = "timeout value, in milliseconds";
 
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
@@ -360,22 +337,18 @@ static int zone_mgmt_send(int argc, char **argv, struct command *acmd, struct pl
 		__u8	zsa;
 		int	data_len;
 		char	*file;
-		__u32	timeout;
 	};
 
 	struct config cfg = {};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace_id),
 		OPT_SUFFIX("start-lba",  's', &cfg.zslba,         zslba),
 		OPT_FLAG("zsaso",        'o', &cfg.zsaso,         zsaso),
 		OPT_FLAG("select-all",   'a', &cfg.select_all,    select_all),
 		OPT_BYTE("zsa",          'z', &cfg.zsa,           zsa),
 		OPT_UINT("data-len",     'l', &cfg.data_len,      data_len),
-		OPT_FILE("data",         'd', &cfg.file,          data),
-		OPT_UINT("timeout",      't', &cfg.timeout,       timeout),
-		OPT_END()
-	};
+		OPT_FILE("data",         'd', &cfg.file,          data));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -473,7 +446,6 @@ static int open_zone(int argc, char **argv, struct command *acmd, struct plugin
 	const char *zslba = "starting LBA of the zone for this command";
 	const char *zrwaa = "Allocate Zone Random Write Area to zone";
 	const char *select_all = "send command to all zones";
-	const char *timeout = "timeout value, in milliseconds";
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -484,20 +456,16 @@ static int open_zone(int argc, char **argv, struct command *acmd, struct plugin
 		__u32	namespace_id;
 		bool	zrwaa;
 		bool	select_all;
-		__u32	timeout;
 	};
 
 	struct config cfg = {
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace_id),
 		OPT_SUFFIX("start-lba",  's', &cfg.zslba,         zslba),
 		OPT_FLAG("zrwaa",         'r', &cfg.zrwaa,          zrwaa),
-		OPT_FLAG("select-all",   'a', &cfg.select_all,    select_all),
-		OPT_UINT("timeout",      't', &cfg.timeout,       timeout),
-		OPT_END()
-	};
+		OPT_FLAG("select-all",   'a', &cfg.select_all,    select_all));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -546,7 +514,6 @@ static int set_zone_desc(int argc, char **argv, struct command *acmd, struct plu
 	const char *zslba = "starting LBA of the zone for this command";
 	const char *zrwaa = "Allocate Zone Random Write Area to zone";
 	const char *data = "optional file for zone extension data (default stdin)";
-	const char *timeout = "timeout value, in milliseconds";
 
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
@@ -560,19 +527,15 @@ static int set_zone_desc(int argc, char **argv, struct command *acmd, struct plu
 		bool	zrwaa;
 		__u32	namespace_id;
 		char   *file;
-		__u32	timeout;
 	};
 
 	struct config cfg = {};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace_id),
 		OPT_SUFFIX("start-lba",  's', &cfg.zslba,         zslba),
 		OPT_FLAG("zrwaa",        'r', &cfg.zrwaa,         zrwaa),
-		OPT_FILE("data",         'd', &cfg.file,          data),
-		OPT_UINT("timeout",      't', &cfg.timeout,       timeout),
-		OPT_END()
-	};
+		OPT_FILE("data",         'd', &cfg.file,          data));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -640,7 +603,6 @@ static int zrwa_flush_zone(int argc, char **argv, struct command *acmd, struct p
 {
 	const char *desc = "Flush Explicit ZRWA Range";
 	const char *slba = "LBA to flush up to";
-	const char *timeout = "timeout value, in milliseconds";
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -649,17 +611,13 @@ static int zrwa_flush_zone(int argc, char **argv, struct command *acmd, struct p
 	struct config {
 		__u64	lba;
 		__u32	namespace_id;
-		__u32	timeout;
 	};
 
 	struct config cfg = {};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace_id),
-		OPT_SUFFIX("lba",        'l', &cfg.lba,           slba),
-		OPT_UINT("timeout",      't', &cfg.timeout,       timeout),
-		OPT_END()
-	};
+		OPT_SUFFIX("lba",        'l', &cfg.lba,           slba));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -704,7 +662,6 @@ static int zone_mgmt_recv(int argc, char **argv, struct command *acmd, struct pl
 	int err = -1;
 
 	struct config {
-		char *output_format;
 		__u64  zslba;
 		__u32  namespace_id;
 		__u8   zra;
@@ -713,26 +670,21 @@ static int zone_mgmt_recv(int argc, char **argv, struct command *acmd, struct pl
 		__u32  data_len;
 	};
 
-	struct config cfg = {
-		.output_format = "normal",
-	};
+	struct config cfg = { };
 
-	OPT_ARGS(opts) = {
-		OPT_FMT("output-format",  'o', &cfg.output_format,  output_format),
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id",  'n', &cfg.namespace_id,   namespace_id),
 		OPT_SUFFIX("start-lba",   's', &cfg.zslba,          zslba),
 		OPT_BYTE("zra",           'z', &cfg.zra,            zra),
 		OPT_BYTE("zrasf",         'S', &cfg.zrasf,          zrasf),
 		OPT_FLAG("partial",       'p', &cfg.partial,        partial),
-		OPT_UINT("data-len",      'l', &cfg.data_len,       data_len),
-		OPT_END()
-	};
+		OPT_UINT("data-len",      'l', &cfg.data_len,       data_len));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return errno;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0)
 		return err;
 
@@ -804,7 +756,6 @@ static int report_zones(int argc, char **argv, struct command *acmd, struct plug
 	struct json_object *zone_list = NULL;
 
 	struct config {
-		char *output_format;
 		__u64 zslba;
 		__u32 namespace_id;
 		int   num_descs;
@@ -815,27 +766,23 @@ static int report_zones(int argc, char **argv, struct command *acmd, struct plug
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
 		.num_descs = -1,
 	};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id",  'n', &cfg.namespace_id,   namespace_id),
 		OPT_SUFFIX("start-lba",   's', &cfg.zslba,          zslba),
 		OPT_UINT("descs",         'd', &cfg.num_descs,      num_descs),
 		OPT_UINT("state",         'S', &cfg.state,          state),
-		OPT_FMT("output-format",  'o', &cfg.output_format,  output_format),
 		OPT_FLAG("verbose",       'v', &cfg.verbose,        verbose),
 		OPT_FLAG("extended",      'e', &cfg.extended,       ext),
-		OPT_FLAG("partial",       'p', &cfg.partial,        part),
-		OPT_END()
-	};
+		OPT_FLAG("partial",       'p', &cfg.partial,        part));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return errno;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0)
 		return err;
 	if (cfg.verbose)
@@ -992,7 +939,7 @@ static int zone_append(int argc, char **argv, struct command *acmd, struct plugi
 
 	struct config cfg = {};
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace_id),
 		OPT_SUFFIX("zslba",           's', &cfg.zslba,         zslba),
 		OPT_SUFFIX("data-size",       'z', &cfg.data_size,     data_size),
@@ -1003,9 +950,7 @@ static int zone_append(int argc, char **argv, struct command *acmd, struct plugi
 		OPT_FLAG("force-unit-access", 'f', &cfg.fua,           fua),
 		OPT_BYTE("prinfo",            'p', &cfg.prinfo,        prinfo),
 		OPT_FLAG("piremap",           'P', &cfg.piremap,       piremap),
-		OPT_FLAG("latency",           't', &cfg.latency,       latency),
-		OPT_END()
-	};
+		OPT_FLAG("latency",           't', &cfg.latency,       latency));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
@@ -1152,27 +1097,21 @@ static int changed_zone_list(int argc, char **argv, struct command *acmd, struct
 	int err = -1;
 
 	struct config {
-		char *output_format;
 		__u32 namespace_id;
 		bool  rae;
 	};
 
-	struct config cfg = {
-		.output_format = "normal",
-	};
+	struct config cfg = { };
 
-	OPT_ARGS(opts) = {
+	NVME_ARGS(opts,
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace_id),
-		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_FLAG("rae",          'r', &cfg.rae,           rae),
-		OPT_END()
-	};
+		OPT_FLAG("rae",          'r', &cfg.rae,           rae));
 
 	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
 	if (err)
 		return errno;
 
-	err = validate_output_format(cfg.output_format, &flags);
+	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0)
 		return err;
 
diff --git a/scripts/build.sh b/scripts/build.sh
index f69b54fa9c..2109a6bbdc 100755
--- a/scripts/build.sh
+++ b/scripts/build.sh
@@ -23,7 +23,9 @@ usage() {
     echo "  cross               use cross toolchain to build"
     echo "  coverage            build coverage report"
     echo "  distro              build libnvme and nvme-cli separately"
-    echo "  docs                build documentation"
+    echo "  docs                build all documentation"
+    echo "  html_docs           build html documentation only"
+    echo "  rst_docs            build rst documentation only"
     echo "  static              build a static binary"
     echo "  libnvme             build only libnvme"
     echo ""
@@ -123,12 +125,34 @@ config_meson_coverage() {
 
 config_meson_docs() {
     CC="${CC}" "${MESON}" setup                 \
+        -Dnvme=disabled                         \
+        -Dlibnvme=disabled                      \
         -Ddocs=all                              \
         -Ddocs-build=true                       \
         --prefix=/tmp/usr                       \
         "${BUILDDIR}"
 }
 
+config_meson_html_docs() {
+    CC="${CC}" "${MESON}" setup                 \
+        -Dnvme=disabled                         \
+        -Dlibnvme=disabled                      \
+        -Ddocs=html                             \
+        -Ddocs-build=true                       \
+        --prefix=/tmp/usr                       \
+        "${BUILDDIR}"
+}
+
+config_meson_rst_docs() {
+    CC="${CC}" "${MESON}" setup                 \
+        -Dnvme=disabled                         \
+        -Dlibnvme=disabled                      \
+        -Ddocs=rst                              \
+        -Ddocs-build=true                       \
+        --prefix=/tmp/usr                       \
+        "${BUILDDIR}"
+}
+
 config_meson_static() {
     CC="${CC}" "${MESON}" setup                 \
         --werror                                \
@@ -146,8 +170,8 @@ config_meson_libnvme() {
     CC="${CC}" "${MESON}" setup                 \
         --werror                                \
         --buildtype="${BUILDTYPE}"              \
-	-Dnvme=disabled				\
-	-Dlibnvme=enabled			\
+        -Dnvme=disabled                         \
+        -Dlibnvme=enabled                       \
         "${BUILDDIR}"
 }
 

From a6fc1781c4a82d7fdf03234433c1cdc40594104e Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Tue, 17 Feb 2026 12:55:36 -0700
Subject: [PATCH 27/83] Updated stub for nvme_dump_config.

The signature changed in the latest tree.h changes.
Updated to match.
---
 libnvme/src/nvme/windows-stubs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 9ff0d12c9c..244baffd24 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -675,11 +675,11 @@ int nvme_dump_tree(struct nvme_global_ctx *ctx)
 	return -1;
 }
 
-int nvme_dump_config(struct nvme_global_ctx *ctx, const char *config_file)
+int nvme_dump_config(struct nvme_global_ctx *ctx, int fd)
 {
 	stub_log(__func__);
 	(void)ctx;
-	(void)config_file;
+	(void)fd;
 	errno = ENOTSUP;
 	return -1;
 }

From d2730a66685ade503725159aaf37d097411b0022 Mon Sep 17 00:00:00 2001
From: Brandon Capener <bcapener@micron.com>
Date: Thu, 19 Feb 2026 15:50:05 -0700
Subject: [PATCH 28/83] Enable id-ctrl command (#54)

Add support for nvme_open, nvme_close, nvme_alloc_huge, nvme_free_huge.
tested command: `nvme id-ctrl PhysicalDrive0`
I added `windows.c` for implementations of functions from linux.h

Add new free functions that must match the allocation function
* `posix_memalign` uses new `platform_aligned_free` function. used in
both nvme-cli and libnvme.
* `nvme_alloc` uses new `nvme_free` function. used in nvme-cli
* `__nvme_alloc` uses new `__nvme_free` function. used in libnvme

---------

Co-authored-by: Broc Going <bgoing@micron.com>
---
 libnvme/src/libnvme.ld                    |   1 +
 libnvme/src/meson.build                   |   5 +-
 libnvme/src/nvme/cleanup.h                |   7 +
 libnvme/src/nvme/fabrics.c                |  10 +-
 libnvme/src/nvme/linux.c                  |  12 +-
 libnvme/src/nvme/private.h                |   2 +
 libnvme/src/nvme/tree.c                   |   6 +-
 libnvme/src/nvme/util.c                   |   7 +-
 libnvme/src/nvme/windows-stubs.c          | 265 ++++++----------------
 libnvme/src/nvme/windows.c                | 193 ++++++++++++++++
 libnvme/src/platform/linux.h              |  10 +
 libnvme/src/platform/windows.h            |  23 +-
 nvme-rpmb.c                               |   2 +-
 nvme.c                                    | 210 ++++++++---------
 plugins/feat/feat-nvme.c                  |   2 +-
 plugins/memblaze/memblaze-nvme.c          |   2 +-
 plugins/micron/micron-nvme.c              |   2 +-
 plugins/netapp/netapp-nvme.c              |   4 +-
 plugins/ocp/ocp-nvme.c                    |   6 +-
 plugins/shannon/shannon-nvme.c            |   4 +-
 plugins/solidigm/solidigm-internal-logs.c |   2 +-
 plugins/toshiba/toshiba-nvme.c            |   8 +-
 plugins/wdc/wdc-nvme.c                    |   2 +-
 plugins/zns/zns.c                         |   6 +-
 util/cleanup.h                            |   6 +
 util/mem-windows.c                        |  97 ++++++++
 util/mem.c                                |  12 +-
 util/mem.h                                |   1 +
 util/meson.build                          |   6 +
 29 files changed, 578 insertions(+), 335 deletions(-)
 create mode 100644 libnvme/src/nvme/windows.c
 create mode 100644 util/mem-windows.c

diff --git a/libnvme/src/libnvme.ld b/libnvme/src/libnvme.ld
index 818a2072cd..0e7727a795 100644
--- a/libnvme/src/libnvme.ld
+++ b/libnvme/src/libnvme.ld
@@ -350,6 +350,7 @@ LIBNVME_2_0 {
 		nvmf_treq_str;
 		nvmf_trtype_str;
 		nvmf_update_config;
+		platform_aligned_free;
 	local:
 		*;
 };
diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index 7244ff0d86..ebb20a1afd 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -9,8 +9,10 @@ sources = [
     'nvme/base64.c',
     'nvme/crc32.c',
     'nvme/ioctl.c',
+    'nvme/linux.c',
     'nvme/log.c',
     'nvme/nbft.c',
+    'nvme/tree.c',
     'nvme/util.c',
 ]
 
@@ -19,6 +21,7 @@ if is_windows
     # Windows-specific sources (exclude Linux networking, fabrics, and filesystem code)
     sources += [
         'nvme/ioctl-windows.c',  # Windows stubs for Linux-specific ioctl functions
+        'nvme/windows.c',  # Windows implementations of linux.h functions
         'nvme/windows-stubs.c',  # Stubs for excluded functions
         'platform/windows.c',  # POSIX compatibility implementations
     ]
@@ -27,10 +30,8 @@ else
     sources += [
         'nvme/fabrics.c',
         'nvme/filters.c',
-        'nvme/linux.c',
         'nvme/mi-mctp.c',
         'nvme/mi.c',
-        'nvme/tree.c',
         'nvme/sysfs.c',
     ]
 endif
diff --git a/libnvme/src/nvme/cleanup.h b/libnvme/src/nvme/cleanup.h
index e17657938e..2cc7667cf3 100644
--- a/libnvme/src/nvme/cleanup.h
+++ b/libnvme/src/nvme/cleanup.h
@@ -9,6 +9,7 @@
 #include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
 
 #include "fabrics.h"
+#include "private.h"
 
 #define __cleanup__(fn) __attribute__((cleanup(fn)))
 
@@ -28,6 +29,12 @@ static inline void freep(void *p)
 }
 #define _cleanup_free_ __cleanup__(freep)
 
+static inline void nvme_freep(void *p)
+{
+	__nvme_free(*(void **)p);
+}
+#define _cleanup_nvme_free_ __cleanup__(nvme_freep)
+
 static inline DEFINE_CLEANUP_FUNC(cleanup_file, FILE *, fclose)
 #define _cleanup_file_ __cleanup__(cleanup_file)
 
diff --git a/libnvme/src/nvme/fabrics.c b/libnvme/src/nvme/fabrics.c
index 62100b6c54..0cf5d7b27c 100644
--- a/libnvme/src/nvme/fabrics.c
+++ b/libnvme/src/nvme/fabrics.c
@@ -1283,7 +1283,7 @@ static int nvme_discovery_log(const struct nvme_get_discovery_args *args,
 		if (numrec == 0)
 			break;
 
-		free(log);
+		__nvme_free(log);
 		entries_size = sizeof(*log->entries) * numrec;
 		log = __nvme_alloc(sizeof(*log) + entries_size);
 		if (!log) {
@@ -1340,7 +1340,7 @@ static int nvme_discovery_log(const struct nvme_get_discovery_args *args,
 	}
 
 out_free_log:
-	free(log);
+	__nvme_free(log);
 	return err;
 }
 
@@ -1857,7 +1857,7 @@ static const char *dctype_str[] = {
  */
 static int nvme_fetch_cntrltype_dctype_from_id(nvme_ctrl_t c)
 {
-	_cleanup_free_ struct nvme_id_ctrl *id = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *id = NULL;
 	int ret;
 
 	id = __nvme_alloc(sizeof(*id));
@@ -2346,7 +2346,7 @@ static int nvmf_create_discovery_ctrl(struct nvme_global_ctx *ctx,
 		struct fabric_args *trcfg,
 		struct nvme_ctrl **ctrl)
 {
-	_cleanup_free_ struct nvme_id_ctrl *id = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *id = NULL;
 	struct nvme_ctrl *c;
 	int ret;
 
@@ -3211,7 +3211,7 @@ static int nvmf_create_discover_ctrl(struct nvme_global_ctx *ctx,
 		struct nvme_host *h, struct nvme_fabrics_config *cfg,
 		struct fabric_args *trcfg, struct nvme_ctrl **ctrl)
 {
-	_cleanup_free_ struct nvme_id_ctrl *id = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *id = NULL;
 	struct nvme_ctrl *c;
 	int ret;
 
diff --git a/libnvme/src/nvme/linux.c b/libnvme/src/nvme/linux.c
index ad4834c9f1..4595a7f221 100644
--- a/libnvme/src/nvme/linux.c
+++ b/libnvme/src/nvme/linux.c
@@ -76,6 +76,7 @@ void nvme_transport_handle_set_decide_retry(struct nvme_transport_handle *hdl,
 		hdl->decide_retry = __nvme_decide_retry;
 }
 
+#ifndef _WIN32
 static int __nvme_transport_handle_open_direct(struct nvme_transport_handle *hdl, const char *devname)
 {
 	struct nvme_passthru_cmd dummy = { 0 };
@@ -124,6 +125,7 @@ void __nvme_transport_handle_close_direct(struct nvme_transport_handle *hdl)
 	close(hdl->fd);
 	free(hdl);
 }
+#endif /* !_WIN32 */
 
 struct nvme_transport_handle *__nvme_create_transport_handle(struct nvme_global_ctx *ctx)
 {
@@ -141,6 +143,7 @@ struct nvme_transport_handle *__nvme_create_transport_handle(struct nvme_global_
 	return hdl;
 }
 
+#ifndef _WIN32
 int nvme_open(struct nvme_global_ctx *ctx, const char *name,
 	      struct nvme_transport_handle **hdlp)
 {
@@ -202,6 +205,7 @@ void nvme_close(struct nvme_transport_handle *hdl)
 		break;
 	}
 }
+#endif /* !_WIN32 */
 
 nvme_fd_t nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl)
 {
@@ -233,6 +237,7 @@ bool nvme_transport_handle_is_mi(struct nvme_transport_handle *hdl)
 	return hdl->type == NVME_TRANSPORT_HANDLE_TYPE_MI;
 }
 
+#ifndef _WIN32
 int nvme_fw_download_seq(struct nvme_transport_handle *hdl, bool ish,
 		__u32 size, __u32 xfer, __u32 offset, void *buf)
 {
@@ -377,7 +382,7 @@ int nvme_get_telemetry_log(struct nvme_transport_handle *hdl, bool create, bool
 	static const __u32 xfer = NVME_LOG_TELEM_BLOCK_SIZE;
 	struct nvme_telemetry_log *telem;
 	struct nvme_passthru_cmd cmd;
-	_cleanup_free_ void *log = NULL;
+	_cleanup_nvme_free_ void *log = NULL;
 	void *tmp;
 	int err;
 	size_t dalb;
@@ -576,7 +581,7 @@ size_t nvme_get_ana_log_len_from_id_ctrl(const struct nvme_id_ctrl *id_ctrl,
 
 int nvme_get_ana_log_len(struct nvme_transport_handle *hdl, size_t *analen)
 {
-	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *ctrl = NULL;
 	struct nvme_passthru_cmd cmd;
 	int ret;
 
@@ -595,7 +600,7 @@ int nvme_get_ana_log_len(struct nvme_transport_handle *hdl, size_t *analen)
 
 int nvme_get_logical_block_size(struct nvme_transport_handle *hdl, __u32 nsid, int *blksize)
 {
-	_cleanup_free_ struct nvme_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns *ns = NULL;
 	struct nvme_passthru_cmd cmd;
 	__u8 flbas;
 	int ret;
@@ -2128,3 +2133,4 @@ int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encoded_key,
 	*keyp = psk;
 	return 0;
 }
+#endif /* !_WIN32 */
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index aacb365e24..e44f7e85f7 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -413,6 +413,8 @@ void *__nvme_alloc(size_t len);
 
 void *__nvme_realloc(void *p, size_t len);
 
+void __nvme_free(void *p);
+
 nvme_host_t nvme_lookup_host(struct nvme_global_ctx *ctx, const char *hostnqn,
 			     const char *hostid);
 nvme_subsystem_t nvme_lookup_subsystem(struct nvme_host *h,
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index 9cfc9e4273..574f5dedf9 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -56,6 +56,7 @@ struct candidate_args {
 };
 typedef bool (*ctrl_match_t)(struct nvme_ctrl *c, struct candidate_args *candidate);
 
+#ifndef _WIN32
 static void __nvme_free_host(nvme_host_t h);
 static void __nvme_free_ctrl(nvme_ctrl_t c);
 static int nvme_subsystem_scan_namespace(struct nvme_global_ctx *ctx,
@@ -323,6 +324,7 @@ int nvme_scan_topology(struct nvme_global_ctx *ctx, nvme_scan_filter_t f, void *
 
 	return 0;
 }
+#endif /* !_WIN32 */
 
 struct nvme_global_ctx *nvme_create_global_ctx(FILE *fp, int log_level)
 {
@@ -353,6 +355,7 @@ struct nvme_global_ctx *nvme_create_global_ctx(FILE *fp, int log_level)
 	return ctx;
 }
 
+#ifndef _WIN32
 int nvme_read_config(struct nvme_global_ctx *ctx, const char *config_file)
 {
 	int err;
@@ -2729,7 +2732,7 @@ static int nvme_ns_init(const char *path, struct nvme_ns *ns)
 		if (ret)
 			return ret;
 	} else {
-		_cleanup_free_ struct nvme_id_ns *id = NULL;
+		_cleanup_nvme_free_ struct nvme_id_ns *id = NULL;
 		uint8_t flbas;
 
 		id = __nvme_alloc(sizeof(*ns));
@@ -3015,3 +3018,4 @@ struct nvme_ns *nvme_subsystem_lookup_namespace(struct nvme_subsystem *s,
 	}
 	return NULL;
 }
+#endif /* !_WIN32 */
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index e2965f2851..20efd626fe 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -1153,12 +1153,17 @@ void *__nvme_realloc(void *p, size_t len)
 
 	if (p && result) {
 		memcpy(result, p, min(old_len, len));
-		free(p);
+		__nvme_free(p);
 	}
 
 	return result;
 }
 
+void __nvme_free(void *p)
+{
+	platform_aligned_free(p);
+}
+
 #ifndef _WIN32
 const struct ifaddrs *nvme_getifaddrs(struct nvme_global_ctx *ctx)
 {
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 244baffd24..718ed7ff29 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -9,6 +9,7 @@
 
 #include <errno.h>
 #include <stdio.h>
+#include <nvme/linux.h>
 #include <nvme/types.h>
 #include "private.h"
 
@@ -183,15 +184,6 @@ int nvme_scan(const char *config_file, struct nvme_global_ctx **ctx)
 	return -1;
 }
 
-struct nvme_global_ctx *nvme_create_global_ctx(FILE *fp, int log_level)
-{
-	stub_log(__func__);
-	(void)fp;
-	(void)log_level;
-	/* Return NULL - global context not supported on Windows */
-	return NULL;
-}
-
 int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name, nvme_ctrl_t *c)
 {
 	stub_log(__func__);
@@ -833,66 +825,6 @@ int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encoded_key,
 /*
  * Additional stubs for nvme-cli linking
  */
-
-/* Transport handle operations (linux.c) */
-int nvme_open(struct nvme_global_ctx *ctx, const char *name,
-	      struct nvme_transport_handle **hdlp)
-{
-	stub_log(__func__);
-	(void)ctx;
-	(void)name;
-	(void)hdlp;
-	errno = ENOTSUP;
-	return -1;
-}
-
-void nvme_close(struct nvme_transport_handle *hdl)
-{
-	stub_log(__func__);
-	(void)hdl;
-}
-
-nvme_fd_t nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl)
-{
-	// TODO: identical to linux.c, need to refactor.
-	return hdl->fd;
-}
-
-const char *nvme_transport_handle_get_name(struct nvme_transport_handle *hdl)
-{
-	stub_log(__func__);
-	(void)hdl;
-	return "";
-}
-
-bool nvme_transport_handle_is_blkdev(struct nvme_transport_handle *hdl)
-{
-	stub_log(__func__);
-	(void)hdl;
-	return false;
-}
-
-bool nvme_transport_handle_is_chardev(struct nvme_transport_handle *hdl)
-{
-	stub_log(__func__);
-	(void)hdl;
-	return false;
-}
-
-bool nvme_transport_handle_is_direct(struct nvme_transport_handle *hdl)
-{
-	stub_log(__func__);
-	(void)hdl;
-	return false;
-}
-
-bool nvme_transport_handle_is_mi(struct nvme_transport_handle *hdl)
-{
-	stub_log(__func__);
-	(void)hdl;
-	return false;
-}
-
 /* Controller property getters (tree.c) */
 const char *nvme_ctrl_get_cntlid(nvme_ctrl_t c)
 {
@@ -1032,40 +964,51 @@ const char *nvme_mi_status_to_string(int status)
  * Linux keyring and TLS key management stubs (linux.c)
  * These are used by nvme-cli security commands
  */
-int nvme_read_key(long keyring_id, long key_id, int *key_len, unsigned char **key_data)
+int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
+		long key_id, int *len, unsigned char **key)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)keyring_id;
 	(void)key_id;
-	(void)key_len;
-	(void)key_data;
+	(void)len;
+	(void)key;
 	errno = ENOTSUP;
 	return -1;
 }
 
-int nvme_lookup_keyring(const char *keyring, long *kr_id)
+int nvme_lookup_keyring(struct nvme_global_ctx *ctx,
+		const char *keyring, long *key)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)keyring;
-	(void)kr_id;
+	(void)key;
 	errno = ENOTSUP;
 	return -1;
 }
 
-int nvme_update_key(long keyring_id, long key_id, const unsigned char *key_data, int key_len)
+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)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)keyring_id;
-	(void)key_id;
+	(void)key_type;
+	(void)identity;
 	(void)key_data;
 	(void)key_len;
+	(void)key;
 	errno = ENOTSUP;
 	return -1;
 }
 
-int nvme_revoke_tls_key(const char *keyring, const char *key_type, const char *identity)
+int nvme_revoke_tls_key(struct nvme_global_ctx *ctx, const char *keyring,
+		const char *key_type, const char *identity)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)keyring;
 	(void)key_type;
 	(void)identity;
@@ -1073,27 +1016,36 @@ int nvme_revoke_tls_key(const char *keyring, const char *key_type, const char *i
 	return -1;
 }
 
-int nvme_scan_tls_keys(const char *keyring)
+int nvme_scan_tls_keys(struct nvme_global_ctx *ctx, const char *keyring,
+		nvme_scan_tls_keys_cb_t cb, void *data)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)keyring;
+	(void)cb;
+	(void)data;
 	errno = ENOTSUP;
 	return -1;
 }
 
-int nvme_describe_key_serial(long key_id)
+char *nvme_describe_key_serial(struct nvme_global_ctx *ctx,
+		long key_id)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)key_id;
-	errno = ENOTSUP;
-	return -1;
+	return NULL;
 }
 
-int nvme_insert_tls_key_versioned(const char *keyring, const char *key_type, const char *hostnqn,
-				 const char *subsysnqn, int version, int hmac,
-				 unsigned char *configured_key, int key_len)
+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,
+		unsigned char *configured_key, int key_len,
+		long *key)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)keyring;
 	(void)key_type;
 	(void)hostnqn;
@@ -1102,49 +1054,68 @@ int nvme_insert_tls_key_versioned(const char *keyring, const char *key_type, con
 	(void)hmac;
 	(void)configured_key;
 	(void)key_len;
+	(void)key;
 	errno = ENOTSUP;
 	return -1;
 }
 
-char *nvme_generate_tls_key_identity_compat(const char *hostnqn, const char *subsysnqn,
-					   int version, int hmac,
-					   unsigned char *configured_key, int key_len)
+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 **identity)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)hostnqn;
 	(void)subsysnqn;
 	(void)version;
 	(void)hmac;
 	(void)configured_key;
 	(void)key_len;
-	return NULL;
+	(void)identity;
+	errno = ENOTSUP;
+	return -1;
 }
 
-int nvme_insert_tls_key_compat(const char *keyring, const char *key_type, const char *identity,
-			       unsigned char *key_data, int key_len)
+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,
+		unsigned char *configured_key, int key_len,
+		long *key)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)keyring;
 	(void)key_type;
-	(void)identity;
-	(void)key_data;
+	(void)hostnqn;
+	(void)subsysnqn;
+	(void)version;
+	(void)hmac;
+	(void)configured_key;
 	(void)key_len;
+	(void)key;
 	errno = ENOTSUP;
 	return -1;
 }
 
-char *nvme_generate_tls_key_identity(const char *hostnqn, const char *subsysnqn,
-				    int version, int hmac,
-				    unsigned char *configured_key, int key_len)
+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,
+		char **identity)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)hostnqn;
 	(void)subsysnqn;
 	(void)version;
 	(void)hmac;
 	(void)configured_key;
 	(void)key_len;
-	return NULL;
+	(void)identity;
+	errno = ENOTSUP;
+	return -1;
 }
 
 char *nvmf_hostnqn_from_file(void)
@@ -1154,10 +1125,13 @@ char *nvmf_hostnqn_from_file(void)
 	return NULL;
 }
 
-int nvme_gen_dhchap_key(char *hostnqn, unsigned int hmac, unsigned int key_len,
-		       unsigned char *secret, unsigned char *key)
+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)
 {
 	stub_log(__func__);
+	(void)ctx;
 	(void)hostnqn;
 	(void)hmac;
 	(void)key_len;
@@ -1182,16 +1156,8 @@ char *nvmf_hostnqn_generate_from_hostid(char *hostid)
 	return NULL;
 }
 
-/* Dry run and other global state functions (linux.c) */
-void nvme_set_dry_run(void *ctx, int enable)
-{
-	stub_log(__func__);
-	(void)ctx;
-	(void)enable;
-}
-
 /* Extended Telemetry (linux.c) */
-int nvme_set_etdas(void *hdl, int *changed)
+int nvme_set_etdas(struct nvme_transport_handle *hdl, bool *changed)
 {
 	stub_log(__func__);
 	(void)hdl;
@@ -1200,7 +1166,7 @@ int nvme_set_etdas(void *hdl, int *changed)
 	return -1;
 }
 
-int nvme_clear_etdas(void *hdl, int *changed)
+int nvme_clear_etdas(struct nvme_transport_handle *hdl, bool *changed)
 {
 	stub_log(__func__);
 	(void)hdl;
@@ -1209,28 +1175,6 @@ int nvme_clear_etdas(void *hdl, int *changed)
 	return -1;
 }
 
-/* Transport handle callbacks (linux.c) */
-void nvme_transport_handle_set_submit_entry(void *hdl, void *fn)
-{
-	stub_log(__func__);
-	(void)hdl;
-	(void)fn;
-}
-
-void nvme_transport_handle_set_submit_exit(void *hdl, void *fn)
-{
-	stub_log(__func__);
-	(void)hdl;
-	(void)fn;
-}
-
-void nvme_transport_handle_set_decide_retry(void *hdl, void *fn)
-{
-	stub_log(__func__);
-	(void)hdl;
-	(void)fn;
-}
-
 /* Path property getters (tree.c) */
 const char *nvme_path_get_numa_nodes(struct nvme_path *p)
 {
@@ -1328,64 +1272,3 @@ void nvmf_nbft_free(struct nvme_global_ctx *ctx, struct nbft_file_entry *head)
 	(void)ctx;
 	(void)head;
 }
-
-/* Platform-specific fstat wrapper for nvme_fd_t */
-int nvme_fstat(nvme_fd_t fd, struct stat *buf)
-{
-	BY_HANDLE_FILE_INFORMATION file_info;
-	ULARGE_INTEGER ull;
-
-	if (!buf) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	/* Check for invalid handle */
-	if (fd == INVALID_HANDLE_VALUE || fd == NULL) {
-		errno = EBADF;
-		return -1;
-	}
-
-	/* Get file information from Windows handle */
-	if (!GetFileInformationByHandle(fd, &file_info)) {
-		errno = EBADF;
-		return -1;
-	}
-
-	/* Fill in the stat structure */
-	memset(buf, 0, sizeof(*buf));
-
-	/* Convert Windows file attributes to stat mode */
-	if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DEVICE)
-		/* Windows device files should be marked as block devices */
-		/* This is used by nvme_verify_chr to check device type */
-		buf->st_mode = S_IFBLK | 0600;
-	else if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
-		buf->st_mode = S_IFDIR | 0755;
-	else
-		buf->st_mode = S_IFREG | 0644;
-
-	/* File size */
-	buf->st_size = (((off_t)file_info.nFileSizeHigh << 32)
-					| file_info.nFileSizeLow);
-
-	/* Number of hard links */
-	buf->st_nlink = file_info.nNumberOfLinks;
-
-	/* Convert FILETIME to time_t for timestamps */
-	/* Windows FILETIME is 100-nanosecond intervals since Jan 1, 1601 */
-	/* Unix time_t is seconds since Jan 1, 1970 */
-	ull.LowPart = file_info.ftLastWriteTime.dwLowDateTime;
-	ull.HighPart = file_info.ftLastWriteTime.dwHighDateTime;
-	buf->st_mtime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
-
-	ull.LowPart = file_info.ftLastAccessTime.dwLowDateTime;
-	ull.HighPart = file_info.ftLastAccessTime.dwHighDateTime;
-	buf->st_atime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
-
-	ull.LowPart = file_info.ftCreationTime.dwLowDateTime;
-	ull.HighPart = file_info.ftCreationTime.dwHighDateTime;
-	buf->st_ctime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
-
-	return 0;
-}
\ No newline at end of file
diff --git a/libnvme/src/nvme/windows.c b/libnvme/src/nvme/windows.c
new file mode 100644
index 0000000000..9967aad431
--- /dev/null
+++ b/libnvme/src/nvme/windows.c
@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2025 Micron Technology, Inc.
+ *
+ * Authors: Brandon Capener <bcapener@micron.com>
+ */
+
+#include "private.h"
+#include "nvme/linux.h"
+
+
+static int __nvme_transport_handle_open_direct(struct nvme_transport_handle *hdl, const char *name)
+{
+	char device_path[MAX_PATH];
+	HANDLE h;
+
+	/* Parse and open direct device */
+	hdl->type = NVME_TRANSPORT_HANDLE_TYPE_DIRECT;
+
+	/* Convert device name to Windows path */
+	if (strncmp(name, "\\\\.\\", 4) == 0) {
+		/* Already a Windows device path */
+		snprintf(device_path, sizeof(device_path), "%s", name);
+	} else {
+		/* Assume it's a device name, prepend Windows device prefix */
+		/* PhysicalDriveN format */
+		snprintf(device_path, sizeof(device_path), "\\\\.\\%s", name);
+	}
+
+	h = CreateFile(device_path,
+		GENERIC_READ,
+		FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+		NULL,
+		OPEN_EXISTING,
+		0,
+		NULL);
+
+	if (h == INVALID_HANDLE_VALUE) {
+		int err = GetLastError();
+		/* Map Windows error to errno */
+		switch (err) {
+		case ERROR_FILE_NOT_FOUND:
+		case ERROR_PATH_NOT_FOUND:
+			return -ENOENT;
+		case ERROR_ACCESS_DENIED:
+			return -EACCES;
+		default:
+			return -EIO;
+		}
+	}
+
+	hdl->fd = h;
+
+	nvme_fstat(hdl->fd, &hdl->stat);
+
+	/* Windows doesn't distinguish 32/64-bit ioctl, assume 64-bit capable */
+	hdl->ioctl64 = true;
+
+	return 0;
+}
+
+/* Transport handle operations (linux.c) */
+int nvme_open(struct nvme_global_ctx *ctx, const char *name,
+	      struct nvme_transport_handle **hdlp)
+{
+	struct nvme_transport_handle *hdl;
+	int ret;
+
+	hdl = __nvme_create_transport_handle(ctx);
+	if (!hdl)
+		return -ENOMEM;
+
+	hdl->name = strdup(name);
+	if (!hdl->name) {
+		free(hdl);
+		return -ENOMEM;
+	}
+
+	/* Handle test devices */
+	if (!strncmp(name, "NVME_TEST_FD", 12)) {
+		hdl->type = NVME_TRANSPORT_HANDLE_TYPE_DIRECT;
+		hdl->fd = TEST_FD;
+
+		if (!strcmp(name, "NVME_TEST_FD64"))
+			hdl->ioctl64 = true;
+
+		*hdlp = hdl;
+		return 0;
+	}
+
+	/* MI transport not supported on Windows */
+	if (!strncmp(name, "mctp:", strlen("mctp:"))) {
+		nvme_close(hdl);
+		return -ENOTSUP;
+	} else {
+		ret = __nvme_transport_handle_open_direct(hdl, name);
+	}
+
+	if (ret) {
+		nvme_close(hdl);
+		return ret;
+	}
+
+	*hdlp = hdl;
+
+	return 0;
+}
+
+void nvme_close(struct nvme_transport_handle *hdl)
+{
+	if (!hdl)
+		return;
+
+	free(hdl->name);
+
+	switch (hdl->type) {
+	case NVME_TRANSPORT_HANDLE_TYPE_DIRECT:
+		/* Close Windows HANDLE if valid */
+		if (hdl->fd && hdl->fd != TEST_FD)
+			CloseHandle(hdl->fd);
+		free(hdl);
+		break;
+	case NVME_TRANSPORT_HANDLE_TYPE_MI:
+		/* MI not supported on Windows */
+		free(hdl);
+		break;
+	case NVME_TRANSPORT_HANDLE_TYPE_UNKNOWN:
+		free(hdl);
+		break;
+	}
+}
+
+/* Platform-specific fstat wrapper for nvme_fd_t */
+int nvme_fstat(nvme_fd_t fd, struct stat *buf)
+{
+	BY_HANDLE_FILE_INFORMATION file_info;
+	ULARGE_INTEGER ull;
+
+	if (!buf) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	/* Check for invalid handle */
+	if (fd == INVALID_HANDLE_VALUE || fd == NULL) {
+		errno = EBADF;
+		return -1;
+	}
+
+	/* Get file information from Windows handle */
+	if (!GetFileInformationByHandle(fd, &file_info)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	/* Fill in the stat structure */
+	memset(buf, 0, sizeof(*buf));
+
+	/* Convert Windows file attributes to stat mode */
+	if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DEVICE)
+		/* Windows device files should be marked as block devices */
+		/* This is used by nvme_verify_chr to check device type */
+		buf->st_mode = S_IFBLK | 0600;
+	else if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+		buf->st_mode = S_IFDIR | 0755;
+	else
+		buf->st_mode = S_IFREG | 0644;
+
+	/* File size */
+	buf->st_size = (((off_t)file_info.nFileSizeHigh << 32)
+					| file_info.nFileSizeLow);
+
+	/* Number of hard links */
+	buf->st_nlink = file_info.nNumberOfLinks;
+
+	/* Convert FILETIME to time_t for timestamps */
+	/* Windows FILETIME is 100-nanosecond intervals since Jan 1, 1601 */
+	/* Unix time_t is seconds since Jan 1, 1970 */
+	ull.LowPart = file_info.ftLastWriteTime.dwLowDateTime;
+	ull.HighPart = file_info.ftLastWriteTime.dwHighDateTime;
+	buf->st_mtime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
+
+	ull.LowPart = file_info.ftLastAccessTime.dwLowDateTime;
+	ull.HighPart = file_info.ftLastAccessTime.dwHighDateTime;
+	buf->st_atime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
+
+	ull.LowPart = file_info.ftCreationTime.dwLowDateTime;
+	ull.HighPart = file_info.ftCreationTime.dwHighDateTime;
+	buf->st_ctime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
+
+	return 0;
+}
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index d72fa48595..4c3f91f1e1 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -18,6 +18,7 @@
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <sys/mman.h>
 #include <sys/param.h>
 #include <sys/time.h>
 #include <sys/uio.h>
@@ -69,4 +70,13 @@ static inline int random_uuid(unsigned char *uuid, size_t len)
 	return ret;
 }
 
+/*
+ * Platform-specific free for aligned memory allocations.
+ * Use when posix_memalign is used to allocate memory.
+ */
+static inline void platform_aligned_free(void *p)
+{
+	free(p);
+}
+
 #endif /* _LIBNVME_PLATFORM_LINUX_H */
\ No newline at end of file
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 96e04f08d5..a64d2a4246 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -28,6 +28,7 @@
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <time.h>
+#include <libgen.h>
 
 /* Prevent conflicts with Windows min/max macros */
 #ifdef min
@@ -187,7 +188,8 @@ struct ifaddrs {
 #define ipv4_from_in6_addr(addr) &(addr.u.Byte[12])
 
 /* Windows missing POSIX functions */
-static inline int dprintf(int fd, const char *format, ...) {
+static inline int dprintf(int fd, const char *format, ...)
+{
     va_list args;
     char buffer[4096];
     int result;
@@ -202,21 +204,34 @@ static inline int dprintf(int fd, const char *format, ...) {
     return result;
 }
 
-static inline int getpagesize(void) {
+static inline DWORD getpagesize(void)
+{
     SYSTEM_INFO si;
     GetSystemInfo(&si);
     return si.dwPageSize;
 }
 
-static inline int posix_memalign(void **memptr, size_t alignment, size_t size) {
+/* Aligned memory allocation function, use platform_aligned_free to free. */
+static inline int posix_memalign(void **memptr, size_t alignment, size_t size)
+{
     *memptr = _aligned_malloc(size, alignment);
     return (*memptr == NULL) ? ENOMEM : 0;
 }
 
-static inline size_t malloc_usable_size(void *ptr) {
+static inline size_t malloc_usable_size(void *ptr)
+{
     return _msize(ptr);
 }
 
+/*
+ * Platform-specific free for aligned memory allocations.
+ * Use when posix_memalign is used to allocate memory.
+ */
+static inline void platform_aligned_free(void *p)
+{
+	_aligned_free(p);
+}
+
 /* Windows ioctl macros - only define if not already defined by winsock */
 #ifndef _IOC_NONE
 #define _IOC_NONE  0U
diff --git a/nvme-rpmb.c b/nvme-rpmb.c
index 963ebc7f2f..274182e13d 100644
--- a/nvme-rpmb.c
+++ b/nvme-rpmb.c
@@ -190,7 +190,7 @@ static int read_file(const char *file, unsigned char **data, unsigned int *len)
 		err = -errno;
 		fprintf(stderr, "Failed to read data from file"
 				" %s with %s\n", file, nvme_strerror(errno));
-		free(buf);
+		platform_aligned_free(buf);
 		goto out;
 	}
 	*data = buf; 
diff --git a/nvme.c b/nvme.c
index da46a39efa..a19f0eb5e6 100644
--- a/nvme.c
+++ b/nvme.c
@@ -518,7 +518,7 @@ static int get_smart_log(int argc, char **argv, struct command *acmd, struct plu
 		"(or optionally a namespace) in either decoded format "
 		"(default) or binary.";
 
-	_cleanup_free_ struct nvme_smart_log *smart_log = NULL;
+	_cleanup_nvme_free_ struct nvme_smart_log *smart_log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	const char *namespace = "(optional) desired namespace";
@@ -583,8 +583,8 @@ static int get_ana_log(int argc, char **argv, struct command *acmd,
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
-	_cleanup_free_ struct nvme_ana_log *ana_log = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *ctrl = NULL;
+	_cleanup_nvme_free_ struct nvme_ana_log *ana_log = NULL;
 	size_t max_ana_log_len;
 	__u32 ana_log_len;
 	nvme_print_flags_t flags;
@@ -707,7 +707,7 @@ static int get_log_telemetry_ctrl(struct nvme_transport_handle *hdl, bool rae, s
 
 	err = nvme_get_log_telemetry_ctrl(hdl, rae, 0, log, size);
 	if (err) {
-		free(log);
+		nvme_free(log);
 		return err;
 	}
 
@@ -727,7 +727,7 @@ static int get_log_telemetry_host(struct nvme_transport_handle *hdl, size_t size
 
 	err = nvme_get_log_telemetry_host(hdl, 0, log, size);
 	if (err) {
-		free(log);
+		nvme_free(log);
 		return err;
 	}
 
@@ -741,7 +741,7 @@ static int __create_telemetry_log_host(struct nvme_transport_handle *hdl,
 				       struct nvme_telemetry_log **buf,
 				       bool da4_support)
 {
-	_cleanup_free_ struct nvme_telemetry_log *log = NULL;
+	_cleanup_nvme_free_ struct nvme_telemetry_log *log = NULL;
 	int err;
 
 	log = nvme_alloc(sizeof(*log));
@@ -803,7 +803,7 @@ static int __get_telemetry_log_ctrl(struct nvme_transport_handle *hdl,
 	return get_log_telemetry_ctrl(hdl, rae, *size, buf);
 
 free:
-	free(log);
+	nvme_free(log);
 	return err;
 }
 
@@ -813,7 +813,7 @@ static int __get_telemetry_log_host(struct nvme_transport_handle *hdl,
 				    struct nvme_telemetry_log **buf,
 				    bool da4_support)
 {
-	_cleanup_free_ struct nvme_telemetry_log *log = NULL;
+	_cleanup_nvme_free_ struct nvme_telemetry_log *log = NULL;
 	int err;
 
 	log = nvme_alloc(sizeof(*log));
@@ -843,8 +843,8 @@ static int get_telemetry_log(int argc, char **argv, struct command *acmd,
 	const char *mcda = "Host-init Maximum Created Data Area. Valid options are 0 ~ 4 "
 		"If given, This option will override dgen. 0 : controller determines data area";
 
-	_cleanup_free_ struct nvme_telemetry_log *log = NULL;
-	_cleanup_free_ struct nvme_id_ctrl *id_ctrl = NULL;
+	_cleanup_nvme_free_ struct nvme_telemetry_log *log = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *id_ctrl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_fd_ int output = -1;
@@ -1007,7 +1007,7 @@ static int get_endurance_log(int argc, char **argv, struct command *acmd, struct
 	const char *desc = "Retrieves endurance groups log page and prints the log.";
 	const char *group_id = "The endurance group identifier";
 
-	_cleanup_free_ struct nvme_endurance_group_log *endurance_log = NULL;
+	_cleanup_nvme_free_ struct nvme_endurance_group_log *endurance_log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -1065,7 +1065,7 @@ static int collect_effects_log(struct nvme_transport_handle *hdl, enum nvme_csi
 
 	err = nvme_get_log_cmd_effects(hdl, csi, &node->effects);
 	if (err) {
-		free(node);
+		nvme_free(node);
 		return err;
 	}
 	list_add(list, &node->node);
@@ -1172,7 +1172,7 @@ static int get_supported_log_pages(int argc, char **argv, struct command *acmd,
 {
 	const char *desc = "Retrieve supported logs and print the table.";
 
-	_cleanup_free_ struct nvme_supported_log_pages *supports = NULL;
+	_cleanup_nvme_free_ struct nvme_supported_log_pages *supports = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -1217,7 +1217,7 @@ static int get_error_log(int argc, char **argv, struct command *acmd, struct plu
 	const char *log_entries = "number of entries to retrieve";
 	const char *raw = "dump in binary format";
 
-	_cleanup_free_ struct nvme_error_log_page *err_log = NULL;
+	_cleanup_nvme_free_ struct nvme_error_log_page *err_log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_id_ctrl ctrl = { 0 };
@@ -1287,7 +1287,7 @@ static int get_fw_log(int argc, char **argv, struct command *acmd, struct plugin
 	const char *desc = "Retrieve the firmware log for the "
 		"specified device in either decoded format (default) or binary.";
 
-	_cleanup_free_ struct nvme_firmware_slot *fw_log = NULL;
+	_cleanup_nvme_free_ struct nvme_firmware_slot *fw_log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -1335,7 +1335,7 @@ static int get_fw_log(int argc, char **argv, struct command *acmd, struct plugin
 static int get_changed_ns_list_log(int argc, char **argv, bool alloc)
 {
 	_cleanup_free_ char *desc = NULL;
-	_cleanup_free_ struct nvme_ns_list *changed_ns_list_log = NULL;
+	_cleanup_nvme_free_ struct nvme_ns_list *changed_ns_list_log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -1413,7 +1413,7 @@ static int get_pred_lat_per_nvmset_log(int argc, char **argv,
 		"format(default),json or binary.";
 	const char *nvmset_id = "NVM Set Identifier";
 
-	_cleanup_free_ struct nvme_nvmset_predictable_lat_log *plpns_log = NULL;
+	_cleanup_nvme_free_ struct nvme_nvmset_predictable_lat_log *plpns_log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -1473,8 +1473,8 @@ static int get_pred_lat_event_agg_log(int argc, char **argv,
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
-	_cleanup_free_ void *pea_log = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *ctrl = NULL;
+	_cleanup_nvme_free_ void *pea_log = NULL;
 	nvme_print_flags_t flags;
 	__u32 log_size;
 	int err;
@@ -1554,7 +1554,7 @@ static int get_persistent_event_log(int argc, char **argv,
 		"processing this persistent log page command.";
 	const char *log_len = "number of bytes to retrieve";
 
-	_cleanup_free_ struct nvme_persistent_event_log *pevent = NULL;
+	_cleanup_nvme_free_ struct nvme_persistent_event_log *pevent = NULL;
 	struct nvme_persistent_event_log *pevent_collected = NULL;
 	_cleanup_huge_ struct nvme_mem_huge mh = { 0, };
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
@@ -1669,8 +1669,8 @@ static int get_endurance_event_agg_log(int argc, char **argv,
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
-	_cleanup_free_ void *endurance_log = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *ctrl = NULL;
+	_cleanup_nvme_free_ void *endurance_log = NULL;
 	nvme_print_flags_t flags;
 	__u32 log_size;
 	int err;
@@ -1752,7 +1752,7 @@ static int get_lba_status_log(int argc, char **argv,
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ void *lba_status = NULL;
+	_cleanup_nvme_free_ void *lba_status = NULL;
 	nvme_print_flags_t flags;
 	__u32 lslplen;
 	int err;
@@ -1808,7 +1808,7 @@ static int get_resv_notif_log(int argc, char **argv,
 		"log page and prints it, for the given "
 		"device in either decoded format(default), json or binary.";
 
-	_cleanup_free_ struct nvme_resv_notification_log *resv = NULL;
+	_cleanup_nvme_free_ struct nvme_resv_notification_log *resv = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -1852,8 +1852,8 @@ static int get_boot_part_log(int argc, char **argv, struct command *acmd, struct
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ struct nvme_boot_partition *boot = NULL;
-	_cleanup_free_ __u8 *bp_log = NULL;
+	_cleanup_nvme_free_ struct nvme_boot_partition *boot = NULL;
+	_cleanup_nvme_free_ __u8 *bp_log = NULL;
 	nvme_print_flags_t flags;
 	int err = -1;
 	_cleanup_fd_ int output = -1;
@@ -1941,7 +1941,7 @@ static int get_phy_rx_eom_log(int argc, char **argv, struct command *acmd,
 		"Measurement log for the given device in decoded format "
 		"(default), json or binary.";
 	const char *controller = "Target Controller ID.";
-	_cleanup_free_ struct nvme_phy_rx_eom_log *phy_rx_eom_log = NULL;
+	_cleanup_nvme_free_ struct nvme_phy_rx_eom_log *phy_rx_eom_log = NULL;
 	size_t phy_rx_eom_log_len;
 	nvme_print_flags_t flags;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
@@ -2028,7 +2028,7 @@ static int get_media_unit_stat_log(int argc, char **argv, struct command *acmd,
 {
 	const char *desc = "Retrieve the configuration and wear of media units and print it";
 
-	_cleanup_free_ struct nvme_media_unit_stat_log *mus = NULL;
+	_cleanup_nvme_free_ struct nvme_media_unit_stat_log *mus = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -2081,7 +2081,7 @@ static int get_supp_cap_config_log(int argc, char **argv, struct command *acmd,
 {
 	const char *desc = "Retrieve the list of Supported Capacity Configuration Descriptors";
 
-	_cleanup_free_ struct nvme_supported_cap_config_list_log *cap_log = NULL;
+	_cleanup_nvme_free_ struct nvme_supported_cap_config_list_log *cap_log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -2138,7 +2138,7 @@ static int io_mgmt_send(int argc, char **argv, struct command *acmd, struct plug
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_fd_ int dfd = STDIN_FILENO;
-	_cleanup_free_ void *buf = NULL;
+	_cleanup_nvme_free_ void *buf = NULL;
 	struct nvme_passthru_cmd cmd;
 	int err = -1;
 
@@ -2213,7 +2213,7 @@ static int io_mgmt_recv(int argc, char **argv, struct command *acmd, struct plug
 
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
-	_cleanup_free_ void *buf = NULL;
+	_cleanup_nvme_free_ void *buf = NULL;
 	struct nvme_passthru_cmd cmd;
 	_cleanup_fd_ int dfd = -1;
 	int err = -1;
@@ -2301,7 +2301,7 @@ static int get_log(int argc, char **argv, struct command *acmd, struct plugin *p
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ unsigned char *log = NULL;
+	_cleanup_nvme_free_ unsigned char *log = NULL;
 	struct nvme_passthru_cmd cmd;
 	int err;
 	nvme_print_flags_t flags;
@@ -2503,7 +2503,7 @@ static int sanitize_log(int argc, char **argv, struct command *acmd, struct plug
 {
 	const char *desc = "Retrieve sanitize log and show it.";
 
-	_cleanup_free_ struct nvme_sanitize_log_page *sanitize_log = NULL;
+	_cleanup_nvme_free_ struct nvme_sanitize_log_page *sanitize_log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -2563,7 +2563,7 @@ static int get_fid_support_effects_log(int argc, char **argv, struct command *ac
 {
 	const char *desc = "Retrieve FID Support and Effects log and show it.";
 
-	_cleanup_free_ struct nvme_fid_supported_effects_log *fid_support_log = NULL;
+	_cleanup_nvme_free_ struct nvme_fid_supported_effects_log *fid_support_log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -2615,7 +2615,7 @@ static int get_mi_cmd_support_effects_log(int argc, char **argv, struct command
 {
 	const char *desc = "Retrieve NVMe-MI Command Support and Effects log and show it.";
 
-	_cleanup_free_ struct nvme_mi_cmd_supported_effects_log *mi_cmd_support_log = NULL;
+	_cleanup_nvme_free_ struct nvme_mi_cmd_supported_effects_log *mi_cmd_support_log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -2667,7 +2667,7 @@ static int list_ctrl(int argc, char **argv, struct command *acmd, struct plugin
 		"given device is part of, or optionally controllers attached to a specific namespace.";
 	const char *controller = "controller to display";
 
-	_cleanup_free_ struct nvme_ctrl_list *cntlist = NULL;
+	_cleanup_nvme_free_ struct nvme_ctrl_list *cntlist = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -2727,7 +2727,7 @@ static int list_ns(int argc, char **argv, struct command *acmd, struct plugin *p
 	const char *csi = "I/O command set identifier";
 	const char *all = "show all namespaces in the subsystem, whether attached or inactive";
 
-	_cleanup_free_ struct nvme_ns_list *ns_list = NULL;
+	_cleanup_nvme_free_ struct nvme_ns_list *ns_list = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	enum nvme_identify_cns cns;
@@ -2802,7 +2802,7 @@ static int id_ns_lba_format(int argc, char **argv, struct command *acmd, struct
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ struct nvme_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns *ns = NULL;
 	nvme_print_flags_t flags;
 	int err = -1;
 
@@ -2857,7 +2857,7 @@ static int id_endurance_grp_list(int argc, char **argv, struct command *acmd,
 	const char *desc = "Show endurance group list information for the given endurance group id";
 	const char *endurance_grp_id = "Endurance Group ID";
 
-	_cleanup_free_ struct nvme_id_endurance_group_list *endgrp_list = NULL;
+	_cleanup_nvme_free_ struct nvme_id_endurance_group_list *endgrp_list = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -2906,7 +2906,7 @@ static bool is_ns_mgmt_support(struct nvme_transport_handle *hdl)
 {
 	int err;
 
-	_cleanup_free_ struct nvme_id_ctrl *ctrl = nvme_alloc(sizeof(*ctrl));
+	_cleanup_nvme_free_ struct nvme_id_ctrl *ctrl = nvme_alloc(sizeof(*ctrl));
 
 	if (ctrl)
 		return false;
@@ -3005,7 +3005,7 @@ static int nvme_attach_ns(int argc, char **argv, int attach, const char *desc, s
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 
-	_cleanup_free_ struct nvme_ctrl_list *cntlist = NULL;
+	_cleanup_nvme_free_ struct nvme_ctrl_list *cntlist = NULL;
 	__u16 list[NVME_ID_CTRL_LIST_MAX];
 	struct nvme_passthru_cmd cmd;
 	nvme_print_flags_t flags;
@@ -3118,9 +3118,9 @@ static int detach_ns(int argc, char **argv, struct command *acmd, struct plugin
 static int parse_lba_num_si(struct nvme_transport_handle *hdl, const char *opt,
 			    const char *val, __u8 flbas, __u64 *num, __u64 align)
 {
-	_cleanup_free_ struct nvme_ns_list *ns_list = NULL;
-	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
-	_cleanup_free_ struct nvme_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_ns_list *ns_list = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *ctrl = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns *ns = NULL;
 	__u32 nsid = 1;
 	__u8 lbaf;
 	unsigned int remainder;
@@ -3224,11 +3224,11 @@ static int create_ns(int argc, char **argv, struct command *acmd, struct plugin
 	const char *phndls = "Comma separated list of Placement Handle Associated RUH";
 
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ struct nvme_ns_mgmt_host_sw_specified *data = NULL;
-	_cleanup_free_ struct nvme_id_ns_granularity_list *gr_list = NULL;
+	_cleanup_nvme_free_ struct nvme_ns_mgmt_host_sw_specified *data = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns_granularity_list *gr_list = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
-	_cleanup_free_ struct nvme_id_ctrl *id = NULL;
-	_cleanup_free_ struct nvme_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *id = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns *ns = NULL;
 	__u64 align_nsze = 1 << 20; /* Default 1 MiB */
 	__u64 align_ncap = align_nsze;
 	struct nvme_passthru_cmd cmd;
@@ -3596,7 +3596,7 @@ int __id_ctrl(int argc, char **argv, struct command *acmd, struct plugin *plugin
 		"controller attributes in hex-dump if requested.";
 	const char *vendor_specific = "dump binary vendor field";
 
-	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *ctrl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -3665,7 +3665,7 @@ static int nvm_id_ctrl(int argc, char **argv, struct command *acmd,
 		"command to the given device and report information about "
 		"the specified controller in various formats.";
 
-	_cleanup_free_ struct nvme_id_ctrl_nvm *ctrl_nvm = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl_nvm *ctrl_nvm = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -3710,8 +3710,8 @@ static int nvm_id_ns(int argc, char **argv, struct command *acmd,
 		"command to the given device and report information about "
 		"the specified namespace in various formats.";
 
-	_cleanup_free_ struct nvme_nvm_id_ns *id_ns = NULL;
-	_cleanup_free_ struct nvme_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_nvm_id_ns *id_ns = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns *ns = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -3784,8 +3784,8 @@ static int nvm_id_ns_lba_format(int argc, char **argv, struct command *acmd, str
 		"command to the given device, returns capability field properties of "
 		"the specified LBA Format index in the specified namespace in various formats.";
 
-	_cleanup_free_ struct nvme_nvm_id_ns *nvm_ns = NULL;
-	_cleanup_free_ struct nvme_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_nvm_id_ns *nvm_ns = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns *ns = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -3855,7 +3855,7 @@ static int ns_descs(int argc, char **argv, struct command *acmd, struct plugin *
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ void *nsdescs = NULL;
+	_cleanup_nvme_free_ void *nsdescs = NULL;
 	nvme_print_flags_t flags;
 	int err;
 
@@ -3923,7 +3923,7 @@ static int id_ns(int argc, char **argv, struct command *acmd, struct plugin *plu
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ struct nvme_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns *ns = NULL;
 	struct nvme_passthru_cmd cmd;
 	nvme_print_flags_t flags;
 	int err;
@@ -4006,7 +4006,7 @@ static int cmd_set_independent_id_ns(int argc, char **argv, struct command *acmd
 		"Namespace command to the given device, returns properties of the "
 		"specified namespace in human-readable or binary or json format.";
 
-	_cleanup_free_ struct nvme_id_independent_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_id_independent_id_ns *ns = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -4078,7 +4078,7 @@ static int id_ns_granularity(int argc, char **argv, struct command *acmd, struct
 		"given device, returns namespace granularity list "
 		"in either human-readable or binary format.";
 
-	_cleanup_free_ struct nvme_id_ns_granularity_list *granularity_list = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns_granularity_list *granularity_list = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -4119,7 +4119,7 @@ static int id_nvmset(int argc, char **argv, struct command *acmd, struct plugin
 		"in either binary format or json format";
 	const char *nvmset_id = "NVM Set Identify value";
 
-	_cleanup_free_ struct nvme_id_nvmset_list *nvmset = NULL;
+	_cleanup_nvme_free_ struct nvme_id_nvmset_list *nvmset = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -4172,7 +4172,7 @@ static int id_uuid(int argc, char **argv, struct command *acmd, struct plugin *p
 	const char *raw = "show uuid in binary format";
 	const char *human_readable = "show uuid in readable format";
 
-	_cleanup_free_ struct nvme_id_uuid_list *uuid_list = NULL;
+	_cleanup_nvme_free_ struct nvme_id_uuid_list *uuid_list = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -4230,7 +4230,7 @@ static int id_iocs(int argc, char **argv, struct command *acmd, struct plugin *p
 		"in either human-readable or binary format.";
 	const char *controller_id = "identifier of desired controller";
 
-	_cleanup_free_ struct nvme_id_iocs *iocs = NULL;
+	_cleanup_nvme_free_ struct nvme_id_iocs *iocs = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -4285,7 +4285,7 @@ static int id_domain(int argc, char **argv, struct command *acmd, struct plugin
 		"in either normal|json|binary format.";
 	const char *domain_id = "identifier of desired domain";
 
-	_cleanup_free_ struct nvme_id_domain_list *id_domain = NULL;
+	_cleanup_nvme_free_ struct nvme_id_domain_list *id_domain = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -4431,7 +4431,7 @@ static int primary_ctrl_caps(int argc, char **argv, struct command *acmd, struct
 		"command to the given device and report the information in a "
 		"decoded format (default), json or binary.";
 
-	_cleanup_free_ struct nvme_primary_ctrl_cap *caps = NULL;
+	_cleanup_nvme_free_ struct nvme_primary_ctrl_cap *caps = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -4489,7 +4489,7 @@ static int list_secondary_ctrl(int argc, char **argv, struct command *acmd, stru
 	const char *controller = "lowest controller identifier to display";
 	const char *num_entries = "number of entries to retrieve";
 
-	_cleanup_free_ struct nvme_secondary_ctrl_list *sc_list = NULL;
+	_cleanup_nvme_free_ struct nvme_secondary_ctrl_list *sc_list = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -4558,8 +4558,8 @@ static int sleep_self_test(unsigned int seconds)
 static int wait_self_test(struct nvme_transport_handle *hdl)
 {
 	static const char spin[] = {'-', '\\', '|', '/' };
-	_cleanup_free_ struct nvme_self_test_log *log = NULL;
-	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
+	_cleanup_nvme_free_ struct nvme_self_test_log *log = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *ctrl = NULL;
 	int err, i = 0, p = 0, cnt = 0;
 	int wthr;
 
@@ -4694,7 +4694,7 @@ static int device_self_test(int argc, char **argv, struct command *acmd, struct
 	}
 
 	if (cfg.stc == NVME_ST_CODE_RESERVED) {
-		_cleanup_free_ struct nvme_self_test_log *log = NULL;
+		_cleanup_nvme_free_ struct nvme_self_test_log *log = NULL;
 
 		log = nvme_alloc(sizeof(*log));
 		if (!log)
@@ -4757,7 +4757,7 @@ static int self_test_log(int argc, char **argv, struct command *acmd, struct plu
 	const char *dst_entries = "Indicate how many DST log entries to be retrieved, "
 		"by default all the 20 entries will be retrieved";
 
-	_cleanup_free_ struct nvme_self_test_log *log = NULL;
+	_cleanup_nvme_free_ struct nvme_self_test_log *log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	nvme_print_flags_t flags;
@@ -4877,8 +4877,8 @@ static bool is_get_feature_result_set(enum nvme_features_id feature_id)
 static int get_feature_id_changed(struct nvme_transport_handle *hdl, struct feat_cfg cfg,
 		nvme_print_flags_t flags)
 {
-	_cleanup_free_ void *buf_def = NULL;
-	_cleanup_free_ void *buf = NULL;
+	_cleanup_nvme_free_ void *buf_def = NULL;
+	_cleanup_nvme_free_ void *buf = NULL;
 	__u64 result_def = 0;
 	__u64 result;
 	int err_def = 0;
@@ -5269,7 +5269,7 @@ static char *nvme_fw_status_reset_type(__u16 status)
 
 static bool fw_commit_support_mud(struct nvme_transport_handle *hdl)
 {
-	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *ctrl = NULL;
 	int err;
 
 	ctrl = nvme_alloc(sizeof(*ctrl));
@@ -6604,8 +6604,8 @@ static int format_cmd(int argc, char **argv, struct command *acmd, struct plugin
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
-	_cleanup_free_ struct nvme_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *ctrl = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns *ns = NULL;
 	nvme_print_flags_t flags = NORMAL;
 	struct nvme_passthru_cmd cmd;
 	__u32 timeout_ms = 600000;
@@ -6874,7 +6874,7 @@ static int set_feature(int argc, char **argv, struct command *acmd, struct plugi
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ void *buf = NULL;
+	_cleanup_nvme_free_ void *buf = NULL;
 	_cleanup_fd_ int ffd = STDIN_FILENO;
 	int err;
 	__u64 result;
@@ -7019,7 +7019,7 @@ static int sec_send(int argc, char **argv, struct command *acmd, struct plugin *
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_passthru_cmd cmd;
-	_cleanup_free_ void *sec_buf = NULL;
+	_cleanup_nvme_free_ void *sec_buf = NULL;
 	_cleanup_fd_ int sec_fd = -1;
 	unsigned int sec_size;
 	int err;
@@ -7130,7 +7130,7 @@ static int dir_send(int argc, char **argv, struct command *acmd, struct plugin *
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ void *buf = NULL;
+	_cleanup_nvme_free_ void *buf = NULL;
 	struct nvme_passthru_cmd cmd;
 	__u32 dw12 = 0;
 	_cleanup_fd_ int ffd = STDIN_FILENO;
@@ -7371,8 +7371,8 @@ static int get_pi_info(struct nvme_transport_handle *hdl,
 		__u32 nsid, __u8 prinfo, __u64 ilbrt, __u64 lbst,
 		unsigned int *logical_block_size, __u16 *metadata_size)
 {
-	_cleanup_free_ struct nvme_nvm_id_ns *nvm_ns = NULL;
-	_cleanup_free_ struct nvme_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_nvm_id_ns *nvm_ns = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns *ns = NULL;
 	__u8 sts = 0, pif = 0;
 	unsigned int lbs = 0;
 	__u8 lba_index;
@@ -7434,8 +7434,8 @@ static int init_pi_tags(struct nvme_transport_handle *hdl,
 	struct nvme_passthru_cmd *cmd, __u32 nsid, __u64 ilbrt, __u64 lbst,
 	__u16 lbat, __u16 lbatm)
 {
-	_cleanup_free_ struct nvme_nvm_id_ns *nvm_ns = NULL;
-	_cleanup_free_ struct nvme_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_nvm_id_ns *nvm_ns = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns *ns = NULL;
 	__u8 sts = 0, pif = 0;
 	int err = 0;
 
@@ -7618,7 +7618,7 @@ static int dsm(int argc, char **argv, struct command *acmd, struct plugin *plugi
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ struct nvme_dsm_range *dsm = NULL;
+	_cleanup_nvme_free_ struct nvme_dsm_range *dsm = NULL;
 	struct nvme_passthru_cmd cmd;
 	__u32 ctx_attrs[256] = {0,};
 	__u32 nlbs[256] = {0,};
@@ -7759,7 +7759,7 @@ static int copy_cmd(int argc, char **argv, struct command *acmd, struct plugin *
 	__u32 elbatms[256] = { 0 };
 	__u32 elbats[256] = { 0 };
 
-	_cleanup_free_ union {
+	_cleanup_nvme_free_ union {
 		struct nvme_copy_range f0[256];
 		struct nvme_copy_range_f1 f1[256];
 		struct nvme_copy_range_f2 f2[256];
@@ -8233,8 +8233,8 @@ static int resv_report(int argc, char **argv, struct command *acmd, struct plugi
 
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
-	_cleanup_free_ struct nvme_resv_status *status = NULL;
-	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
+	_cleanup_nvme_free_ struct nvme_resv_status *status = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ctrl *ctrl = NULL;
 	struct nvme_passthru_cmd cmd;
 	nvme_print_flags_t flags;
 	int err, size;
@@ -8329,9 +8329,9 @@ static int submit_io(int opcode, char *command, const char *desc, int argc, char
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	unsigned long long buffer_size = 0, mbuffer_size = 0;
-	_cleanup_free_ struct nvme_nvm_id_ns *nvm_ns = NULL;
+	_cleanup_nvme_free_ struct nvme_nvm_id_ns *nvm_ns = NULL;
 	_cleanup_huge_ struct nvme_mem_huge mh = { 0, };
-	_cleanup_free_ struct nvme_id_ns *ns = NULL;
+	_cleanup_nvme_free_ struct nvme_id_ns *ns = NULL;
 	unsigned int logical_block_size = 0;
 	struct timeval start_time, end_time;
 	_cleanup_free_ void *mbuffer = NULL;
@@ -8793,7 +8793,7 @@ static int sec_recv(int argc, char **argv, struct command *acmd, struct plugin *
 
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
-	_cleanup_free_ void *sec_buf = NULL;
+	_cleanup_nvme_free_ void *sec_buf = NULL;
 	struct nvme_passthru_cmd cmd;
 	nvme_print_flags_t flags;
 	int err;
@@ -8886,7 +8886,7 @@ static int get_lba_status(int argc, char **argv, struct command *acmd,
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 	struct nvme_passthru_cmd cmd;
-	_cleanup_free_ void *buf = NULL;
+	_cleanup_nvme_free_ void *buf = NULL;
 	nvme_print_flags_t flags;
 	unsigned long buf_len;
 	int err;
@@ -9049,7 +9049,7 @@ static int dir_receive(int argc, char **argv, struct command *acmd, struct plugi
 	nvme_print_flags_t flags = NORMAL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ void *buf = NULL;
+	_cleanup_nvme_free_ void *buf = NULL;
 	struct nvme_passthru_cmd cmd;
 	__u32 dw12 = 0;
 	int err;
@@ -10622,7 +10622,7 @@ static int get_mgmt_addr_list_log(int argc, char **argv, struct command *acmd, s
 	nvme_print_flags_t flags;
 	int err = -1;
 
-	_cleanup_free_ struct nvme_mgmt_addr_list_log *ma_log = NULL;
+	_cleanup_nvme_free_ struct nvme_mgmt_addr_list_log *ma_log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
@@ -10660,7 +10660,7 @@ static int get_rotational_media_info_log(int argc, char **argv, struct command *
 	nvme_print_flags_t flags;
 	int err = -1;
 
-	_cleanup_free_ struct nvme_rotational_media_info_log *info = NULL;
+	_cleanup_nvme_free_ struct nvme_rotational_media_info_log *info = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
@@ -10736,7 +10736,7 @@ static int get_dispersed_ns_psub(struct nvme_transport_handle *hdl, __u32 nsid,
 	return 0;
 
 err_free:
-	free(log);
+	nvme_free(log);
 	return err;
 }
 
@@ -10749,7 +10749,7 @@ static int get_dispersed_ns_participating_nss_log(int argc, char **argv, struct
 
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ struct nvme_dispersed_ns_participating_nss_log *log = NULL;
+	_cleanup_nvme_free_ struct nvme_dispersed_ns_participating_nss_log *log = NULL;
 
 	struct config {
 		__u32 namespace_id;
@@ -10844,7 +10844,7 @@ static int get_reachability_group_desc(struct nvme_transport_handle *hdl, struct
 	return 0;
 
 err_free:
-	free(log);
+	nvme_free(log);
 	*logp = NULL;
 	return err;
 }
@@ -10880,7 +10880,7 @@ static int get_reachability_groups(struct nvme_transport_handle *hdl, bool rgo,
 	return 0;
 
 err_free:
-	free(log);
+	nvme_free(log);
 	return err;
 }
 
@@ -10892,7 +10892,7 @@ static int get_reachability_groups_log(int argc, char **argv, struct command *ac
 	nvme_print_flags_t flags;
 	int err;
 	__u64 len = 0;
-	_cleanup_free_ struct nvme_reachability_groups_log *log = NULL;
+	_cleanup_nvme_free_ struct nvme_reachability_groups_log *log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
@@ -10955,7 +10955,7 @@ static int get_reachability_association_desc(struct nvme_transport_handle *hdl,
 	return 0;
 
 err_free:
-	free(log);
+	nvme_free(log);
 	*logp = NULL;
 	return err;
 }
@@ -10991,7 +10991,7 @@ static int get_reachability_associations(struct nvme_transport_handle *hdl, bool
 	return 0;
 
 err_free:
-	free(log);
+	nvme_free(log);
 	return err;
 }
 
@@ -11003,7 +11003,7 @@ static int get_reachability_associations_log(int argc, char **argv, struct comma
 	nvme_print_flags_t flags;
 	int err;
 	__u64 len = 0;
-	_cleanup_free_ struct nvme_reachability_associations_log *log = NULL;
+	_cleanup_nvme_free_ struct nvme_reachability_associations_log *log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
@@ -11073,7 +11073,7 @@ static int get_host_discovery(struct nvme_transport_handle *hdl, bool allhoste,
 	return 0;
 
 err_free:
-	free(log);
+	nvme_free(log);
 	return err;
 }
 
@@ -11083,7 +11083,7 @@ static int get_host_discovery_log(int argc, char **argv, struct command *acmd, s
 	const char *allhoste = "All Host Entries";
 	nvme_print_flags_t flags;
 	int err;
-	_cleanup_free_ struct nvme_host_discover_log *log = NULL;
+	_cleanup_nvme_free_ struct nvme_host_discover_log *log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
@@ -11152,7 +11152,7 @@ static int get_ave_discovery(struct nvme_transport_handle *hdl, bool rae, struct
 	return 0;
 
 err_free:
-	free(log);
+	nvme_free(log);
 	return err;
 }
 
@@ -11162,7 +11162,7 @@ static int get_ave_discovery_log(int argc, char **argv, struct command *acmd, st
 	nvme_print_flags_t flags;
 	int err;
 
-	_cleanup_free_ struct nvme_ave_discover_log *log = NULL;
+	_cleanup_nvme_free_ struct nvme_ave_discover_log *log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
@@ -11227,7 +11227,7 @@ static int get_pull_model_ddc_req(struct nvme_transport_handle *hdl,
 	return 0;
 
 err_free:
-	free(log);
+	nvme_free(log);
 	return err;
 }
 
@@ -11238,7 +11238,7 @@ static int get_pull_model_ddc_req_log(int argc, char **argv, struct command *acm
 	nvme_print_flags_t flags;
 	int err;
 
-	_cleanup_free_ struct nvme_pull_model_ddc_req_log *log = NULL;
+	_cleanup_nvme_free_ struct nvme_pull_model_ddc_req_log *log = NULL;
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
 
diff --git a/plugins/feat/feat-nvme.c b/plugins/feat/feat-nvme.c
index 0d17680809..a18fc3db3b 100644
--- a/plugins/feat/feat-nvme.c
+++ b/plugins/feat/feat-nvme.c
@@ -58,7 +58,7 @@ static int feat_get(struct nvme_transport_handle *hdl, const __u8 fid,
 	int err;
 	__u32 len = 0;
 
-	_cleanup_free_ void *buf = NULL;
+	_cleanup_nvme_free_ void *buf = NULL;
 
 	if (!NVME_CHECK(sel, GET_FEATURES_SEL, SUPPORTED))
 		nvme_get_feature_length(fid, cdw11, NVME_DATA_TFR_CTRL_TO_HOST, &len);
diff --git a/plugins/memblaze/memblaze-nvme.c b/plugins/memblaze/memblaze-nvme.c
index 3b9b047f7d..980551c831 100644
--- a/plugins/memblaze/memblaze-nvme.c
+++ b/plugins/memblaze/memblaze-nvme.c
@@ -860,7 +860,7 @@ static int mb_selective_download(int argc, char **argv, struct command *acmd, st
 	}
 
 out_free:
-	free(fw_buf);
+	platform_aligned_free(fw_buf);
 out_close:
 	close(fw_fd);
 out:
diff --git a/plugins/micron/micron-nvme.c b/plugins/micron/micron-nvme.c
index e9399baf36..9828e19a54 100644
--- a/plugins/micron/micron-nvme.c
+++ b/plugins/micron/micron-nvme.c
@@ -682,7 +682,7 @@ static int micron_selective_download(int argc, char **argv,
 	}
 
 out_free:
-	free(fw_buf);
+	platform_aligned_free(fw_buf);
 out:
 	close(fw_fd);
 	return err;
diff --git a/plugins/netapp/netapp-nvme.c b/plugins/netapp/netapp-nvme.c
index 5eb21b25d4..0af7e1d097 100644
--- a/plugins/netapp/netapp-nvme.c
+++ b/plugins/netapp/netapp-nvme.c
@@ -830,12 +830,12 @@ static int netapp_ontapdevices_get_info(struct nvme_transport_handle *hdl,
 		fprintf(stderr, "Unable to identify namespace descriptor for %s (%s)\n",
 			dev, err < 0 ? nvme_strerror(-err) :
 			nvme_status_to_string(err, false));
-		free(nsdescs);
+		platform_aligned_free(nsdescs);
 		return 0;
 	}
 
 	memcpy(item->uuid, nsdescs + sizeof(struct nvme_ns_id_desc), sizeof(item->uuid));
-	free(nsdescs);
+	platform_aligned_free(nsdescs);
 
 	err = nvme_get_ontap_c2_log(hdl, item->nsid, item->log_data, ONTAP_C2_LOG_SIZE);
 	if (err) {
diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index 750e0faac0..d809275317 100644
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -2621,7 +2621,7 @@ static int fw_activation_history_log(int argc, char **argv, struct command *acmd
 
 static int error_injection_get(struct nvme_transport_handle *hdl, const __u8 sel, bool uuid, __u32 nsid)
 {
-	_cleanup_free_ struct erri_entry *entry = NULL;
+	_cleanup_nvme_free_ struct erri_entry *entry = NULL;
 	struct erri_get_cq_entry cq_entry;
 	const __u8 fid = OCP_FID_ERRI;
 	__u64 result;
@@ -2704,7 +2704,7 @@ static int get_error_injection(int argc, char **argv, struct command *acmd, stru
 
 static int error_injection_set(struct nvme_transport_handle *hdl, struct erri_config *cfg, bool uuid, __u32 nsid)
 {
-	_cleanup_free_ struct erri_entry *entry = NULL;
+	_cleanup_nvme_free_ struct erri_entry *entry = NULL;
 	_cleanup_fd_ int ffd = -1;
 	__u32 data_len;
 	__u8 uidx = 0;
@@ -2927,7 +2927,7 @@ static int ocp_get_persistent_event_log(int argc, char **argv,
 		"processing this persistent log page command.";
 	const char *log_len = "number of bytes to retrieve";
 
-	_cleanup_free_ struct nvme_persistent_event_log *pevent = NULL;
+	_cleanup_nvme_free_ struct nvme_persistent_event_log *pevent = NULL;
 	struct nvme_persistent_event_log *pevent_collected = NULL;
 	_cleanup_huge_ struct nvme_mem_huge mh = { 0, };
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
diff --git a/plugins/shannon/shannon-nvme.c b/plugins/shannon/shannon-nvme.c
index 7cfd1d3cc9..9498b04a88 100644
--- a/plugins/shannon/shannon-nvme.c
+++ b/plugins/shannon/shannon-nvme.c
@@ -230,7 +230,7 @@ static int get_additional_feature(int argc, char **argv, struct command *acmd, s
 			cfg.cdw11, 0, buf, cfg.data_len, &result);
 	if (err > 0)
 		nvme_show_status(err);
-	free(buf);
+	platform_aligned_free(buf);
 	return err;
 }
 
@@ -255,7 +255,7 @@ static int set_additional_feature(int argc, char **argv, struct command *acmd, s
 	const char *save = "specifies that the controller shall save the attribute";
 	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
 	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
-	_cleanup_free_ void *buf = NULL;
+	_cleanup_nvme_free_ void *buf = NULL;
 	int ffd = STDIN_FILENO;
 	__u64 result;
 	int err;
diff --git a/plugins/solidigm/solidigm-internal-logs.c b/plugins/solidigm/solidigm-internal-logs.c
index be1b0e4e6b..3903eed980 100644
--- a/plugins/solidigm/solidigm-internal-logs.c
+++ b/plugins/solidigm/solidigm-internal-logs.c
@@ -773,7 +773,7 @@ static int ilog_dump_no_lsp_log_pages(struct nvme_transport_handle *hdl, struct
 
 static int ilog_dump_pel(struct nvme_transport_handle *hdl, struct ilog *ilog)
 {
-	_cleanup_free_ struct nvme_persistent_event_log *pevent = NULL;
+	_cleanup_nvme_free_ struct nvme_persistent_event_log *pevent = NULL;
 	_cleanup_huge_ struct nvme_mem_huge mh = {0};
 	void *pevent_log_full;
 	size_t max_data_tx;
diff --git a/plugins/toshiba/toshiba-nvme.c b/plugins/toshiba/toshiba-nvme.c
index 7dfcf2fb3d..0b83693d04 100644
--- a/plugins/toshiba/toshiba-nvme.c
+++ b/plugins/toshiba/toshiba-nvme.c
@@ -109,7 +109,7 @@ static int nvme_get_sct_status(struct nvme_transport_handle *hdl, __u32 device_m
 		}
 	}
 end:
-	free(data);
+	platform_aligned_free(data);
 	return err;
 }
 
@@ -133,7 +133,7 @@ static int nvme_sct_command_transfer_log(struct nvme_transport_handle *hdl, bool
 	memcpy(data + 2, &function_code, sizeof(function_code));
 
 	err = nvme_sct_op(hdl, OP_SCT_COMMAND_TRANSFER, DW10_SCT_COMMAND_TRANSFER, DW11_SCT_COMMAND_TRANSFER, data, data_len);
-	free(data);
+	platform_aligned_free(data);
 	return err;
 }
 
@@ -313,7 +313,7 @@ static int nvme_get_internal_log(struct nvme_transport_handle *hdl,
 end:
 	if (o_fd >= 0)
 		close(o_fd);
-	free(page_data);
+	platform_aligned_free(page_data);
 	return err;
 }
 
@@ -410,7 +410,7 @@ static int nvme_get_vendor_log(struct nvme_transport_handle *hdl,
 			d(log, log_len, 16, 1);
 	}
 end:
-	free(log);
+	platform_aligned_free(log);
 	return err;
 }
 
diff --git a/plugins/wdc/wdc-nvme.c b/plugins/wdc/wdc-nvme.c
index 394fff4ccd..446763986e 100644
--- a/plugins/wdc/wdc-nvme.c
+++ b/plugins/wdc/wdc-nvme.c
@@ -2871,7 +2871,7 @@ static bool wdc_nvme_check_supported_log_page(struct nvme_global_ctx *ctx,
 	int err = -1;
 	struct wdc_c2_cbs_data *cbs_data = NULL;
 
-	_cleanup_free_ struct nvme_supported_log_pages *supports = NULL;
+	_cleanup_nvme_free_ struct nvme_supported_log_pages *supports = NULL;
 
 	/* Check log page id 0 (supported log pages) first */
 	supports = nvme_alloc(sizeof(*supports));
diff --git a/plugins/zns/zns.c b/plugins/zns/zns.c
index 9c1c1155ae..30e2655692 100644
--- a/plugins/zns/zns.c
+++ b/plugins/zns/zns.c
@@ -422,7 +422,7 @@ static int zone_mgmt_send(int argc, char **argv, struct command *acmd, struct pl
 	if (cfg.file)
 		close(ffd);
 free:
-	free(buf);
+	platform_aligned_free(buf);
 	return err;
 }
 
@@ -1072,12 +1072,12 @@ static int zone_append(int argc, char **argv, struct command *acmd, struct plugi
 		perror("zns zone-append");
 
 free_meta:
-	free(mbuf);
+	platform_aligned_free(mbuf);
 close_mfd:
 	if (cfg.metadata)
 		close(mfd);
 free_data:
-	free(buf);
+	platform_aligned_free(buf);
 close_dfd:
 	if (cfg.data)
 		close(dfd);
diff --git a/util/cleanup.h b/util/cleanup.h
index bb11d32842..985822e05c 100644
--- a/util/cleanup.h
+++ b/util/cleanup.h
@@ -27,6 +27,12 @@ static inline void freep(void *p)
 }
 #define _cleanup_free_ __cleanup__(freep)
 
+static inline void nvme_freep(void *p)
+{
+	nvme_free(*(void **)p);
+}
+#define _cleanup_nvme_free_ __cleanup__(nvme_freep)
+
 #define _cleanup_huge_ __cleanup__(nvme_free_huge)
 
 static inline void cleanup_fd(int *fd)
diff --git a/util/mem-windows.c b/util/mem-windows.c
new file mode 100644
index 0000000000..130834ac43
--- /dev/null
+++ b/util/mem-windows.c
@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2025 Micron Technology, Inc.
+ *
+ * Authors: Brandon Capener <bcapener@micron.com>
+ */
+
+#include <stdlib.h>
+#include <malloc.h>
+#include <string.h>
+
+#include "platform/includes.h"
+#include "mem.h"
+#include "common.h"
+
+#define ROUND_UP(N, S) ((((N) + (S) - 1) / (S)) * (S))
+#define HUGE_MIN 0x80000 /* policy threshold when large pages unavailable */
+
+void *nvme_alloc_huge(size_t len, struct nvme_mem_huge *mh)
+{
+	SIZE_T large_min = GetLargePageMinimum(); /* 0 if unsupported/unavailable */
+	SIZE_T huge_min = large_min ? large_min : HUGE_MIN;
+	SIZE_T page_size = getpagesize();
+	SIZE_T align;
+
+	memset(mh, 0, sizeof(*mh));
+
+	len = ROUND_UP(len, page_size);
+
+	/*
+	 * For smaller allocations, use regular allocator.
+	 */
+	if (len < huge_min) {
+		mh->p = nvme_alloc(len);
+		if (!mh->p)
+			return NULL;
+		mh->posix_memalign = true;
+		mh->len = len;
+		return mh->p;
+	}
+
+	/*
+	 * Try large pages first when available.
+	 * Requires SeLockMemoryPrivilege and size multiple of large_min.
+	 */
+	if (large_min) {
+		SIZE_T lp_len = ROUND_UP(len, large_min);
+
+		mh->p = VirtualAlloc(NULL, lp_len,
+					 MEM_COMMIT | MEM_RESERVE | MEM_LARGE_PAGES,
+					 PAGE_READWRITE);
+		if (mh->p != NULL) {
+			mh->len = lp_len;
+			mh->posix_memalign = false;
+			return mh->p;
+		}
+	}
+
+	/*
+	 * Fallback to regular VirtualAlloc.
+	 */
+	mh->p = VirtualAlloc(NULL, len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+	if (mh->p != NULL) {
+		mh->len = len;
+		mh->posix_memalign = false;
+		return mh->p;
+	}
+
+	/*
+	 * Final fallback: aligned heap allocation.
+	 * Prefer large page size if known, otherwise page size.
+	 */
+	align = large_min ? large_min : page_size;
+	len = ROUND_UP(len, align);
+	if (posix_memalign(&mh->p, align, len))
+		return NULL;
+
+	mh->posix_memalign = true;
+	mh->len = len;
+	memset(mh->p, 0, mh->len);
+	return mh->p;
+}
+
+void nvme_free_huge(struct nvme_mem_huge *mh)
+{
+	if (!mh || mh->len == 0)
+		return;
+
+	if (mh->posix_memalign)
+		nvme_free(mh->p);
+	else
+		VirtualFree(mh->p, 0, MEM_RELEASE);
+
+	mh->len = 0;
+	mh->p = NULL;
+}
diff --git a/util/mem.c b/util/mem.c
index de9294aa63..1dcd829c65 100644
--- a/util/mem.c
+++ b/util/mem.c
@@ -1,6 +1,5 @@
 /* SPDX-License-Identifier: GPL-2.0-or-later */
 #include <stdlib.h>
-#include <unistd.h>
 #include <malloc.h>
 #include <string.h>
 #ifndef _WIN32
@@ -36,12 +35,18 @@ void *nvme_realloc(void *p, size_t len)
 
 	if (p) {
 		memcpy(result, p, min(old_len, len));
-		free(p);
+		nvme_free(p);
 	}
 
 	return result;
 }
 
+void nvme_free(void *p)
+{
+	platform_aligned_free(p);
+}
+
+#ifndef _WIN32
 void *nvme_alloc_huge(size_t len, struct nvme_mem_huge *mh)
 {
 	memset(mh, 0, sizeof(*mh));
@@ -104,10 +109,11 @@ void nvme_free_huge(struct nvme_mem_huge *mh)
 		return;
 
 	if (mh->posix_memalign)
-		free(mh->p);
+		nvme_free(mh->p);
 	else
 		munmap(mh->p, mh->len);
 
 	mh->len = 0;
 	mh->p = NULL;
 }
+#endif
diff --git a/util/mem.h b/util/mem.h
index d13eb3a213..a792457cbc 100644
--- a/util/mem.h
+++ b/util/mem.h
@@ -7,6 +7,7 @@
 
 void *nvme_alloc(size_t len);
 void *nvme_realloc(void *p, size_t len);
+void nvme_free(void *p);
 
 struct nvme_mem_huge {
 	size_t len;
diff --git a/util/meson.build b/util/meson.build
index 9f8bdf2a6b..c017f8f06d 100644
--- a/util/meson.build
+++ b/util/meson.build
@@ -12,6 +12,12 @@ util_sources = [
     'util/table.c'
 ]
 
+if is_windows
+	util_sources += [
+		'util/mem-windows.c',
+	]
+endif
+
 if json_c_dep.found()
     util_sources += [
         'util/json.c',

From 297fba6d1946d985e05952697e5633039faa15d8 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 20 Feb 2026 21:08:26 -0700
Subject: [PATCH 29/83] Cleanup of includes and some formatting. (#59)

* Cleaned up formatting in includes.h and linux.h.
* Standardized positioning of platform/includes.h includes and removed
comments.
* Updated more files to use platform/includes.h and removed _WIN32
checks.
* Removed platform-agnostic includes from platform/includes.h. They were
still being included explicitly where needed, and it didn't make sense
to have them included in the platform-specific includes file as well.
---
 libnvme/src/nvme/cleanup.h      |  2 +-
 libnvme/src/nvme/fabrics.c      |  2 +-
 libnvme/src/nvme/ioctl.h        |  4 ++--
 libnvme/src/nvme/linux.c        |  2 +-
 libnvme/src/nvme/log.c          |  2 +-
 libnvme/src/nvme/log.h          |  2 +-
 libnvme/src/nvme/mi-mctp.c      |  3 ++-
 libnvme/src/nvme/mi.h           |  3 ++-
 libnvme/src/nvme/nbft.c         |  2 +-
 libnvme/src/nvme/private.h      |  2 +-
 libnvme/src/nvme/tree.c         |  2 +-
 libnvme/src/nvme/tree.h         |  2 +-
 libnvme/src/nvme/types.h        |  2 +-
 libnvme/src/nvme/util.c         |  3 ++-
 libnvme/src/nvme/util.h         |  2 +-
 libnvme/src/platform/includes.h | 15 ++-------------
 libnvme/src/platform/linux.h    | 10 ++++------
 libnvme/src/platform/windows.c  |  6 ++----
 libnvme/src/platform/windows.h  |  2 +-
 logging.c                       |  8 ++------
 nvme-print-stdout.c             |  6 ++----
 nvme.c                          |  6 ------
 nvme.h                          |  7 ++-----
 util/mem-windows.c              |  1 +
 util/mem.c                      |  3 ---
 25 files changed, 35 insertions(+), 64 deletions(-)

diff --git a/libnvme/src/nvme/cleanup.h b/libnvme/src/nvme/cleanup.h
index 2cc7667cf3..afb4505107 100644
--- a/libnvme/src/nvme/cleanup.h
+++ b/libnvme/src/nvme/cleanup.h
@@ -6,7 +6,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"
 
 #include "fabrics.h"
 #include "private.h"
diff --git a/libnvme/src/nvme/fabrics.c b/libnvme/src/nvme/fabrics.c
index 0cf5d7b27c..a5c70a749d 100644
--- a/libnvme/src/nvme/fabrics.c
+++ b/libnvme/src/nvme/fabrics.c
@@ -21,7 +21,7 @@
 #include <dirent.h>
 #include <inttypes.h>
 
-#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"
 
 #include <ccan/endian/endian.h>
 #include <ccan/list/list.h>
diff --git a/libnvme/src/nvme/ioctl.h b/libnvme/src/nvme/ioctl.h
index a3f3a2c805..2022f798a6 100644
--- a/libnvme/src/nvme/ioctl.h
+++ b/libnvme/src/nvme/ioctl.h
@@ -11,10 +11,10 @@
 #define _LIBNVME_IOCTL_H
 
 #include <string.h>
-#include "platform/includes.h"  /* Platform abstraction - includes endian.h and ioctl.h */
 #include <errno.h>
 #include <stddef.h>
-#include <string.h>
+
+#include "platform/includes.h"
 
 #include <nvme/types.h>
 
diff --git a/libnvme/src/nvme/linux.c b/libnvme/src/nvme/linux.c
index 4595a7f221..e30ae59245 100644
--- a/libnvme/src/nvme/linux.c
+++ b/libnvme/src/nvme/linux.c
@@ -12,7 +12,7 @@
 #include <string.h>
 #include <errno.h>
 
-#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"
 
 #ifdef CONFIG_OPENSSL
 #include <openssl/evp.h>
diff --git a/libnvme/src/nvme/log.c b/libnvme/src/nvme/log.c
index 5004dd420c..91df527649 100644
--- a/libnvme/src/nvme/log.c
+++ b/libnvme/src/nvme/log.c
@@ -12,7 +12,7 @@
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdbool.h>
-#include "platform/includes.h"  /* Platform abstraction - includes syslog */
+#include "platform/includes.h"
 #include <time.h>
 #define LOG_FUNCNAME 1
 #include "private.h"
diff --git a/libnvme/src/nvme/log.h b/libnvme/src/nvme/log.h
index 36f4e66203..d3ba79f269 100644
--- a/libnvme/src/nvme/log.h
+++ b/libnvme/src/nvme/log.h
@@ -6,7 +6,7 @@
 #define _LOG_H
 
 #include <stdbool.h>
-#include "platform/includes.h"  /* Platform abstraction - includes syslog */
+#include "platform/includes.h"
 
 /* for nvme_root_t */
 #include <nvme/tree.h>
diff --git a/libnvme/src/nvme/mi-mctp.c b/libnvme/src/nvme/mi-mctp.c
index 227072867c..5487e22638 100644
--- a/libnvme/src/nvme/mi-mctp.c
+++ b/libnvme/src/nvme/mi-mctp.c
@@ -10,9 +10,10 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
 #include <fcntl.h>
 
+#include "platform/includes.h"
+
 #if HAVE_LINUX_MCTP_H
 #include <linux/mctp.h>
 #else
diff --git a/libnvme/src/nvme/mi.h b/libnvme/src/nvme/mi.h
index 447a7c3d56..162f4feb85 100644
--- a/libnvme/src/nvme/mi.h
+++ b/libnvme/src/nvme/mi.h
@@ -84,9 +84,10 @@
 #ifndef _LIBNVME_MI_MI_H
 #define _LIBNVME_MI_MI_H
 
-#include "platform/includes.h"  /* Platform abstraction */
 #include <stdint.h>
 
+#include "platform/includes.h"
+
 #include <nvme/types.h>
 #include <nvme/tree.h>
 
diff --git a/libnvme/src/nvme/nbft.c b/libnvme/src/nvme/nbft.c
index 54dc156e5d..cda4916bf5 100644
--- a/libnvme/src/nvme/nbft.c
+++ b/libnvme/src/nvme/nbft.c
@@ -10,8 +10,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
 #include <ccan/endian/endian.h>
+#include "platform/includes.h"
 
 #include "private.h"
 #include "nbft.h"
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index e44f7e85f7..1256af132f 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -10,7 +10,7 @@
 #define _LIBNVME_PRIVATE_H
 
 #include <ccan/list/list.h>
-#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"
 
 #include <nvme/fabrics.h>
 #include <nvme/mi.h>
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index 574f5dedf9..a395b74d4b 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -15,7 +15,7 @@
 #include <fcntl.h>
 #include <libgen.h>
 
-#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
+#include "platform/includes.h"
 
 #include <ccan/endian/endian.h>
 #include <ccan/list/list.h>
diff --git a/libnvme/src/nvme/tree.h b/libnvme/src/nvme/tree.h
index 416821a7d4..c361e0fb37 100644
--- a/libnvme/src/nvme/tree.h
+++ b/libnvme/src/nvme/tree.h
@@ -13,7 +13,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-#include "platform/includes.h"  /* Platform abstraction */
+#include "platform/includes.h"
 
 #include <nvme/ioctl.h>
 #include <nvme/util.h>
diff --git a/libnvme/src/nvme/types.h b/libnvme/src/nvme/types.h
index 6cf002f7cf..67c38a9cd9 100644
--- a/libnvme/src/nvme/types.h
+++ b/libnvme/src/nvme/types.h
@@ -14,7 +14,7 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include "platform/includes.h"  /* Platform abstraction - includes type definitions */
+#include "platform/includes.h"
 
 struct nvme_global_ctx;
 struct nvme_transport_handle;
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 20efd626fe..e0c4048514 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -16,7 +16,8 @@
 
 #include <sys/stat.h>
 #include <fcntl.h>
-#include "platform/includes.h"  /* Platform abstraction - includes all needed headers */
+
+#include "platform/includes.h"
 
 #include <ccan/minmax/minmax.h>
 #include <ccan/endian/endian.h>
diff --git a/libnvme/src/nvme/util.h b/libnvme/src/nvme/util.h
index 7994fda5ef..3382041577 100644
--- a/libnvme/src/nvme/util.h
+++ b/libnvme/src/nvme/util.h
@@ -9,7 +9,7 @@
 #ifndef _LIBNVME_UTIL_H
 #define _LIBNVME_UTIL_H
 
-#include "platform/includes.h"  /* Platform abstraction */
+#include "platform/includes.h"
 
 #include <nvme/types.h>
 
diff --git a/libnvme/src/platform/includes.h b/libnvme/src/platform/includes.h
index 22a97c14d1..841314cb9c 100644
--- a/libnvme/src/platform/includes.h
+++ b/libnvme/src/platform/includes.h
@@ -3,23 +3,12 @@
  * This file is part of libnvme.
  * Copyright (c) 2025 Micron Technology, Inc.
  *
- * Main platform abstraction entry point.
- * Replaces the scattered #ifdef WIN32 conditionals throughout the codebase.
+ * Common platform-specific includes and definitions.
  */
 
 #ifndef _LIBNVME_PLATFORM_INCLUDES_H
 #define _LIBNVME_PLATFORM_INCLUDES_H
 
-/* Standard includes needed everywhere */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include <assert.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-
 #include "platform/types.h"
 
 /* Platform-specific includes */
@@ -29,4 +18,4 @@
     #include "platform/linux.h"
 #endif
 
-#endif /* _LIBNVME_PLATFORM_INCLUDES_H */
\ No newline at end of file
+#endif /* _LIBNVME_PLATFORM_INCLUDES_H */
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index 4c3f91f1e1..5bf7158600 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -4,13 +4,13 @@
  * Copyright (c) 2025 Micron Technology, Inc.
  *
  * Linux platform-specific definitions and includes.
- * Complete replacement for Linux portions of legacy platform.h
  */
 
 #ifndef _LIBNVME_PLATFORM_LINUX_H
 #define _LIBNVME_PLATFORM_LINUX_H
 
-/* Linux standard includes */
+/* Linux includes */
+#include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>
@@ -28,9 +28,7 @@
 #include <ifaddrs.h>
 #include <poll.h>
 #include <syslog.h>
-
-/* Linux-specific includes */
-#include <linux/types.h>
+#include <dirent.h>
 #include <endian.h>
 #include <net/if.h>
 
@@ -79,4 +77,4 @@ static inline void platform_aligned_free(void *p)
 	free(p);
 }
 
-#endif /* _LIBNVME_PLATFORM_LINUX_H */
\ No newline at end of file
+#endif /* _LIBNVME_PLATFORM_LINUX_H */
diff --git a/libnvme/src/platform/windows.c b/libnvme/src/platform/windows.c
index 65533df248..656928e124 100644
--- a/libnvme/src/platform/windows.c
+++ b/libnvme/src/platform/windows.c
@@ -7,9 +7,9 @@
  * Provides POSIX-compatible functions for Windows.
  */
 
-#ifdef _WIN32
-
 #include "platform/includes.h"
+#include <stdlib.h>
+#include <string.h>
 
 /* getline implementation for Windows */
 ssize_t getline(char **lineptr, size_t *n, FILE *stream) {
@@ -114,5 +114,3 @@ FILE *open_memstream(char **ptr, size_t *sizeloc) {
 	if (sizeloc) *sizeloc = 0;
 	return f;
 }
-
-#endif /* _WIN32 */
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index a64d2a4246..725e4070a5 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -4,7 +4,6 @@
  * Copyright (c) 2025 Micron Technology, Inc.
  *
  * Windows platform-specific definitions and includes.
- * Complete replacement for Windows portions of legacy platform.h
  */
 
 #ifndef _LIBNVME_PLATFORM_WINDOWS_H
@@ -19,6 +18,7 @@
 #include <winioctl.h>
 #include <ntddstor.h>
 #include <bcrypt.h>
+#include <stdio.h>
 #include <stdint.h>
 #include <stdarg.h>
 #include <errno.h>
diff --git a/logging.c b/logging.c
index c718969c3e..9faa639e05 100644
--- a/logging.c
+++ b/logging.c
@@ -5,12 +5,8 @@
 #include <stdint.h>
 #include <string.h>
 #include <errno.h>
-#ifndef _WIN32
-#include <sys/ioctl.h>
-#include <sys/syslog.h>
-#include <sys/time.h>
-#include <platform/types.h>
-#endif
+
+#include "platform/includes.h"
 
 #include <libnvme.h>
 #include <libnvme-mi.h>
diff --git a/nvme-print-stdout.c b/nvme-print-stdout.c
index 26c6e08056..278d06d9ea 100644
--- a/nvme-print-stdout.c
+++ b/nvme-print-stdout.c
@@ -7,15 +7,13 @@
 #include <time.h>
 #include <sys/stat.h>
 #include <sys/types.h>
-#ifndef _WIN32
-#include <sys/socket.h>
-#include <arpa/inet.h>
-#endif
 #include <ccan/strset/strset.h>
 #include <ccan/htable/htable_type.h>
 #include <ccan/htable/htable.h>
 #include <ccan/hash/hash.h>
 
+#include "platform/includes.h"
+
 #include "nvme.h"
 #include "libnvme.h"
 #include "nvme-print.h"
diff --git a/nvme.c b/nvme.c
index a19f0eb5e6..88c5bf75a9 100644
--- a/nvme.c
+++ b/nvme.c
@@ -38,9 +38,6 @@
 #include <string.h>
 #include <unistd.h>
 #include <math.h>
-#ifndef _WIN32
-#include <dirent.h>
-#endif
 #include <libgen.h>
 #include <signal.h>
 
@@ -48,9 +45,6 @@
 #include <linux/fs.h>
 #endif
 
-#ifndef _WIN32
-#include <sys/mman.h>
-#endif
 #include <sys/types.h>
 #include <sys/stat.h>
 
diff --git a/nvme.h b/nvme.h
index 6703ed3233..a164b2a06f 100644
--- a/nvme.h
+++ b/nvme.h
@@ -19,13 +19,10 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
-#ifndef _WIN32
-#include <dirent.h>
-#include <endian.h>
-#include <sys/time.h>
-#endif
 #include <sys/stat.h>
 
+#include "platform/includes.h"
+
 #include <libnvme-mi.h>
 
 #include "plugin.h"
diff --git a/util/mem-windows.c b/util/mem-windows.c
index 130834ac43..6ce3a6f126 100644
--- a/util/mem-windows.c
+++ b/util/mem-windows.c
@@ -11,6 +11,7 @@
 #include <string.h>
 
 #include "platform/includes.h"
+
 #include "mem.h"
 #include "common.h"
 
diff --git a/util/mem.c b/util/mem.c
index 1dcd829c65..375c960883 100644
--- a/util/mem.c
+++ b/util/mem.c
@@ -2,9 +2,6 @@
 #include <stdlib.h>
 #include <malloc.h>
 #include <string.h>
-#ifndef _WIN32
-#include <sys/mman.h>
-#endif
 
 #include "platform/includes.h"
 

From 12d5218acad363ca689d30560ac93cd7fb493edd Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 20 Feb 2026 21:09:10 -0700
Subject: [PATCH 30/83] Removed BUILD.md and updated ENVIRONMENT.md. (#60)

The build instructions are already documented in README.md,
and Windows builds now follow the same pattern.

Removed ENVIRONMENT.md references to MSVC.
This file will likely not be needed for the final merge,
but it provides good documentation for now.
It would be good to figure out how best to add it to README.md.
---
 BUILD.md       | 467 -------------------------------------------------
 ENVIRONMENT.md |  15 +-
 2 files changed, 2 insertions(+), 480 deletions(-)
 delete mode 100644 BUILD.md

diff --git a/BUILD.md b/BUILD.md
deleted file mode 100644
index 2a50d87aac..0000000000
--- a/BUILD.md
+++ /dev/null
@@ -1,467 +0,0 @@
-# Build Guide for nvme-cli
-
-This document provides instructions for building nvme-cli and libnvme on both Linux and Windows platforms.
-
-> **Prerequisites:** Before building, ensure your environment is properly set up by following the instructions in [ENVIRONMENT.md](ENVIRONMENT.md).
-
-## Table of Contents
-
-- [Build Configuration Options](#build-configuration-options)
-- [Building libnvme](#building-libnvme)
-- [Building nvme-cli](#building-nvme-cli)
-- [Common Build Scenarios](#common-build-scenarios)
-- [Reconfiguring](#reconfiguring-an-existing-build)
-- [Troubleshooting](#troubleshooting)
-
-## Meson Options
-
-Key options available via `-D<option>=<value>`:
-
-| Option | Values | Default | Description |
-|--------|--------|---------|-------------|
-| `nvme` | enabled/disabled/auto | enabled | Build nvme executable |
-| `libnvme` | enabled/disabled/auto | enabled | Build libnvme library |
-| `default_library` | static/shared/both | shared | Library build type |
-| `tests` | true/false | true | Build tests |
-| `nvme-tests` | true/false | false | Run tests against real hardware |
-| `docs` | false/html/man/rst/all | false | Install documentation |
-| `docs-build` | true/false | false | Build documentation |
-| `examples` | true/false | true | Build examples |
-| `python` | enabled/disabled/auto | auto | Build Python bindings |
-| `json-c` | enabled/disabled/auto | auto | JSON support (Linux only) |
-| `openssl` | enabled/disabled/auto | auto | OpenSSL support |
-| `keyutils` | enabled/disabled/auto | auto | Keyutils support (Linux only) |
-| `libdbus` | enabled/disabled/auto | disabled | DBus support (Linux only) |
-| `liburing` | enabled/disabled/auto | disabled | io_uring support (Linux only) |
-| `version-tag` | string | (auto-detected) | Override version (required on Windows with MinGW to avoid bash dependency) |
-
-**Important for Windows:** When using MinGW on Windows, always specify `-Dversion-tag=<version>` (e.g., `-Dversion-tag=3.0-a.1`) to bypass a bash script that detects the git version. Without this option, the build will fail in PowerShell environments.
-
-### Common Configuration Patterns
-
-#### Minimal Build (libnvme only, no tests, no docs)
-
-**Linux:**
-```bash
-meson setup .build \
-    -Dnvme=disabled \
-    -Dlibnvme=enabled \
-    -Dtests=false \
-    -Ddocs=false \
-    -Ddocs-build=false \
-    -Dexamples=false
-```
-
-**Windows (PowerShell):**
-```powershell
-meson setup .build `
-    -Dnvme=disabled `
-    -Dlibnvme=enabled `
-    -Dtests=false `
-    -Ddocs=false `
-    -Ddocs-build=false `
-    -Dexamples=false `
-    -Dversion-tag=3.0-a.1
-```
-
-#### Full Featured Build
-```bash
-meson setup .build \
-    -Djson-c=enabled \
-    -Dopenssl=enabled \
-    -Dkeyutils=enabled \
-    -Dtests=true \
-    -Ddocs-build=true
-```
-
-#### Static Library Build
-```bash
-meson setup .build -Ddefault_library=static
-```
-
-#### Dynamic Library Build
-```bash
-meson setup .build -Ddefault_library=shared
-```
-
-## Building libnvme
-
-Starting with nvme-cli 3.x, libnvme is fully integrated into the nvme-cli source tree. There is no separate repository or external dependency.
-
-### Basic libnvme Build
-
-Build libnvme only (without nvme-cli, tests, or documentation):
-
-**Linux:**
-```bash
-# Configure
-meson setup .build \
-    -Dnvme=disabled \
-    -Dlibnvme=enabled \
-    -Dtests=false \
-    -Ddocs=false \
-    -Ddocs-build=false \
-    -Dexamples=false
-
-# Build
-meson compile -C .build
-
-# Install (optional)
-sudo meson install -C .build
-```
-
-**Windows (PowerShell with MinGW):**
-```powershell
-# Set PATH (adjust paths if needed)
-$env:PATH = "C:\Users\$env:USERNAME\AppData\Local\Microsoft\WinGet\Packages\BrechtSanders.WinLibs.POSIX.UCRT_Microsoft.Winget.Source_8wekyb3d8bbwe\mingw64\bin;C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312\Scripts;C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312;$env:PATH"
-
-# Configure
-meson setup .build `
-    -Dnvme=disabled `
-    -Dlibnvme=enabled `
-    -Dtests=false `
-    -Ddocs=false `
-    -Ddocs-build=false `
-    -Dexamples=false `
-    -Dversion-tag=3.0-a.1
-
-# Build
-meson compile -C .build
-
-# Install (optional, requires admin privileges)
-meson install -C .build
-```
-
-### Static Build
-
-To build libnvme as a static library:
-
-```bash
-meson setup .build \
-    -Ddefault_library=static \
-    -Dnvme=disabled \
-    -Dlibnvme=enabled \
-    -Dtests=false \
-    -Ddocs=false \
-    -Ddocs-build=false
-    
-meson compile -C .build
-```
-
-The static library will be located at: `.build/libnvme/src/libnvme.a` (Linux) or `.build/libnvme/src/libnvme.lib` (Windows)
-
-### Dynamic Build
-
-To build libnvme as a shared library:
-
-```bash
-meson setup .build \
-    -Ddefault_library=shared \
-    -Dnvme=disabled \
-    -Dlibnvme=enabled \
-    -Dtests=false \
-    -Ddocs=false \
-    -Ddocs-build=false
-    
-meson compile -C .build
-```
-
-The shared library will be located at: 
-- Linux: `.build/libnvme/src/libnvme.so.<version>`
-- Windows: `.build/libnvme/src/libnvme.dll`
-
-### Without Tests
-
-To skip building tests (recommended for production builds):
-
-```bash
-meson setup .build \
-    -Dtests=false \
-    -Dnvme-tests=false
-    
-meson compile -C .build
-```
-
-### Without Documentation
-
-To skip building documentation:
-
-```bash
-meson setup .build \
-    -Ddocs=false \
-    -Ddocs-build=false
-    
-meson compile -C .build
-```
-
-### With Specific Dependencies
-
-#### Linux with JSON and OpenSSL
-```bash
-meson setup .build \
-    -Djson-c=enabled \
-    -Dopenssl=enabled \
-    -Dkeyutils=enabled
-    
-meson compile -C .build
-```
-
-#### Windows with OpenSSL
-```bash
-meson setup .build -Dopenssl=enabled
-meson compile -C .build
-```
-
-## Building nvme-cli
-
-To build the complete nvme-cli tool (includes libnvme):
-
-### Linux
-
-```bash
-# Configure with all features
-meson setup .build
-
-# Or minimal configuration
-meson setup .build \
-    -Djson-c=disabled \
-    -Dopenssl=disabled \
-    -Dtests=false \
-    -Ddocs=false
-
-# Build
-meson compile -C .build
-
-# Install
-sudo meson install -C .build
-```
-
-### Windows
-
-```bash
-# Configure (in Visual Studio Developer Command Prompt)
-meson setup .build
-
-# Build
-meson compile -C .build
-
-# Install (requires admin privileges)
-meson install -C .build
-```
-
-## Common Build Scenarios
-
-### Scenario 1: Development Build (Linux)
-
-Quick build for development with all features:
-
-```bash
-meson setup .build -Dbuildtype=debug
-meson compile -C .build
-```
-
-### Scenario 2: Release Build (Linux)
-
-Optimized build for production:
-
-```bash
-meson setup .build \
-    -Dbuildtype=release \
-    -Ddefault_library=shared \
-    -Djson-c=enabled \
-    -Dopenssl=enabled
-    
-meson compile -C .build
-sudo meson install -C .build
-```
-
-### Scenario 3: Static Binary (Linux)
-
-Single static binary with no dependencies:
-
-```bash
-meson setup .build \
-    -Ddefault_library=static \
-    -Dbuildtype=release \
-    -Djson-c=disabled \
-    -Dopenssl=disabled
-    
-meson compile -C .build
-```
-
-Or use the Makefile wrapper:
-```bash
-make static
-```
-
-### Scenario 4: Cross-Compilation (Linux)
-
-For embedded systems or different architectures:
-
-```bash
-# Create a cross-file (e.g., arm64-cross.txt)
-# Then configure with cross-file
-meson setup .build --cross-file arm64-cross.txt
-
-meson compile -C .build
-```
-
-Example using the build script:
-```bash
-./scripts/build.sh -b release -c gcc -t aarch64 cross
-```
-
-### Scenario 5: Windows DLL Build
-
-Build shared library on Windows:
-
-```bash
-meson setup .build -Ddefault_library=shared
-meson compile -C .build
-```
-
-### Scenario 6: CI/Testing Build
-
-For continuous integration or testing:
-
-```bash
-meson setup .build \
-    -Dtests=true \
-    -Dexamples=true \
-    -Dwarn_level=3
-    
-meson compile -C .build
-meson test -C .build
-```
-
-## Reconfiguring an Existing Build
-
-To change configuration options without starting over:
-
-```bash
-# View current configuration
-meson configure .build
-
-# Change specific options
-meson configure .build -Dtests=false -Ddocs=false
-
-# Rebuild with new configuration
-meson compile -C .build
-```
-
-## Cleaning Build Directory
-
-```bash
-# Clean build artifacts (keeps configuration)
-ninja -C .build clean
-
-# Or completely remove build directory
-rm -rf .build
-```
-
-## Troubleshooting
-
-### Dependency Not Found
-
-If meson reports a missing dependency:
-
-1. Check if it's optional and can be disabled:
-   ```bash
-   meson setup .build -D<dependency>=disabled
-   ```
-
-2. Install the dependency using your package manager
-
-3. Set `PKG_CONFIG_PATH` if installed in non-standard location:
-   ```bash
-   export PKG_CONFIG_PATH=/path/to/pkgconfig:$PKG_CONFIG_PATH
-   ```
-
-### Windows-Specific Issues
-
-#### "bash command not found" or Script Execution Errors
-
-**Problem:** Meson tries to execute a bash script to detect the git version, failing with:
-```
-ERROR: Command `bash C:\Users\...\scripts/meson-vcs-tag.sh ...` failed
-```
-
-**Solution:** Always specify the `-Dversion-tag` option when configuring:
-```powershell
-meson setup .build -Dversion-tag=3.0-a.1 [other options...]
-```
-
-#### "meson: command not found"
-
-**Problem:** Meson is not in the PATH.
-
-**Solution:** Set the PATH to include Python and Scripts directories:
-```powershell
-$env:PATH = "C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312\Scripts;C:\Users\$env:USERNAME\AppData\Local\Programs\Python\Python312;$env:PATH"
-```
-
-Or locate meson using:
-```powershell
-Get-ChildItem -Path "$env:LOCALAPPDATA\Programs\Python" -Recurse -Filter "meson.exe" | Select-Object -First 1 -ExpandProperty FullName
-```
-
-#### "gcc: command not found"
-
-**Problem:** MinGW GCC is not in the PATH.
-
-**Solution:** Add MinGW to PATH. First, locate the installation:
-```powershell
-Get-ChildItem -Path "$env:LOCALAPPDATA\Microsoft\WinGet\Packages" -Filter "*WinLibs*" -Directory
-```
-
-Then add to PATH:
-```powershell
-$env:PATH = "C:\Users\$env:USERNAME\AppData\Local\Microsoft\WinGet\Packages\BrechtSanders.WinLibs.POSIX.UCRT_Microsoft.Winget.Source_8wekyb3d8bbwe\mingw64\bin;$env:PATH"
-```
-
-#### Setting PATH Permanently on Windows
-
-To avoid setting PATH every time:
-
-1. Open System Properties:
-   - Press `Win + X` → System → Advanced system settings
-   - Or search for "Environment Variables" in Start Menu
-
-2. Click "Environment Variables"
-
-3. Under "User variables", select "Path" and click "Edit"
-
-4. Click "New" and add these paths (adjust as needed):
-   - `C:\Users\YourUsername\AppData\Local\Microsoft\WinGet\Packages\BrechtSanders.WinLibs.POSIX.UCRT_Microsoft.Winget.Source_8wekyb3d8bbwe\mingw64\bin`
-   - `C:\Users\YourUsername\AppData\Local\Programs\Python\Python312`
-   - `C:\Users\YourUsername\AppData\Local\Programs\Python\Python312\Scripts`
-
-5. Click OK on all dialogs and restart PowerShell
-
-### General Build Issues
-
-### Minimal Build Requirements
-
-If you have limited dependencies, use this minimal configuration:
-
-```bash
-meson setup .build \
-    -Dnvme=disabled \
-    -Dlibnvme=enabled \
-    -Dtests=false \
-    -Ddocs=false \
-    -Ddocs-build=false \
-    -Dexamples=false \
-    -Djson-c=disabled \
-    -Dopenssl=disabled \
-    -Dkeyutils=disabled \
-    -Dlibdbus=disabled \
-    -Dliburing=disabled
-```
-
-## Additional Resources
-
-- Main README: [README.md](README.md)
-- Meson documentation: https://mesonbuild.com/
-- libnvme documentation: `libnvme/doc/`
-- GitHub Actions CI examples: `.github/workflows/`
diff --git a/ENVIRONMENT.md b/ENVIRONMENT.md
index 40cb116f04..30f928738c 100644
--- a/ENVIRONMENT.md
+++ b/ENVIRONMENT.md
@@ -9,7 +9,7 @@ This guide covers how to set up your development environment for building nvme-c
 **Both Platforms:**
 - Meson >= 0.62.0 (build system)
 - Ninja (build backend) or Samurai (minimal alternative)
-- C compiler (GCC or Clang on Linux, MSVC or MinGW on Windows)
+- C compiler (GCC or Clang on Linux, MinGW with GCC on Windows)
 
 ### Platform-Specific Dependencies
 
@@ -38,17 +38,10 @@ This guide covers how to set up your development environment for building nvme-c
 #### Windows Dependencies
 
 **Required:**
-- MSVC (Visual Studio 2019 or later) OR MinGW-w64 (installed via WinGet)
+- MinGW-w64
 - Meson
 - Ninja
 - Python 3.8+
-- Windows SDK (for Visual Studio builds)
-
-**System Libraries (automatically linked):**
-- ws2_32.lib (Windows Sockets 2)
-- wsock32.lib (Windows Sockets)
-- kernel32.lib (Windows Kernel)
-- iphlpapi.lib (IP Helper API)
 
 **Optional:**
 - OpenSSL >= 3.0.0 (for security features)
@@ -303,7 +296,3 @@ ninja --version
 ```
 
 If any command fails, review the PATH setup instructions above.
-
-## Next Steps
-
-Once your environment is set up, proceed to [BUILD.md](BUILD.md) for instructions on configuring and building nvme-cli and libnvme.

From e6e7f38bcefd0e7fd0437c1c09fb7b816d435dea Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 20 Feb 2026 21:13:01 -0700
Subject: [PATCH 31/83] Added readme describing the Windows port design choices
 and strategies. (#58)

Added a document intended to provide an overview of direction
we've gone with the Windows port, and some background behind some of the
things we've done in the code. This document can be removed before the
actual PR into the upstream project.
---
 WINDOWS-PORT-README.md | 43 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 WINDOWS-PORT-README.md

diff --git a/WINDOWS-PORT-README.md b/WINDOWS-PORT-README.md
new file mode 100644
index 0000000000..bfb5f3dcf1
--- /dev/null
+++ b/WINDOWS-PORT-README.md
@@ -0,0 +1,43 @@
+# Windows Port README
+
+This document outlines some of the design choices and strategies used during the development of Windows support.
+
+## Windows support strategy using MinGW
+
+The mingw-w64 libraries and tools were chosen for the design to provide a more straightforward port to Windows, taking advantage of its headers and libraries and the GNU toolchain, including the gcc compiler. Benefits from this approach include faster turnaround, toolchain compatibility, and fewer code changes, which will help the code be more maintainable.
+
+Installation and configuration of mingw and other tools such as meson, python, perl, and OpenSSL is described in [ENVIRONMENT.md](ENVIRONMENT.md). Meson build configuration is the same on Windows as on Linux.
+
+## Windows build configuration support
+
+The Meson build configuration files have been updated to detect the platform, and configure the build accordingly. Configuration options remain unchanged. On Windows builds, some features are flagged as not supported, and some files are not yet included in the build.
+
+## Platform-specific includes
+
+To reduce preprocessor checks for `_WIN32` throughout the codebase, common platform-specific includes, type definitions, and utility functions are centralized in `platform/linux.h` and `platform/windows.h` under libnvme. Code can include `platform/include.h`, which includes the appropriate platform header based on the target platform.
+
+Some methods, macros, and types used throughout the code lack direct Windows equivalents. Windows-specific implementations and definitions have been added to `platform/windows.h` and `platform/windows.c`.
+
+For types defined by `linux/types.h` on Linux, a new `platform/types.h` was created to define equivalent types for Windows. On Linux, `platform/types.h` simply includes `linux/types.h`. All project includes of `linux/types.h` have been replaced with `platform/types.h`.
+
+## Stubs for currently unsupported methods
+
+To allow compilation while some features remain unsupported on Windows, `windows-stubs.c` files contain stubbed implementations of unsupported methods. As support is added, these stubs are removed. These stub files are temporary and will be phased out as development progresses.
+
+The Meson build configurations determine whether to build using the windows-stub.c files or the standard implementation files based on the target platform.
+
+## Platform-specific method implementation
+
+Many existing implementations work for both Linux and Windows. When platform-specific implementations are needed, we follow this pattern:
+
+- **Header files (.h)**: Method declarations remain unchanged and platform-agnostic.
+- **Windows implementations (filename-windows.c)**: Platform-specific implementations for Windows are placed in files following the naming convention `filename-windows.c` (for example, `ioctl-windows.c`).
+- **Platform-agnostic implementations**: Code that works on both Linux and Windows remains in the existing `.c` file.
+- **Linux-specific implementations**: Linux-only code remains in the existing `.c` file within `#ifndef _WIN32` guards. Eventually, we plan to extract these into separate `filename-linux.c` files. For now, keeping them inline simplifies upstream merging and ensures we don't miss method updates from the main project.
+- **Build configuration**: The Meson build configuration determines which implementation files to include in the build based on the target platform.
+
+Some Windows methods behave differently than their Linux counterparts and require project-specific implementations. Examples include `fstat` and `free`. We created wrapper methods such as `nvme_fstat` and `nvme_free` with platform-specific implementations to provide platform-agnostic interfaces throughout the codebase.
+
+### The linux.h / linux.c exception
+
+The files `nvme/linux.h` and `nvme/linux.c` present a problem for the pattern described above. Although the file names suggests that the methods they implement are Linux-specific, they are actually utility methods that are needed for both Linux and Windows implementations, and many of the existing implementations are compitible with Windows using MinGW. For now, a new file named `nvme/windows.c` contains the Windows-specific implementations of methods declared in `nvme/linux.h`, breaking with the pattern. Re-evaluation of the linux.h / linux.c names is needed.
\ No newline at end of file

From d92c0cb5a0e1124830cfb2a36263d8b15b1c75a6 Mon Sep 17 00:00:00 2001
From: Brandon Capener <bcapener@micron.com>
Date: Thu, 26 Feb 2026 09:12:34 -0700
Subject: [PATCH 32/83] Update build files to align better with master (#62)

This aligns our meson.build files to be more inline with master, this
should reduce merge conflicts. Some of these changes were made to better
align with the PR we plan to push to upstream master, see
https://github.com/Micron-TPG/nvme-cli/pull/61
---
 libnvme/doc/meson.build      |   1 +
 libnvme/examples/meson.build |   4 +-
 libnvme/src/meson.build      |  25 ++--
 libnvme/src/nvme/meson.build | 124 ++++++++---------
 libnvme/test/meson.build     |  27 ++--
 meson.build                  | 257 ++++++++++++++++-------------------
 plugins/meson.build          |   2 -
 7 files changed, 208 insertions(+), 232 deletions(-)

diff --git a/libnvme/doc/meson.build b/libnvme/doc/meson.build
index b81222c1e1..f437db1e92 100644
--- a/libnvme/doc/meson.build
+++ b/libnvme/doc/meson.build
@@ -60,6 +60,7 @@ if is_windows
     endif
 else
     kernel_doc_check = find_program(top_source_dir +'scripts/kernel-doc-check')
+
     test('libnvme - kdoc', kernel_doc_check, args: api_paths)
 endif
 
diff --git a/libnvme/examples/meson.build b/libnvme/examples/meson.build
index 0d6ba683a1..aea3a543d0 100644
--- a/libnvme/examples/meson.build
+++ b/libnvme/examples/meson.build
@@ -6,7 +6,7 @@
 # Authors: Martin Belanger <Martin.Belanger@dell.com>
 #
 
-# Skip examples on Windows for now due to missing err.h and other incompatibilities
+# Skip examples on Windows for now.
 if not is_windows
 
 executable(
@@ -93,4 +93,4 @@ if libdbus_dep.found()
     )
 endif
 
-endif # Windows exclusion
+endif # not is_windows
diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index ebb20a1afd..2beff9bdb0 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -16,9 +16,7 @@ sources = [
     'nvme/util.c',
 ]
 
-# Platform-specific sources
 if is_windows
-    # Windows-specific sources (exclude Linux networking, fabrics, and filesystem code)
     sources += [
         'nvme/ioctl-windows.c',  # Windows stubs for Linux-specific ioctl functions
         'nvme/windows.c',  # Windows implementations of linux.h functions
@@ -26,7 +24,6 @@ if is_windows
         'platform/windows.c',  # POSIX compatibility implementations
     ]
 else
-    # Linux-specific sources (include networking and fabrics support)
     sources += [
         'nvme/fabrics.c',
         'nvme/filters.c',
@@ -50,25 +47,19 @@ deps = [
     ccan_dep,
     json_c_dep,
     keyutils_dep,
-    libdbus_dep,
-    liburing_dep,
     openssl_dep,
+    accessors_dep,
 ]
-
-# Skipping accessor generation for now on Windows. Needs to be ported.
-if not is_windows
+if is_windows
     deps += [
-        accessors_dep,
+        ws2_32_dep,
+        kernel32_dep,
+        bcrypt_dep,
     ]
-endif
-
-# Add Windows-specific networking libraries
-if is_windows
+else
     deps += [
-        cc.find_library('ws2_32'),
-        cc.find_library('wsock32'),
-        cc.find_library('iphlpapi'),
-        cc.find_library('bcrypt'),  # For BCryptGenRandom in nvme_uuid_random
+        libdbus_dep,
+        liburing_dep,
     ]
 endif
 
diff --git a/libnvme/src/nvme/meson.build b/libnvme/src/nvme/meson.build
index 82252a853d..bb88787037 100644
--- a/libnvme/src/nvme/meson.build
+++ b/libnvme/src/nvme/meson.build
@@ -7,72 +7,72 @@
 #
 # Run generate-accessors to generate the setter/getter functions.
 
-# Skip for now on Windows.  Accessor generation needs to be ported.
-if not is_windows
-
-generated_h = 'accessors.h'
-generated_c = 'accessors.c'
-generated_ld = 'accessors.ld'
+if is_windows
+    # Skip for now on Windows.  Accessor generation needs to be ported.
+    accessors_dep = dependency('', required: false)
+else
+    generated_h = 'accessors.h'
+    generated_c = 'accessors.c'
+    generated_ld = 'accessors.ld'
 
-# List of header files to parse for structs
-headers_to_scan = [
-    '../nvme/private.h',
-]
+    # List of header files to parse for structs
+    headers_to_scan = [
+        '../nvme/private.h',
+    ]
 
-# Build the code generator tool
-generate_accessors = executable(
-    'generate-accessors',
-    'generate-accessors.c',
-    c_args: ['-D_GNU_SOURCE'],
-    dependencies: [
-        config_dep,
-    ],
-    native: true,
-)
+    # Build the code generator tool
+    generate_accessors = executable(
+        'generate-accessors',
+        'generate-accessors.c',
+        c_args: ['-D_GNU_SOURCE'],
+        dependencies: [
+            config_dep,
+        ],
+        native: true,
+    )
 
-# Generate accessors code
-accessors_ch_custom_tgt = custom_target(
-    'accessors[.c.h.ld]',
-    input: files(headers_to_scan),
-    output: [
-        generated_h,
-        generated_c,
-        generated_ld,
-    ],
-    command: [
-        generate_accessors,
-        '--h-out', '@OUTPUT0@',
-        '--c-out', '@OUTPUT1@',
-        '--ld-out', '@OUTPUT2@',
-        '--incl', join_paths(meson.current_source_dir(), 'structs-to-include.txt'),
-        '@INPUT@',
-    ],
-    build_by_default: true,
-    install: true,
-    install_dir: [
-        get_option('includedir') / 'nvme',
-        false,
-        false,
-    ],
-    install_mode: 'rw-r--r--',
-)
+    # Generate accessors code
+    accessors_ch_custom_tgt = custom_target(
+        'accessors[.c.h.ld]',
+        input: files(headers_to_scan),
+        output: [
+            generated_h,
+            generated_c,
+            generated_ld,
+        ],
+        command: [
+            generate_accessors,
+            '--h-out', '@OUTPUT0@',
+            '--c-out', '@OUTPUT1@',
+            '--ld-out', '@OUTPUT2@',
+            '--incl', join_paths(meson.current_source_dir(), 'structs-to-include.txt'),
+            '@INPUT@',
+        ],
+        build_by_default: true,
+        install: true,
+        install_dir: [
+            get_option('includedir') / 'nvme',
+            false,
+            false,
+        ],
+        install_mode: 'rw-r--r--',
+    )
 
-tgt_accessors_h = accessors_ch_custom_tgt[0]
-tgt_accessors_c = accessors_ch_custom_tgt[1]
-tgt_accessors_ld = accessors_ch_custom_tgt[2]
+    tgt_accessors_h = accessors_ch_custom_tgt[0]
+    tgt_accessors_c = accessors_ch_custom_tgt[1]
+    tgt_accessors_ld = accessors_ch_custom_tgt[2]
 
-accessors_dep = declare_dependency(
-    sources: [
-        tgt_accessors_c,
-        tgt_accessors_h,
-    ],
-    include_directories: '.',
-)
+    accessors_dep = declare_dependency(
+        sources: [
+            tgt_accessors_c,
+            tgt_accessors_h,
+        ],
+        include_directories: '.',
+    )
 
-if meson.version().version_compare('>=1.4.0')
-    accessors_ld_full_path = tgt_accessors_ld.full_path()
-else
-    accessors_ld_full_path = meson.current_build_dir() / generated_ld
+    if meson.version().version_compare('>=1.4.0')
+        accessors_ld_full_path = tgt_accessors_ld.full_path()
+    else
+        accessors_ld_full_path = meson.current_build_dir() / generated_ld
+    endif
 endif
-
-endif
\ No newline at end of file
diff --git a/libnvme/test/meson.build b/libnvme/test/meson.build
index 7c28527644..1a6d58aad5 100644
--- a/libnvme/test/meson.build
+++ b/libnvme/test/meson.build
@@ -45,18 +45,6 @@ if cxx_available
 
 endif
 
-uuid = executable(
-    'test-uuid',
-    ['uuid.c'],
-    dependencies: [
-        config_dep,
-        ccan_dep,
-        libnvme_dep,
-    ],
-)
-
-test('libnvme - uuid', uuid)
-
 if not is_windows
     register = executable(
         'test-register',
@@ -101,7 +89,21 @@ if not is_windows
     )
 
     test('libnvme - mi-mctp', mi_mctp)
+endif # not is_windows
 
+uuid = executable(
+    'test-uuid',
+    ['uuid.c'],
+    dependencies: [
+        config_dep,
+        ccan_dep,
+        libnvme_dep,
+    ],
+)
+
+test('libnvme - uuid', uuid)
+
+if not is_windows
     uriparser = executable(
         'test-uriparser',
         ['uriparser.c'],
@@ -177,4 +179,5 @@ if not is_windows
             dependencies: openssl_dep,
         )
     endif
+
 endif # not is_windows
diff --git a/meson.build b/meson.build
index 2209d16b40..06bbe1d604 100644
--- a/meson.build
+++ b/meson.build
@@ -23,7 +23,6 @@ project(
     default_options: [
         'c_std=gnu99',
         'buildtype=debugoptimized',
-        'prefix=/usr/local',
         'warning_level=1',
         'sysconfdir=etc',
         'wrap_mode=nofallback',
@@ -34,6 +33,7 @@ fs = import('fs')
 
 cc = meson.get_compiler('c')
 cxx_available = add_languages('cpp', required: false, native: false)
+is_windows = host_machine.system() == 'windows'
 
 ################################################################################
 # Determine which features we need to build: The nvme executable, the libnvme
@@ -55,7 +55,7 @@ want_docs = get_option('docs')
 want_docs_build = get_option('docs-build')
 
 feature_python = get_option('python')
-if feature_python.disabled()
+if is_windows or feature_python.disabled()
     py3_dep = dependency('', required: false)  # Needed for muon
     want_python = false
 else
@@ -96,10 +96,7 @@ endif
 
 ################################################################################
 prefixdir      = get_option('prefix')
-bindir         = join_paths(prefixdir, get_option('bindir'))
 datadir        = join_paths(prefixdir, get_option('datadir'))
-includedir     = join_paths(prefixdir, get_option('includedir'))
-libdir         = join_paths(prefixdir, get_option('libdir'))
 mandir         = join_paths(prefixdir, get_option('mandir'))
 sbindir        = join_paths(prefixdir, get_option('sbindir'))
 sysconfdir     = join_paths(prefixdir, get_option('sysconfdir'))
@@ -114,134 +111,53 @@ std_prefix = prefixdir == '/usr' or prefixdir == '/usr/local'
 conf = configuration_data()
 requires = ''
 
-# Windows platform detection and configuration
-is_windows = host_machine.system() == 'windows'
-
 version_tag = get_option('version-tag')
 if version_tag != ''
     conf.set('GIT_VERSION', '"@0@"'.format(version_tag))
 else
-    if is_windows
-        r = run_command(
-            'powershell', '-File', 'scripts/meson-vcs-tag.ps1',
-            meson.current_source_dir(),
-            meson.project_version(),
-            check: true,
-        )
-    else
-        r = run_command(
-            'scripts/meson-vcs-tag.sh',
-            meson.current_source_dir(),
-            meson.project_version(),
-            check: true,
-        )
-    endif
+    windows_vcs_cmd = ['powershell', '-File', 'scripts/meson-vcs-tag.ps1']
+    linux_vcs_cmd = 'scripts/meson-vcs-tag.sh'
+    r = run_command(
+        is_windows ? windows_vcs_cmd : linux_vcs_cmd,
+        meson.current_source_dir(),
+        meson.project_version(),
+        check: true,
+    )
     conf.set('GIT_VERSION', '"@0@"'.format(r.stdout().strip()))
 endif
 
 conf.set('SYSCONFDIR', '"@0@"'.format(sysconfdir))
 conf.set('RUNDIR', '"@0@"'.format(rundir))
-  
-################################################################################
-# Windows-specific dependency handling
+
 if is_windows
-    # Disable Linux-specific dependencies on Windows
-    json_c_dep = dependency('', required: false)
-    liburing_dep = dependency('', required: false)
-    keyutils_dep = dependency('', required: false)
-    libdbus_dep = dependency('', required: false)
-    
-    # Find Windows system libraries
     ws2_32_dep = cc.find_library('ws2_32', required: true)
-    wsock32_dep = cc.find_library('wsock32', required: true)
     kernel32_dep = cc.find_library('kernel32', required: true)
-    iphlpapi_dep = cc.find_library('iphlpapi', required: true)
+    bcrypt_dep = cc.find_library('bcrypt', required: true)  # For BCryptGenRandom in nvme_uuid_random
+endif
+
+# Check for libjson-c availability
+if is_windows or get_option('json-c').disabled()
+    json_c_dep = dependency('', required: false)
 else
-    # Linux dependency detection
-    if get_option('json-c').disabled()
-        json_c_dep = dependency('', required: false)
-    else
-        json_c_dep = dependency(
-            'json-c',
-            required: get_option('json-c'),
-            version: '>=0.13',
-            fallback : ['json-c', 'json_c_dep'])
-    endif
+    json_c_dep = dependency(
+        'json-c',
+        required: get_option('json-c'),
+        version: '>=0.13',
+        fallback : ['json-c', 'json_c_dep'],
+    )
     if json_c_dep.version().version_compare('>=0.14')
         conf.set('CONFIG_JSONC_14', true, description: 'Is json-c at least 0.14?')
         requires = 'Requires: json-c >= 0.14'
     else
         requires = 'Requires: json-c >= 0.13'
     endif
-
-    if get_option('liburing').disabled()
-        liburing_dep = dependency('', required: false)
-    else
-        liburing_dep = dependency('liburing', version: '>=2.2', required: get_option('liburing'))
-    endif
-
-    if get_option('keyutils').disabled()
-        keyutils_dep = dependency('', required: false)
-    else
-        keyutils_dep = dependency('libkeyutils',
-                                  required : get_option('keyutils'))
-    endif
-
-    if get_option('libdbus').disabled()
-        libdbus_dep = dependency('', required: false)
-    else
-        # Check for libdbus availability. Optional, only required for MCTP dbus scan
-
-        libdbus_dep = dependency(
-            'dbus-1',
-            required: true,
-            fallback: ['dbus', 'libdbus_dep'],
-            default_options: [
-                'default_library=static',
-                'embedded_tests=false',
-                'message_bus=false',
-                'modular_tests=disabled',
-                'tools=false',
-            ],
-        )
-    endif
-    
-    # Initialize Windows dependencies as empty for Linux
-    ws2_32_dep = dependency('', required: false)
-    wsock32_dep = dependency('', required: false)
-    kernel32_dep = dependency('', required: false)
-    iphlpapi_dep = dependency('', required: false)
 endif
+conf.set('CONFIG_JSONC', json_c_dep.found(), description: 'Is json-c available?')
 
 conf.set('NVME_VERSION', '"@0@"'.format(meson.project_version()))
 conf.set('LIBNVME_VERSION', '"@0@"'.format(meson.project_version()))
-conf.set('CONFIG_JSONC', json_c_dep.found(), description: 'Is json-c available?')
-conf.set10('DEFAULT_PDC_ENABLED', get_option('pdc-enabled'))
 
-# OpenSSL is supported on both platforms
-if get_option('openssl').disabled()
-  openssl_dep = dependency('', required: false)
-else
-  openssl_dep = dependency('openssl',
-                           version: '>=3.0.0',
-                           required: get_option('openssl'),
-                           fallback : ['openssl', 'libssl_dep'])
-endif
-if openssl_dep.found()
-  # Test for LibreSSL v3.x with incomplete OpenSSL v3 APIs
-  if openssl_dep.type_name() != 'internal'
-    is_libressl = cc.has_header_symbol('openssl/opensslv.h',
-                                       'LIBRESSL_VERSION_NUMBER',
-                                       dependencies: openssl_dep)
-    has_header = cc.has_header('openssl/core_names.h',
-                               dependencies: openssl_dep)
-    if is_libressl and not has_header
-      openssl_dep = dependency('', required: false)
-    endif
-  endif
-endif
-conf.set('CONFIG_OPENSSL', openssl_dep.found(),
-         description: 'Is OpenSSL/LibreSSL available?')
+conf.set10('DEFAULT_PDC_ENABLED', get_option('pdc-enabled'))
 
 # Windows-specific compiler flags
 if is_windows
@@ -377,8 +293,68 @@ else
     conf.set('fallthrough', 'do {} while (0) /* fallthrough */')
 endif
 
+
+if is_windows or get_option('liburing').disabled()
+    liburing_dep = dependency('', required: false)
+else
+    liburing_dep = dependency('liburing', version: '>=2.2', required: get_option('liburing'))
+endif
 conf.set('CONFIG_LIBURING', liburing_dep.found(), description: 'Is liburing available?')
+
+if get_option('openssl').disabled()
+    openssl_dep = dependency('', required: false)
+else
+    openssl_dep = dependency(
+        'openssl',
+        version: '>=3.0.0',
+        required: get_option('openssl'),
+        fallback : ['openssl', 'libssl_dep'],
+    )
+endif
+if openssl_dep.found()
+    # Test for LibreSSL v3.x with incomplete OpenSSL v3 APIs
+    if openssl_dep.type_name() != 'internal'
+        is_libressl = cc.has_header_symbol(
+            'openssl/opensslv.h',
+            'LIBRESSL_VERSION_NUMBER',
+            dependencies: openssl_dep,
+        )
+        has_header = cc.has_header(
+            'openssl/core_names.h',
+            dependencies: openssl_dep,
+        )
+        if is_libressl and not has_header
+            openssl_dep = dependency('', required: false)
+        endif
+    endif
+endif
+conf.set('CONFIG_OPENSSL', openssl_dep.found(), description: 'Is OpenSSL/LibreSSL available?')
+
+if is_windows or get_option('keyutils').disabled()
+    keyutils_dep = dependency('', required: false)
+else
+    keyutils_dep = dependency('libkeyutils', required : get_option('keyutils'))
+endif
 conf.set('CONFIG_KEYUTILS', keyutils_dep.found(), description: 'Is libkeyutils available?')
+
+if is_windows or get_option('libdbus').disabled()
+    libdbus_dep = dependency('', required: false)
+else
+    # Check for libdbus availability. Optional, only required for MCTP dbus scan
+    libdbus_dep = dependency(
+        'dbus-1',
+        required: true,
+        fallback: ['dbus', 'libdbus_dep'],
+        default_options: [
+            'default_library=static',
+            'embedded_tests=false',
+            'message_bus=false',
+            'modular_tests=disabled',
+            'tools=false',
+        ],
+    )
+endif
+
 conf.set('CONFIG_DBUS', libdbus_dep.found(), description: 'Enable dbus support?')
 
 conf.set10(
@@ -404,16 +380,16 @@ conf.set10(
 is_static = get_option('default_library') == 'static'
 have_netdb = false
 if not is_static and not is_windows
-  have_netdb = cc.links(
-      '''#include <sys/types.h>
-         #include <sys/socket.h>
-         #include <netdb.h>
-         int main(int argc, char **argv) {
-             struct addrinfo hints, *result;
-             return getaddrinfo(argv[1], argv[2], &hints, &result);
-      }
-      ''',
-      name: 'netdb',
+    have_netdb = cc.links(
+        '''#include <sys/types.h>
+        #include <sys/socket.h>
+        #include <netdb.h>
+        int main(int argc, char **argv) {
+            struct addrinfo hints, *result;
+            return getaddrinfo(argv[1], argv[2], &hints, &result);
+        }
+        ''',
+        name: 'netdb',
     )
 endif
 conf.set(
@@ -482,7 +458,6 @@ if libtype == 'static'
     requires = ''
 endif
 
-################################################################################
 substs = configuration_data()
 substs.set('VERSION', meson.project_version())
 substs.set('NVMECLI_LICENSE', meson.project_license()[0])
@@ -520,14 +495,15 @@ if want_nvme
         'libnvme-wrap.c',
         'logging.c',
     ]
-    # fabrics.c and nvme-rpmb.c use Linux-specific libnvme functionality
-    if not is_windows
-        sources += ['fabrics.c', 'nvme-rpmb.c']
-    endif
     if is_windows
         sources += [
             'windows-stubs.c',
         ]
+    else
+        sources += [
+            'fabrics.c',
+            'nvme-rpmb.c',
+        ]
     endif
     if json_c_dep.found()
         sources += [
@@ -544,11 +520,14 @@ if want_nvme
         libnvme_dep,
         json_c_dep,
     ]
-    
-    if not is_windows
-        link_args_list = ['-ldl']
+
+    if is_windows
+        link_deps += [
+            ws2_32_dep,
+            kernel32_dep,
+        ]
     else
-        link_deps += [ws2_32_dep, wsock32_dep, kernel32_dep, iphlpapi_dep]
+        link_args_list = ['-ldl']
     endif
 
     executable(
@@ -660,16 +639,20 @@ path_dict = {
 summary(path_dict, section: 'Paths')
 
 dep_dict = {
-    'json-c':               json_c_dep.found(),
-    'OpenSSL':              openssl_dep.found(),
-    'keyutitls':            keyutils_dep.found(),
-    'libdbus':              libdbus_dep.found(),
-    'python3':              py3_dep.found(),
-    'liburing':             liburing_dep.found(),
-    'Windows (ws2_32)':     ws2_32_dep.found(),
-    'Windows (kernel32)':   kernel32_dep.found(),
-    'Windows (iphlpapi)':   iphlpapi_dep.found(),
+    'json-c':           json_c_dep.found(),
+    'OpenSSL':          openssl_dep.found(),
+    'keyutils':         keyutils_dep.found(),
+    'libdbus':          libdbus_dep.found(),
+    'python3':          py3_dep.found(),
+    'liburing':         liburing_dep.found(),
 }
+if is_windows
+    dep_dict += {
+        'ws2_32':       ws2_32_dep.found(),
+        'kernel32':     kernel32_dep.found(),
+        'bcrypt':       bcrypt_dep.found(),
+    }
+endif
 summary(dep_dict, section: 'Dependencies', bool_yn: true)
 
 wanted_dict = {
diff --git a/plugins/meson.build b/plugins/meson.build
index 269a54f5ee..a52ffd7cd5 100644
--- a/plugins/meson.build
+++ b/plugins/meson.build
@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-# Plugins that work on all platforms
 plugin_sources = [
     'plugins/amzn/amzn-nvme.c',
     'plugins/dapustor/dapustor-nvme.c',
@@ -23,7 +22,6 @@ plugin_sources = [
     'plugins/virtium/virtium-nvme.c',
 ]
 
-# Plugins with Linux-specific dependencies - exclude on Windows
 if not is_windows
     plugin_sources += [
         'plugins/huawei/huawei-nvme.c',

From c99cfde8975d35d714ec822a6336aa80e6913ebc Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Mon, 2 Mar 2026 16:32:33 -0700
Subject: [PATCH 33/83] Added WinPE implementations for supported commands.
 (#64)

Some commands are only supported on WinPE, and some are supported
differently. Added detection of WinPE and handling of WinPE-specific
behavior.
---
 libnvme/src/nvme/ioctl-windows.c | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/libnvme/src/nvme/ioctl-windows.c b/libnvme/src/nvme/ioctl-windows.c
index 8da517729e..17d000dbe5 100644
--- a/libnvme/src/nvme/ioctl-windows.c
+++ b/libnvme/src/nvme/ioctl-windows.c
@@ -74,6 +74,24 @@ static int get_errno_from_storage_protocol_status(DWORD status)
 	}
 }
 
+static bool get_is_win_pe(void)
+{
+	HKEY key;
+	LONG rc = RegOpenKeyExW(
+		HKEY_LOCAL_MACHINE,
+		L"SYSTEM\\CurrentControlSet\\Control\\MiniNT",
+		0,
+		KEY_READ,
+		&key
+	);
+
+	if (rc == ERROR_SUCCESS) {
+		RegCloseKey(key);
+		return true;
+	}
+	return false;
+}
+
 int nvme_subsystem_reset(struct nvme_transport_handle *hdl)
 {
 	(void)hdl;
@@ -1018,6 +1036,10 @@ static int nvme_submit_admin_format_nvm(struct nvme_transport_handle *hdl,
 {
 	__u8 ses;
 
+	/* For WinPE, use storage protocol command. */
+	if (get_is_win_pe())
+		return nvme_submit_storage_protocol_command(hdl, cmd);
+
 	/* Namespace-specific format is not supported on Windows */
 	if (cmd->nsid != NVME_NSID_ALL)
 		return -ENOTSUP;
@@ -1203,6 +1225,13 @@ int nvme_submit_admin_passthru(struct nvme_transport_handle *hdl,
 		return nvme_submit_admin_set_features(hdl, cmd);
 	case nvme_admin_get_features:
 		return nvme_submit_admin_get_features(hdl, cmd);
+	case nvme_admin_ns_mgmt:
+	case nvme_admin_ns_attach:
+		/* Only supported on WinPE */
+		if (get_is_win_pe())
+			return nvme_submit_storage_protocol_command(hdl, cmd);
+		else
+			return -ENOTSUP;
 	case nvme_admin_fw_commit:
 		return nvme_submit_admin_fw_commit(hdl, cmd);
 	case nvme_admin_fw_download:

From 0be3d6e7558a77aef441874ae290c6b9371c1bab Mon Sep 17 00:00:00 2001
From: Brandon Capener <bcapener@micron.com>
Date: Wed, 4 Mar 2026 15:39:27 -0700
Subject: [PATCH 34/83] Revert use of powershell (#68)

Now that we are using msys2 we have access to bash, so reverting use of
powershell scripts.
---
 libnvme/doc/meson.build              | 14 ++--------
 libnvme/scripts/kernel-doc-check.ps1 | 28 -------------------
 meson.build                          |  4 +--
 scripts/meson-vcs-tag.ps1            | 41 ----------------------------
 4 files changed, 3 insertions(+), 84 deletions(-)
 delete mode 100644 libnvme/scripts/kernel-doc-check.ps1
 delete mode 100644 scripts/meson-vcs-tag.ps1

diff --git a/libnvme/doc/meson.build b/libnvme/doc/meson.build
index f437db1e92..df0d92f3d9 100644
--- a/libnvme/doc/meson.build
+++ b/libnvme/doc/meson.build
@@ -50,19 +50,9 @@ subdir('rst')
 top_source_dir = meson.current_source_dir() + '/../'
 
 kernel_doc = find_program(top_source_dir + 'scripts/kernel-doc')
+kernel_doc_check = find_program(top_source_dir +'scripts/kernel-doc-check')
 
-if is_windows
-    powershell = find_program('powershell', required: false)
-    if powershell.found()
-        kernel_doc_check_script = top_source_dir + 'scripts/kernel-doc-check.ps1'
-        test('libnvme - kdoc', powershell,
-             args: ['-ExecutionPolicy', 'Bypass', '-File', kernel_doc_check_script] + api_paths)
-    endif
-else
-    kernel_doc_check = find_program(top_source_dir +'scripts/kernel-doc-check')
-
-    test('libnvme - kdoc', kernel_doc_check, args: api_paths)
-endif
+test('libnvme - kdoc', kernel_doc_check, args: api_paths)
 
 if want_docs != 'false'
     if want_docs == 'all' or want_docs == 'man'
diff --git a/libnvme/scripts/kernel-doc-check.ps1 b/libnvme/scripts/kernel-doc-check.ps1
deleted file mode 100644
index 7988f7bb8a..0000000000
--- a/libnvme/scripts/kernel-doc-check.ps1
+++ /dev/null
@@ -1,28 +0,0 @@
-
-# SPDX-License-Identifier: LGPL-2.1-or-later
-
-$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
-$kernelDoc = Join-Path $scriptDir "kernel-doc"
-
-# Check if perl is available
-$perl = Get-Command perl -ErrorAction SilentlyContinue
-if (-not $perl) {
-    Write-Error "Perl is not installed or not in PATH."
-    exit 1
-}
-
-# Run kernel-doc and capture output and exit code
-$output = & perl $kernelDoc -none $args 2>&1
-$kernelDocExitCode = $LASTEXITCODE
-
-# Filter for warnings and errors
-$filtered = $output | Select-String -Pattern '(warning|error)'
-
-# Check that kernel-doc succeeded (exit code 0) and no warnings/errors were found
-if ($kernelDocExitCode -eq 0 -and $filtered.Count -eq 0) {
-    exit 0
-} else {
-    # Print any warnings/errors found
-    $filtered | ForEach-Object { Write-Host $_ }
-    exit 1
-}
diff --git a/meson.build b/meson.build
index 9b0829c7b3..9c2427534a 100644
--- a/meson.build
+++ b/meson.build
@@ -116,10 +116,8 @@ version_tag = get_option('version-tag')
 if version_tag != ''
     conf.set('GIT_VERSION', '"@0@"'.format(version_tag))
 else
-    windows_vcs_cmd = ['powershell', '-File', 'scripts/meson-vcs-tag.ps1']
-    linux_vcs_cmd = 'scripts/meson-vcs-tag.sh'
     r = run_command(
-        is_windows ? windows_vcs_cmd : linux_vcs_cmd,
+        'scripts/meson-vcs-tag.sh',
         meson.current_source_dir(),
         meson.project_version(),
         check: true,
diff --git a/scripts/meson-vcs-tag.ps1 b/scripts/meson-vcs-tag.ps1
deleted file mode 100644
index 09da8f512d..0000000000
--- a/scripts/meson-vcs-tag.ps1
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/usr/bin/env pwsh
-# SPDX-License-Identifier: LGPL-2.1-or-later
-
-param(
-    [Parameter(Mandatory=$true, Position=0)]
-    [string]$Directory,
-
-    [Parameter(Mandatory=$true, Position=1)]
-    [string]$Fallback
-)
-
-$ErrorActionPreference = "Stop"
-
-# Apparently git describe has a bug where it always considers the work-tree
-# dirty when invoked with --git-dir (even though 'git status' is happy). Work
-# around this issue by cd-ing to the source directory.
-Push-Location $Directory
-
-try {
-    # Check that we have either .git/ (a normal clone) or a .git file (a work-tree)
-    # and that we don't get confused if a tarball is extracted in a higher-level
-    # git repository.
-    if (Test-Path ".git") {
-        try {
-            $version = git describe --abbrev=7 --dirty=+ 2>&1
-            if ($LASTEXITCODE -eq 0) {
-                # Remove leading 'v' if present
-                $version = $version -replace '^v', ''
-                Write-Output $version
-            } else {
-                Write-Output $Fallback
-            }
-        } catch {
-            Write-Output $Fallback
-        }
-    } else {
-        Write-Output $Fallback
-    }
-} finally {
-    Pop-Location
-}

From b1180306f580b0dfae35c33ffb20df0e1173b83e Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Wed, 4 Mar 2026 15:41:04 -0700
Subject: [PATCH 35/83] Adding .github/copilot-instructions.md (#66)

Adding copilot-instructions.md to our internal repository for use by
all developers and agents.
---
 .github/copilot-instructions.md | 234 ++++++++++++++++++++++++++++++++
 .gitignore                      |   1 -
 2 files changed, 234 insertions(+), 1 deletion(-)
 create mode 100644 .github/copilot-instructions.md

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 0000000000..9d1cb78184
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,234 @@
+# nvme-cli Codebase Guide for AI Agents
+
+## Project Overview
+
+nvme-cli is a cross-platform NVMe management utility (Linux/Windows) with an integrated libnvme library (v3.x+). The project uses Meson build system and supports an extensible plugin architecture for vendor-specific commands.
+
+**Critical:** Starting with nvme-cli 3.x, libnvme is fully integrated into the source tree at `libnvme/` - there's no external dependency.
+
+## Architecture
+
+### Component Structure
+
+- **nvme-cli** (`nvme.c`, `nvme-builtin.h`): Main CLI tool with built-in NVMe commands
+- **libnvme** (`libnvme/src/nvme/`): Cross-platform NVMe library with OS-specific ioctl implementations
+  - `ioctl.c` (Linux), `ioctl-windows.c` (Windows)
+- **Plugins** (`plugins/*/`): Vendor-specific extensions (OCP, WDC, Intel, Solidigm, etc.)
+- **Utilities** (`util/`): Shared helpers (argument parsing, formatting, cleanup)
+
+### Command Registration Pattern
+
+Commands use a macro-based registration system via `define_cmd.h`:
+
+1. **Built-in commands** (`nvme-builtin.h`):
+   ```c
+   COMMAND_LIST(
+       ENTRY("list", "List all NVMe devices", list)
+       ENTRY("id-ctrl", "Send Identify Controller", id_ctrl)
+   )
+   ```
+
+2. **Plugin commands** (e.g., `plugins/ocp/ocp-nvme.h`):
+   ```c
+   PLUGIN(NAME("ocp", "OCP cloud SSD extensions", OCP_PLUGIN_VERSION),
+       COMMAND_LIST(
+           ENTRY("smart-add-log", "Retrieve extended SMART", smart_add_log)
+       )
+   )
+   ```
+
+Commands are invoked as: `nvme <command>` (built-in) or `nvme <plugin> <command>` (plugin).
+
+### Cross-Platform Abstraction
+
+- **Platform detection**: Use Meson's `build_machine.system()` checks
+- **OS-specific code**: Separate implementations in `libnvme/src/nvme/ioctl-*.c`
+- **Windows quirks**: 
+  - Network libraries (ws2_32, wsock32, iphlpapi) auto-linked on Windows
+  - Linux-only features (json-c, liburing, keyutils) auto-disabled on Windows
+
+## Build System (Meson)
+
+### Standard Build Commands
+
+**Linux:**
+```bash
+meson setup .build
+meson compile -C .build
+meson install -C .build
+```
+
+**Windows (MSYS2):**
+```bash
+meson setup .build
+meson compile -C .build
+meson install -C .build
+```
+
+**Windows (PowerShell):**
+```powershell
+meson setup .build
+meson compile -C .build
+```
+
+### Key Build Options
+
+- `-Dnvme=enabled|disabled` - Build nvme CLI (default: enabled)
+- `-Dlibnvme=enabled|disabled` - Build libnvme library (default: enabled)
+- `-Dtests=true|false` - Build tests (default: true)
+- `-Ddefault_library=static|shared` - Library type
+- `-Djson-c=enabled|auto|disabled` - JSON support (required for plugins on Linux)
+
+**Important:** Disabling json-c on Linux disables all plugins.
+
+### Build Configurations
+
+See `scripts/build.sh` for CI configurations:
+- `scripts/build.sh` - Default build
+- `scripts/build.sh fallback` - Download all dependencies
+- `scripts/build.sh static` - Static binary
+- `scripts/build.sh libnvme` - libnvme only
+
+## Development Workflows
+
+### Adding a New Built-in Command
+
+1. Add `ENTRY()` to `nvme-builtin.h`
+2. Implement callback in `nvme.c`:
+   ```c
+   static int my_cmd(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+   ```
+3. Use `argconfig` for option parsing (see existing commands)
+4. Return 0 on success, errno on failure
+
+### Adding a Plugin Command
+
+1. Create plugin header in `plugins/<vendor>/<vendor>-nvme.h`:
+   ```c
+   #undef CMD_INC_FILE
+   #define CMD_INC_FILE plugins/<vendor>/<vendor>-nvme
+   
+   PLUGIN(NAME("<vendor>", "Description", VERSION),
+       COMMAND_LIST(
+           ENTRY("cmd-name", "Description", callback_fn)
+       )
+   )
+   #include "define_cmd.h"
+   ```
+2. Implement commands in `plugins/<vendor>/<vendor>-nvme.c`
+3. Update `plugins/meson.build` to include new plugin
+
+### Testing
+
+Python-based tests in `tests/`:
+- Test framework: `nvme_test.py`, `nvme_test_logger.py`
+- Run with: `meson test -C .build` or `pytest tests/`
+- Tests require real NVMe hardware (controlled by `-Dnvme-tests=true`)
+
+### Windows Development
+
+You're currently working on Windows implementation (`libnvme/src/nvme/ioctl-windows.c`). Key points:
+
+- Use Windows API: `DeviceIoControl()`, `CreateFile()`, etc.
+- Convert Windows errors to errno with helper functions
+- Many Linux features unsupported: reset, rescan, io_uring
+- Test using MinGW builds
+
+## Code Conventions
+
+### Coding Style
+
+**Follow Linux kernel coding style** for all code contributions:
+
+- **Indentation**: Use tabs (not spaces) for indentation, with 8-character tab stops
+- **Line length**: Should not exceed 80 characters with 8-space tabs if possible. This is a soft guideline - readability takes priority, with a hard limit of 100 columns for code.
+- **Bracing**: K&R style - opening brace on same line, closing brace on new line. For conditional statements with single instructions in all branches, do not use braces.
+  ```c
+  // Multiple statements - use braces
+  if (condition) {
+      do_something();
+      do_another_thing();
+  } else {
+      do_something_else();
+  }
+  
+  // Single statement in all branches - no braces
+  if (condition)
+      do_something();
+  else
+      do_something_else();
+  ```
+- **Naming**: 
+  - Functions/variables: lowercase with underscores (`get_smart_log`, `namespace_id`)
+  - Macros/constants: uppercase with underscores (`NVME_LOG_PAGE_SIZE`)
+  - Struct members: lowercase with underscores
+- **Spacing**: Space after keywords (`if (`, `while (`), no space for function calls (`func(`)
+- **Pointer declarations**: Attach asterisk to type name, not variable name: `type *name` not `type* name`
+  ```c
+  int *ptr;           // Correct
+  char *str;          // Correct
+  void *user_data;    // Correct
+  int* ptr;           // Wrong
+  ```
+- **Comments**: Follow these conventions:
+  - **Multi-line block comments**: Use Linux kernel style with `/* */` wrapper and ` * ` prefix:
+    ```c
+    /*
+     * This is a multi-line comment explaining something
+     * with important details across multiple lines.
+     */
+    ```
+  - **Single-line standalone comments**: Use `/* */` format: `/* Single line comment */`
+  - **Inline comments** (end-of-line): Use `/* */` format: `/* Inline comment */`
+  - **TODO comments**: Use C++ style: `// TODO: description`
+  - **SPDX license headers**: Use C++ style: `// SPDX-License-Identifier: ...`
+- **Type declarations**: Prefer kernel types (`__u32`, `__le16`) for hardware structures
+
+See the Linux kernel [coding style documentation](https://www.kernel.org/doc/html/latest/process/coding-style.html) for complete details.
+
+### Commit Messages
+
+Follow Linux kernel style:
+```
+<area>: <short description>
+
+<detailed description>
+
+Signed-off-by: Name <email>
+```
+
+Examples: `nvme: fix buffer overflow`, `ocp: add latency monitor log`
+
+### Error Handling
+
+- Return 0 on success, negative errno on failure
+- Use `nvme_status_to_errno()` for NVMe status codes
+- Log errors with `nvme_show_error()` or `perror()`
+
+### Memory Management
+
+- Use cleanup attributes for auto-cleanup: `_cleanup_(nvme_free_tree)`, `_cleanup_free_`
+- Defined in `util/cleanup.h`
+- Example: `_cleanup_free_ char *buf = malloc(size);`
+
+### Licensing
+
+- nvme-cli: GPL-2.0-or-later (some files GPL-2.0-only)
+- libnvme: LGPL-2.1-or-later
+- Always include SPDX header: `// SPDX-License-Identifier: GPL-2.0-or-later`
+
+## Key Files Reference
+
+- `nvme.c` (11k lines) - Main CLI implementation
+- `nvme-builtin.h` - Built-in command registry
+- `define_cmd.h` - Command macro magic
+- `plugin.c`, `plugin.h` - Plugin infrastructure
+- `ENVIRONMENT.md` - Dependency setup guide
+- `meson.build` - Root build configuration
+
+## Common Pitfalls
+
+1. **Plugins disabled**: Check if json-c is enabled on Linux builds
+2. **Test failures**: Tests require real NVMe hardware and `-Dnvme-tests=true`
+3. **libnvme not found**: In 3.x+, libnvme is integrated - don't install separately
+4. **Wrong command invocation**: Plugins use `nvme <plugin> <cmd>`, not `nvme <cmd>`
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index b8d60e2342..5ce3d1fbe6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,4 +23,3 @@ tests/*.pyc
 dist/
 
 .vscode/
-.github

From c2440365d0aab28c4f44b1896fffa83cc52b3e09 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Thu, 5 Mar 2026 10:24:22 -0700
Subject: [PATCH 36/83] Implemented nvme_submit_io_passthru for Windows. (#65)

Added IO command implementations for commands supported by Windows:
* Flush
* Write
* Read
* Compare (WinPE only)
---
 libnvme/src/nvme/ioctl-windows.c | 396 +++++++++++++++++++++++++++++--
 1 file changed, 370 insertions(+), 26 deletions(-)

diff --git a/libnvme/src/nvme/ioctl-windows.c b/libnvme/src/nvme/ioctl-windows.c
index 17d000dbe5..2315fd271f 100644
--- a/libnvme/src/nvme/ioctl-windows.c
+++ b/libnvme/src/nvme/ioctl-windows.c
@@ -117,14 +117,10 @@ int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
 	return -ENOTSUP;
 }
 
-int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
-{
-	(void)hdl;
-	(void)cmd;
-	return -ENOTSUP;
-}
-
+/*
+ * IOCTL_STORAGE_PROTOCOL_COMMAND pass-through implementation used for
+ * VU commands and a small subset of other admin and IO commands.
+ */
 static int nvme_submit_storage_protocol_command(
 		struct nvme_transport_handle *hdl,
 		struct nvme_passthru_cmd *cmd)
@@ -134,7 +130,7 @@ static int nvme_submit_storage_protocol_command(
 	ULONG returned_len = 0;
 	BOOL result = FALSE;
 	PUCHAR buffer = NULL;
-	void *user_data;
+	void *user_data = NULL;
 	int err = 0;
 	bool is_read = false;
 	bool is_write = false;
@@ -253,6 +249,320 @@ static int nvme_submit_storage_protocol_command(
 	return err;
 }
 
+/*
+ * Windows-specific IO command implementations.
+ */
+
+/* SCSI operation code definitions */
+#define SCSIOP_SYNCHRONIZE_CACHE 0x35
+#define SCSIOP_READ16 0x88
+#define SCSIOP_WRITE16 0x8A
+
+static int nvme_submit_io_flush(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	PSCSI_PASS_THROUGH pass_through = NULL;
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	PUCHAR buffer = NULL;
+	void *user_data = NULL;
+	int err = 0;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	buffer_len = sizeof(SCSI_PASS_THROUGH);
+	buffer = (PUCHAR)malloc(buffer_len);
+	if (!buffer) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(buffer, buffer_len);
+
+	pass_through = (PSCSI_PASS_THROUGH)buffer;
+	pass_through->Length = sizeof(SCSI_PASS_THROUGH);
+	pass_through->CdbLength = 10;
+	pass_through->DataIn = SCSI_IOCTL_DATA_UNSPECIFIED;
+	pass_through->TimeOutValue = (cmd->timeout_ms > 0) ?
+		((cmd->timeout_ms + 999) / 1000) : 30;
+
+	pass_through->Cdb[0] = SCSIOP_SYNCHRONIZE_CACHE;
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+				IOCTL_SCSI_PASS_THROUGH,
+				buffer,
+				buffer_len,
+				buffer,
+				buffer_len,
+				&returned_len,
+				NULL);
+		if (result && !pass_through->ScsiStatus)
+			break;
+
+		if (!result)
+			err = get_last_error_as_errno();
+		else
+			err = -EIO;
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	cmd->result = 0;
+
+out_free_buffer:
+	free(buffer);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+static __u8 nvme_prinfo_to_scsi_wrrdprotect(__u8 prinfo)
+{
+	/*
+	 * From WRPROTECT/RDPROTECT -> PRINFO (PRACT + PRCHK) mapping tables
+	 * in NVM Express: SCSI Translation Reference documentation.
+	 */
+	switch (prinfo) {
+	case 0b0111:
+		return 1;
+	case 0b0011:
+		return 2;
+	case 0b0000:
+		return 3;
+	case 0b0100:
+		return 4;
+	case 0b1000:	/* For Write */
+	case 0b1111:	/* For Read */
+	default:
+		return 0; /* Default to no check */
+	}
+}
+
+/**
+ * fill_scsi_rw16_cdb() - Fill the CDB for a SCSI READ(16) or WRITE(16) command.
+ * @cmd:    NVMe command containing the CDW fields to translate
+ * @cdb:    CDB buffer to fill
+ *
+ * Fills the CDB for a SCSI READ(16) or WRITE(16) command based on the
+ * supported NVMe command fields.
+ *
+ * See NVM Express: SCSI Translation Reference documentation.
+ */
+static void fill_scsi_rw16_cdb(struct nvme_passthru_cmd *cmd, UCHAR cdb[16])
+{
+	__u8 opcode = (cmd->opcode == nvme_cmd_read) ?
+			SCSIOP_READ16 : SCSIOP_WRITE16;
+	__u64 lba = ((__u64)cmd->cdw11 << 32) | cmd->cdw10;
+	__u32 transfer_len = NVME_FIELD_DECODE(cmd->cdw12,
+			NVME_IOCS_COMMON_CDW12_NLB_SHIFT,
+			NVME_IOCS_COMMON_CDW12_NLB_MASK) + 1; /* NLB + 1 */
+	__u8 prinfo = NVME_FIELD_DECODE(cmd->cdw12,
+			NVME_IOCS_COMMON_CDW12_PRINFO_SHIFT,
+			NVME_IOCS_COMMON_CDW12_PRINFO_MASK);
+	__u8 fua = NVME_FIELD_DECODE(cmd->cdw12,
+			NVME_IOCS_COMMON_CDW12_FUA_SHIFT,
+			NVME_IOCS_COMMON_CDW12_FUA_MASK);
+
+	__u8 wrrdprotect = nvme_prinfo_to_scsi_wrrdprotect(prinfo);
+
+	cdb[0] = opcode;
+	cdb[1] = (wrrdprotect << 5) | ((fua & 1) << 3);
+	cdb[2] = (lba >> 56) & 0xFF;
+	cdb[3] = (lba >> 48) & 0xFF;
+	cdb[4] = (lba >> 40) & 0xFF;
+	cdb[5] = (lba >> 32) & 0xFF;
+	cdb[6] = (lba >> 24) & 0xFF;
+	cdb[7] = (lba >> 16) & 0xFF;
+	cdb[8] = (lba >> 8) & 0xFF;
+	cdb[9] = lba & 0xFF;
+	cdb[10] = (transfer_len >> 24) & 0xFF;
+	cdb[11] = (transfer_len >> 16) & 0xFF;
+	cdb[12] = (transfer_len >> 8) & 0xFF;
+	cdb[13] = transfer_len & 0xFF;
+	cdb[14] = 0;
+	cdb[15] = 0;
+}
+
+static int nvme_submit_io_write(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	PSCSI_PASS_THROUGH pass_through = NULL;
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	PUCHAR buffer = NULL;
+	void *user_data = NULL;
+	int err = 0;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	if (cmd->data_len > 0 && !cmd->addr) {
+		err = -EINVAL;
+		goto out;
+	}
+
+	/* Allocate buffer for SCSI_PASS_THROUGH + write payload */
+	buffer_len = sizeof(SCSI_PASS_THROUGH) + cmd->data_len;
+	buffer = (PUCHAR)malloc(buffer_len);
+	if (!buffer) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(buffer, buffer_len);
+
+	pass_through = (PSCSI_PASS_THROUGH)buffer;
+	pass_through->Length = sizeof(SCSI_PASS_THROUGH);
+	pass_through->CdbLength = 16;
+	pass_through->DataIn = SCSI_IOCTL_DATA_OUT;
+	pass_through->DataTransferLength = cmd->data_len;
+	pass_through->TimeOutValue = (cmd->timeout_ms > 0) ?
+		((cmd->timeout_ms + 999) / 1000) : 30;
+	pass_through->DataBufferOffset = sizeof(SCSI_PASS_THROUGH);
+
+	fill_scsi_rw16_cdb(cmd, pass_through->Cdb);
+
+	if (cmd->addr && cmd->data_len > 0) {
+		memcpy(buffer + pass_through->DataBufferOffset,
+			(void *)(uintptr_t)cmd->addr, cmd->data_len);
+	}
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+				IOCTL_SCSI_PASS_THROUGH,
+				buffer,
+				buffer_len,
+				buffer,
+				buffer_len,
+				&returned_len,
+				NULL);
+		if (result && !pass_through->ScsiStatus)
+			break;
+
+		if (!result)
+			err = get_last_error_as_errno();
+		else
+			err = -EIO;
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	cmd->result = 0;
+
+out_free_buffer:
+	free(buffer);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+static int nvme_submit_io_read(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	PSCSI_PASS_THROUGH pass_through = NULL;
+	ULONG buffer_len = 0;
+	ULONG returned_len = 0;
+	BOOL result = FALSE;
+	PUCHAR buffer = NULL;
+	void *user_data = NULL;
+	int err = 0;
+
+	user_data = hdl->submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
+
+	if (hdl->fd == INVALID_HANDLE_VALUE || hdl->fd == NULL) {
+		err = -EBADF;
+		goto out;
+	}
+
+	if (cmd->data_len > 0 && !cmd->addr) {
+		err = -EINVAL;
+		goto out;
+	}
+
+	/* Allocate buffer for SCSI_PASS_THROUGH + read payload */
+	buffer_len = sizeof(SCSI_PASS_THROUGH) + cmd->data_len;
+	buffer = (PUCHAR)malloc(buffer_len);
+	if (!buffer) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	ZeroMemory(buffer, buffer_len);
+
+	pass_through = (PSCSI_PASS_THROUGH)buffer;
+	pass_through->Length = sizeof(SCSI_PASS_THROUGH);
+	pass_through->CdbLength = 16;
+	pass_through->DataIn = SCSI_IOCTL_DATA_IN;
+	pass_through->DataTransferLength = cmd->data_len;
+	pass_through->TimeOutValue = (cmd->timeout_ms > 0) ?
+		((cmd->timeout_ms + 999) / 1000) : 30;
+	pass_through->DataBufferOffset = sizeof(SCSI_PASS_THROUGH);
+
+	fill_scsi_rw16_cdb(cmd, pass_through->Cdb);
+
+	do {
+		err = 0;
+		result = DeviceIoControl(hdl->fd,
+				IOCTL_SCSI_PASS_THROUGH,
+				buffer,
+				buffer_len,
+				buffer,
+				buffer_len,
+				&returned_len,
+				NULL);
+		if (result && !pass_through->ScsiStatus)
+			break;
+
+		if (!result)
+			err = get_last_error_as_errno();
+		else
+			err = -EIO;
+	} while (hdl->decide_retry(hdl, cmd, err));
+
+	if (err)
+		goto out_free_buffer;
+
+	if (cmd->addr && cmd->data_len > 0) {
+		memcpy((void *)(uintptr_t)cmd->addr,
+			buffer + pass_through->DataBufferOffset,
+			min(pass_through->DataTransferLength, cmd->data_len));
+	}
+
+	cmd->result = 0;
+
+out_free_buffer:
+	free(buffer);
+out:
+	hdl->submit_exit(hdl, cmd, err, user_data);
+	return err;
+}
+
+/*
+ * Windows-specific admin command implementations.
+ */
+
 static int nvme_submit_admin_get_log_page(struct nvme_transport_handle *hdl,
 		struct nvme_passthru_cmd *cmd)
 {
@@ -263,9 +573,9 @@ static int nvme_submit_admin_get_log_page(struct nvme_transport_handle *hdl,
 	ULONG returned_len = 0;
 	BOOL result = FALSE;
 	PUCHAR buffer = NULL;
-	__u32 csi;
-	void *user_data;
+	void *user_data = NULL;
 	int err = 0;
+	__u32 csi;
 
 	user_data = hdl->submit_entry(hdl, cmd);
 	if (hdl->ctx->dry_run)
@@ -376,10 +686,10 @@ static int nvme_submit_admin_identify(struct nvme_transport_handle *hdl,
 	ULONG returned_len = 0;
 	BOOL result = FALSE;
 	PUCHAR buffer = NULL;
+	void *user_data = NULL;
+	int err = 0;
 	__u32 cns;
 	__u32 csi;
-	void *user_data;
-	int err = 0;
 
 	user_data = hdl->submit_entry(hdl, cmd);
 	if (hdl->ctx->dry_run)
@@ -486,7 +796,7 @@ static int nvme_submit_admin_set_features(struct nvme_transport_handle *hdl,
 	ULONG returned_len = 0;
 	BOOL result = FALSE;
 	PUCHAR buffer = NULL;
-	void *user_data;
+	void *user_data = NULL;
 	int err = 0;
 
 	user_data = hdl->submit_entry(hdl, cmd);
@@ -577,7 +887,7 @@ static int nvme_submit_admin_get_features(struct nvme_transport_handle *hdl,
 	ULONG returned_len = 0;
 	BOOL result = FALSE;
 	PUCHAR buffer = NULL;
-	void *user_data;
+	void *user_data = NULL;
 	int err = 0;
 
 	user_data = hdl->submit_entry(hdl, cmd);
@@ -708,9 +1018,9 @@ static int nvme_submit_admin_fw_commit(struct nvme_transport_handle *hdl,
 	ULONG buffer_len = 0;
 	ULONG returned_len = 0;
 	BOOL result = FALSE;
-	__u8 commit_action;
-	void *user_data;
+	void *user_data = NULL;
 	int err = 0;
+	__u8 commit_action;
 
 	user_data = hdl->submit_entry(hdl, cmd);
 	if (hdl->ctx->dry_run)
@@ -800,7 +1110,7 @@ static int nvme_submit_admin_fw_download(struct nvme_transport_handle *hdl,
 	ULONG returned_len = 0;
 	BOOL result = FALSE;
 	PUCHAR buffer = NULL;
-	void *user_data;
+	void *user_data = NULL;
 	int err = 0;
 
 	user_data = hdl->submit_entry(hdl, cmd);
@@ -906,7 +1216,7 @@ static int nvme_submit_admin_format_nvm_user_data_erase(
 	ULONG returned_len = 0;
 	BOOL result = FALSE;
 	PUCHAR buffer = NULL;
-	void *user_data;
+	void *user_data = NULL;
 	int err = 0;
 
 	user_data = hdl->submit_entry(hdl, cmd);
@@ -997,7 +1307,7 @@ static int nvme_submit_admin_format_nvm_crypto_erase(
 {
 	BOOL result = FALSE;
 	ULONG returned_len = 0;
-	void *user_data;
+	void *user_data = NULL;
 	int err = 0;
 
 	user_data = hdl->submit_entry(hdl, cmd);
@@ -1083,7 +1393,7 @@ static int nvme_submit_admin_security_send_receive(
 	ULONG returned_len = 0;
 	BOOL result = FALSE;
 	PUCHAR buffer = NULL;
-	void *user_data;
+	void *user_data = NULL;
 	int err = 0;
 	bool is_send = (cmd->opcode == nvme_admin_security_send);
 
@@ -1194,12 +1504,48 @@ static int nvme_submit_admin_security_send_receive(
 	return err;
 }
 
+/*
+ * Windows only supports a subset of NVMe IO command calls from user space
+ * and uses different IOCTLs for different commands instead of a single
+ * passthru interface.
+ * Passthru is supported using IOCTL_STORAGE_PROTOCOL_COMMAND,
+ * but only for vendor-specific commands and a small subset of IO commands.
+ * For supported commands and a mapping to the required IOCTLs, see:
+ * https://learn.microsoft.com/en-us/windows-hardware/drivers/storage/stornvme-command-set-support
+ */
+int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	if (!hdl || !cmd)
+		return -EINVAL;
+
+	switch (cmd->opcode) {
+	case nvme_cmd_flush:
+		return nvme_submit_io_flush(hdl, cmd);
+	case nvme_cmd_write:
+		return nvme_submit_io_write(hdl, cmd);
+	case nvme_cmd_read:
+		return nvme_submit_io_read(hdl, cmd);
+	case nvme_cmd_compare:
+		/* Only supported on WinPE */
+		if (get_is_win_pe())
+			return nvme_submit_storage_protocol_command(hdl, cmd);
+		else
+			return -ENOTSUP;
+	case 0x80 ... 0xFF: /* vendor-specific commands */
+		return nvme_submit_storage_protocol_command(hdl, cmd);
+	default:
+		return -ENOTSUP;
+	}
+	return -ENOTSUP;
+}
+
 /*
  * Windows only supports a subset of NVMe admin command calls from user space
  * and uses different IOCTLs for different commands instead of a single
  * passthru interface.
  * Passthru is supported using IOCTL_STORAGE_PROTOCOL_COMMAND,
- * but only for VU commands and a small subset of admin commands.
+ * but only for vendor-specific commands and a small subset of admin commands.
  * For supported commands and a mapping to the required IOCTLs, see:
  * https://learn.microsoft.com/en-us/windows-hardware/drivers/storage/stornvme-command-set-support
  */
@@ -1212,10 +1558,6 @@ int nvme_submit_admin_passthru(struct nvme_transport_handle *hdl,
 	if (hdl->type != NVME_TRANSPORT_HANDLE_TYPE_DIRECT)
 		return -ENOTSUP;
 
-	/* VU commands */
-	if (cmd->opcode >= 0xC0 && cmd->opcode <= 0xFF)
-		return nvme_submit_storage_protocol_command(hdl, cmd);
-
 	switch (cmd->opcode) {
 	case nvme_admin_get_log_page:
 		return nvme_submit_admin_get_log_page(hdl, cmd);
@@ -1245,6 +1587,8 @@ int nvme_submit_admin_passthru(struct nvme_transport_handle *hdl,
 		return nvme_submit_admin_security_send_receive(hdl, cmd);
 	case nvme_admin_sanitize_nvm:
 		return nvme_submit_storage_protocol_command(hdl, cmd);
+	case 0xC0 ... 0xFF: /* vendor-specific commands */
+		return nvme_submit_storage_protocol_command(hdl, cmd);
 	default:
 		return -ENOTSUP;
 	}

From 839d4a71102fd58d89e70dec70b030e59ee63d2e Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Thu, 5 Mar 2026 16:08:32 -0700
Subject: [PATCH 37/83] Fixed Windows build issues introduced by latest merge
 from master. (#69)

* Renamed windows.c lib-windows.c to match reorganization in master.
* Removed Windows stubs for methods in cmds.h/.c.
* Added stubs for freeifaddrs and __nvme_free_host.
Allows nvme_free_global_ctx to compile without being a stub.
* Replaced linux-specific includes with platform/includes.h.
* Updated ioctl-windows.c to include libnvme.h, matching ioctl.c and
including cmds.h, which now has definitions previously in ioctl.h
---
 libnvme/src/meson.build                       |  4 +-
 libnvme/src/nvme/cmds.c                       |  2 +
 libnvme/src/nvme/cmds.h                       |  1 -
 libnvme/src/nvme/ioctl-windows.c              |  2 +
 libnvme/src/nvme/lib-types.h                  |  2 +-
 libnvme/src/nvme/{windows.c => lib-windows.c} |  2 +-
 libnvme/src/nvme/lib.c                        |  7 +++-
 libnvme/src/nvme/lib.h                        |  8 ++--
 libnvme/src/nvme/nbft.h                       |  2 +-
 libnvme/src/nvme/windows-stubs.c              | 40 +++----------------
 libnvme/src/platform/windows.h                |  3 +-
 nvme.c                                        |  1 -
 12 files changed, 26 insertions(+), 48 deletions(-)
 rename libnvme/src/nvme/{windows.c => lib-windows.c} (99%)

diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index 0bff2f5bd5..ee87030351 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -11,7 +11,6 @@ sources = [
     'nvme/crc32.c',
     'nvme/ioctl.c',
     'nvme/lib.c',
-    'nvme/linux.c',
     'nvme/log.c',
     'nvme/nbft.c',
     'nvme/tree.c',
@@ -21,12 +20,13 @@ sources = [
 if is_windows
     sources += [
         'nvme/ioctl-windows.c',  # Windows stubs for Linux-specific ioctl functions
-        'nvme/windows.c',  # Windows implementations of linux.h functions
+        'nvme/lib-windows.c',  # Windows implementations of lib.h functions
         'nvme/windows-stubs.c',  # Stubs for excluded functions
         'platform/windows.c',  # POSIX compatibility implementations
     ]
 else
     sources += [
+        'nvme/linux.c',
         'nvme/fabrics.c',
         'nvme/filters.c',
         'nvme/mi-mctp.c',
diff --git a/libnvme/src/nvme/cmds.c b/libnvme/src/nvme/cmds.c
index 71457f5e65..8e3f2df68e 100644
--- a/libnvme/src/nvme/cmds.c
+++ b/libnvme/src/nvme/cmds.c
@@ -12,6 +12,8 @@
 
 #include <libnvme.h>
 
+#include "platform/includes.h"
+
 #include "cleanup.h"
 #include "private.h"
 
diff --git a/libnvme/src/nvme/cmds.h b/libnvme/src/nvme/cmds.h
index ef0a4fcde7..e09e7450af 100644
--- a/libnvme/src/nvme/cmds.h
+++ b/libnvme/src/nvme/cmds.h
@@ -15,7 +15,6 @@
 
 #include <string.h>
 #include <errno.h>
-#include <endian.h>
 
 enum nvme_cmd_dword_fields {
 	NVME_DEVICE_SELF_TEST_CDW10_STC_SHIFT			= 0,
diff --git a/libnvme/src/nvme/ioctl-windows.c b/libnvme/src/nvme/ioctl-windows.c
index 2315fd271f..85dc045079 100644
--- a/libnvme/src/nvme/ioctl-windows.c
+++ b/libnvme/src/nvme/ioctl-windows.c
@@ -12,6 +12,8 @@
 #include "private.h"
 #include "types.h"
 
+#include <libnvme.h>
+
 #include <windows.h>
 #include <winioctl.h>
 #include <errno.h>
diff --git a/libnvme/src/nvme/lib-types.h b/libnvme/src/nvme/lib-types.h
index 43eab2ddac..04a8afd017 100644
--- a/libnvme/src/nvme/lib-types.h
+++ b/libnvme/src/nvme/lib-types.h
@@ -8,7 +8,7 @@
  */
 #pragma once
 
-#include <linux/types.h>
+#include <platform/types.h>
 
 struct nvme_global_ctx;
 struct nvme_transport_handle;
diff --git a/libnvme/src/nvme/windows.c b/libnvme/src/nvme/lib-windows.c
similarity index 99%
rename from libnvme/src/nvme/windows.c
rename to libnvme/src/nvme/lib-windows.c
index 9967aad431..1bd1c81170 100644
--- a/libnvme/src/nvme/windows.c
+++ b/libnvme/src/nvme/lib-windows.c
@@ -7,7 +7,7 @@
  */
 
 #include "private.h"
-#include "nvme/linux.h"
+#include "nvme/lib.h"
 
 
 static int __nvme_transport_handle_open_direct(struct nvme_transport_handle *hdl, const char *name)
diff --git a/libnvme/src/nvme/lib.c b/libnvme/src/nvme/lib.c
index b7865da5a3..7585cc80f0 100644
--- a/libnvme/src/nvme/lib.c
+++ b/libnvme/src/nvme/lib.c
@@ -15,7 +15,6 @@
 #include <libgen.h>
 #include <strings.h>
 #include <fcntl.h>
-#include <sys/ioctl.h>
 
 static bool nvme_mi_probe_enabled_default(void)
 {
@@ -120,6 +119,7 @@ void nvme_transport_handle_set_decide_retry(struct nvme_transport_handle *hdl,
 		hdl->decide_retry = __nvme_decide_retry;
 }
 
+#ifndef _WIN32
 static int __nvme_transport_handle_open_direct(
 		struct nvme_transport_handle *hdl, const char *devname)
 {
@@ -176,6 +176,7 @@ void __nvme_transport_handle_close_direct(struct nvme_transport_handle *hdl)
 	close(hdl->fd);
 	free(hdl);
 }
+#endif /* !_WIN32 */
 
 struct nvme_transport_handle *__nvme_create_transport_handle(
 		struct nvme_global_ctx *ctx)
@@ -194,6 +195,7 @@ struct nvme_transport_handle *__nvme_create_transport_handle(
 	return hdl;
 }
 
+#ifndef _WIN32
 int nvme_open(struct nvme_global_ctx *ctx, const char *name,
 	      struct nvme_transport_handle **hdlp)
 {
@@ -255,8 +257,9 @@ void nvme_close(struct nvme_transport_handle *hdl)
 		break;
 	}
 }
+#endif /* !_WIN32 */
 
-int nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl)
+nvme_fd_t nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl)
 {
 	return hdl->fd;
 }
diff --git a/libnvme/src/nvme/lib.h b/libnvme/src/nvme/lib.h
index eeb6444fcf..784cd647eb 100644
--- a/libnvme/src/nvme/lib.h
+++ b/libnvme/src/nvme/lib.h
@@ -10,7 +10,8 @@
 
 #include <stdio.h>
 #include <stdbool.h>
-#include <syslog.h>
+
+#include "platform/includes.h"
 
 #include <nvme/lib-types.h>
 
@@ -92,9 +93,10 @@ void nvme_close(struct nvme_transport_handle *hdl);
  * If the device handle is for a ioctl based device,
  * nvme_transport_handle_get_fd will return a valid file descriptor.
  *
- * Return: File descriptor for an IOCTL based transport handle, otherwise -1.
+ * Return: File descriptor for an IOCTL based transport handle,
+ * otherwise INIT_FD.
  */
-int nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl);
+nvme_fd_t nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl);
 
 /**
  * nvme_transport_handle_get_name - Return name of the device transport handle
diff --git a/libnvme/src/nvme/nbft.h b/libnvme/src/nvme/nbft.h
index 79ae801446..f0b1db5de1 100644
--- a/libnvme/src/nvme/nbft.h
+++ b/libnvme/src/nvme/nbft.h
@@ -11,7 +11,7 @@
 #include <stdbool.h>
 #include <sys/types.h>
 
-#include <linux/types.h>
+#include <platform/types.h>
 
 #include <nvme/lib-types.h>
 
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 718ed7ff29..9f24363e7c 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -132,6 +132,11 @@ void nvme_free_uri(struct nvme_fabrics_uri *uri)
  * Stub implementations for tree functions (tree.c)
  * Minimal support - just return NULL/errors
  */
+void __nvme_free_host(struct nvme_host *h)
+{
+	stub_log(__func__);
+	(void)h;
+}
 
 void nvme_release_fds(struct nvme_global_ctx *ctx)
 {
@@ -154,12 +159,6 @@ void nvme_free_tree(void *r)
 	(void)r;
 }
 
-void nvme_free_global_ctx(struct nvme_global_ctx *ctx)
-{
-	stub_log(__func__);
-	(void)ctx;
-}
-
 const char *nvme_root_get_application(void *r)
 {
 	stub_log(__func__);
@@ -942,16 +941,6 @@ nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p)
 	return NULL;
 }
 
-/* ANA log utilities (linux.c) */
-size_t nvme_get_ana_log_len_from_id_ctrl(const struct nvme_id_ctrl *id_ctrl,
-	bool rgo)
-{
-	stub_log(__func__);
-	(void)id_ctrl;
-	(void)rgo;
-	return 0;
-}
-
 /* MI status string (mi.c) */
 const char *nvme_mi_status_to_string(int status)
 {
@@ -1156,25 +1145,6 @@ char *nvmf_hostnqn_generate_from_hostid(char *hostid)
 	return NULL;
 }
 
-/* Extended Telemetry (linux.c) */
-int nvme_set_etdas(struct nvme_transport_handle *hdl, bool *changed)
-{
-	stub_log(__func__);
-	(void)hdl;
-	(void)changed;
-	errno = ENOTSUP;
-	return -1;
-}
-
-int nvme_clear_etdas(struct nvme_transport_handle *hdl, bool *changed)
-{
-	stub_log(__func__);
-	(void)hdl;
-	(void)changed;
-	errno = ENOTSUP;
-	return -1;
-}
-
 /* Path property getters (tree.c) */
 const char *nvme_path_get_numa_nodes(struct nvme_path *p)
 {
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 725e4070a5..22c9a73e8a 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -173,7 +173,7 @@ struct iovec {
     size_t iov_len;
 };
 
-/* Windows missing network structures */
+/* Windows missing network structures - ifaddrs.h stubs */
 struct ifaddrs {
     struct ifaddrs *ifa_next;
     char *ifa_name;
@@ -183,6 +183,7 @@ struct ifaddrs {
     struct sockaddr *ifa_broadaddr;
     void *ifa_data;
 };
+static inline void freeifaddrs(struct ifaddrs *ifa) { (void)ifa; }
 
 /* Extract IPv4 from IPv6 mapped address */
 #define ipv4_from_in6_addr(addr) &(addr.u.Byte[12])
diff --git a/nvme.c b/nvme.c
index 475db9f7ee..f966481bb1 100644
--- a/nvme.c
+++ b/nvme.c
@@ -47,7 +47,6 @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <sys/ioctl.h>
 
 
 #if HAVE_SYS_RANDOM

From 81a9f18751e6cbe3b62f4c731bcb8ed65c004252 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Thu, 12 Mar 2026 17:01:05 -0600
Subject: [PATCH 38/83] Implemented nvme_get_nsid for Windows. (#78)

Get the NSID for a given handle using IOCTL_SCSI_GET_ADDRESS. The LUN
field corresponds to the namespace ID - 1.

Also updated the Windows identify handler after testing additional
identify CNS values and finding that more were supported than just
identify controller and namespace.
---
 libnvme/src/nvme/ioctl-windows.c | 32 ++++++++++++++------------------
 1 file changed, 14 insertions(+), 18 deletions(-)

diff --git a/libnvme/src/nvme/ioctl-windows.c b/libnvme/src/nvme/ioctl-windows.c
index 85dc045079..5398e2e04c 100644
--- a/libnvme/src/nvme/ioctl-windows.c
+++ b/libnvme/src/nvme/ioctl-windows.c
@@ -114,9 +114,17 @@ int nvme_ns_rescan(struct nvme_transport_handle *hdl)
 
 int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
 {
-	(void)hdl;
-	(void)nsid;
-	return -ENOTSUP;
+	/* Get the SCSI LUN, which corresponds to NSID - 1. */
+	SCSI_ADDRESS addr = {0};
+	addr.Length = sizeof(addr);
+
+	DWORD bytesReturned = 0;
+	if (!DeviceIoControl(hdl->fd, IOCTL_SCSI_GET_ADDRESS, NULL, 0,
+				&addr, sizeof(addr), &bytesReturned, NULL))
+		return -EIO;
+
+	*nsid = addr.Lun + 1;
+	return 0;
 }
 
 /*
@@ -703,19 +711,13 @@ static int nvme_submit_admin_identify(struct nvme_transport_handle *hdl,
 	}
 
 	/*
-	 * From Windows STORAGE_PROTOCOL_NVME_DATA_TYPE documentation
-	 * for NVMeDataTypeIdentify:
-	 * "ProtocolDataRequestValue will be NVME_IDENTIFY_CNS_CONTROLLER for
-	 * adapter or NVME_IDENTIFY_CNS_SPECIFIC_NAMESPACE for namespace."
-	 * Other CNS values are not supported.
+	 * Not all Controller or Namespace Structure values are supported
+	 * on Windows, but allow the requested command to be issued and fail
+	 * if not supported.
 	 */
 	cns = NVME_FIELD_DECODE(cmd->cdw10,
 				NVME_IDENTIFY_CDW10_CNS_SHIFT,
 				NVME_IDENTIFY_CDW10_CNS_MASK);
-	if (cns != NVME_IDENTIFY_CNS_CTRL && cns != NVME_IDENTIFY_CNS_NS) {
-		err = -ENOTSUP;
-		goto out;
-	}
 
 	/* Command Set Indicator values other than NVME_CSI_NVM not supported */
 	csi = NVME_FIELD_DECODE(cmd->cdw11,
@@ -740,15 +742,9 @@ static int nvme_submit_admin_identify(struct nvme_transport_handle *hdl,
 	query = (PSTORAGE_PROPERTY_QUERY)buffer;
 	protocol_data = (PSTORAGE_PROTOCOL_SPECIFIC_DATA)query->AdditionalParameters;
 
-	/*
-	 * NOTE: If testing fails with Identify Specific Namespace, try
-	 * StorageDeviceProtocolSpecificProperty for that cns.
-	 */
 	query->PropertyId = StorageAdapterProtocolSpecificProperty;
-
 	protocol_data->ProtocolType = ProtocolTypeNvme;
 	protocol_data->DataType = NVMeDataTypeIdentify;
-
 	protocol_data->ProtocolDataRequestValue = cns;
 	protocol_data->ProtocolDataRequestSubValue = cmd->nsid;
 	protocol_data->ProtocolDataOffset = sizeof(STORAGE_PROTOCOL_SPECIFIC_DATA);

From 7a8f895fef093fd3323362426ce821c45d6b3757 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Mon, 23 Mar 2026 13:34:34 -0700
Subject: [PATCH 39/83] Merge remote-tracking branch 'origin/master' into mingw

---
 .github/workflows/build.yml                   |   13 +
 .github/workflows/check-accessors.yml         |   48 +
 .github/workflows/codeql.yml                  |    6 +-
 .github/workflows/upload.yml                  |   43 +-
 Makefile                                      |    4 +
 README.md                                     |   89 +-
 fabrics.c                                     |   23 +-
 libnvme/examples/discover-loop.c              |    7 +-
 libnvme/examples/display-columnar.c           |    4 +-
 libnvme/examples/display-tree.c               |    4 +-
 libnvme/examples/meson.build                  |   20 +-
 libnvme/examples/mi-conf.c                    |    4 +-
 libnvme/examples/mi-mctp-ae.c                 |   11 +-
 libnvme/examples/mi-mctp-csi-test.c           |    8 +-
 libnvme/examples/mi-mctp.c                    |    6 +-
 libnvme/examples/telemetry-listen.c           |    9 +-
 libnvme/libnvme/nvme.i                        |   55 +-
 libnvme/meson.build                           |    4 +-
 libnvme/src/accessors.ld                      |  154 ++
 libnvme/src/{libnvme.h => libnvme.h.in}       |    4 +-
 libnvme/src/libnvme.ld                        |  180 +-
 libnvme/src/libnvmf.ld                        |   45 +
 libnvme/src/meson.build                       |   83 +-
 libnvme/src/nvme/accessors.c                  |  888 +++++++
 libnvme/src/nvme/accessors.h                  | 1202 ++++++++++
 libnvme/src/nvme/base64.c                     |    3 +-
 libnvme/src/nvme/cmds.c                       |  379 +--
 libnvme/src/nvme/cmds.h                       | 2101 ++---------------
 libnvme/src/nvme/compiler_attributes.h        |   26 +
 libnvme/src/nvme/crc32.h                      |    2 +-
 libnvme/src/nvme/fabrics.c                    |  794 ++-----
 libnvme/src/nvme/fabrics.h                    |   61 +-
 libnvme/src/nvme/filters.c                    |   33 +-
 libnvme/src/nvme/filters.h                    |   16 +-
 libnvme/src/nvme/generate-accessors.c         | 1783 --------------
 libnvme/src/nvme/generate-accessors.md        |  296 ---
 libnvme/src/nvme/ioctl.c                      |  356 +--
 libnvme/src/nvme/ioctl.h                      |   17 +-
 libnvme/src/nvme/json.c                       |   30 +-
 libnvme/src/nvme/lib.c                        |   45 +-
 libnvme/src/nvme/lib.h                        |    1 -
 libnvme/src/nvme/linux.c                      |  328 ++-
 libnvme/src/nvme/linux.h                      |   54 +-
 libnvme/src/nvme/log.c                        |   10 +-
 libnvme/src/nvme/meson.build                  |   78 -
 libnvme/src/nvme/mi-mctp.c                    |   10 +-
 libnvme/src/nvme/mi.c                         |   70 +-
 libnvme/src/nvme/nbft.c                       |    7 +-
 libnvme/src/nvme/nbft.h                       |   23 +-
 libnvme/src/nvme/no-json.c                    |    6 +-
 libnvme/src/nvme/private.h                    |  185 +-
 libnvme/src/nvme/structs-to-include.txt       |    8 -
 libnvme/src/nvme/tree.c                       |  544 +----
 libnvme/src/nvme/tree.h                       |  518 +---
 libnvme/src/nvme/types.h                      |   59 +-
 libnvme/src/nvme/uring.c                      |  138 ++
 libnvme/src/nvme/util.c                       |   37 +-
 libnvme/src/nvme/util.h                       |   12 +-
 libnvme/test/config/config-dump.c             |    4 +-
 libnvme/test/config/hostnqn-order.c           |    4 +-
 libnvme/test/config/psk-json.c                |    9 +-
 libnvme/test/cpp.cc                           |    4 +-
 libnvme/test/hkdf_add1.c                      |    5 +-
 libnvme/test/ioctl/meson.build                |   24 +-
 libnvme/test/ioctl/misc.c                     |   31 +-
 libnvme/test/ioctl/mock.c                     |    3 +-
 libnvme/test/ioctl/zns.c                      |    5 +-
 libnvme/test/meson.build                      |   38 +-
 libnvme/test/mi-mctp.c                        |   17 +-
 libnvme/test/mi.c                             |    2 +-
 libnvme/test/mock-ifaddrs.c                   |   11 +-
 libnvme/test/nbft/nbft-dump.c                 |    8 +-
 libnvme/test/psk.c                            |    4 +-
 libnvme/test/register.c                       |    5 +-
 libnvme/test/test-util.c                      |    6 +-
 libnvme/test/test.c                           |   25 +-
 libnvme/test/tree.c                           |   27 +-
 libnvme/test/uriparser.c                      |    2 +-
 libnvme/test/uuid.c                           |    6 +-
 libnvme/test/zns.c                            |   15 +-
 libnvme/tools/check-public-symbols.py         |   95 +
 libnvme/tools/generator/generate-accessors.md |  271 +++
 libnvme/tools/generator/generate-accessors.py |  672 ++++++
 libnvme/tools/generator/meson.build           |   40 +
 libnvme/tools/generator/update-accessors.sh   |  111 +
 logging.c                                     |    8 +-
 meson.build                                   |   30 +-
 meson_options.txt                             |    6 +
 nvme-builtin.h                                |    6 +-
 nvme-cmds.c                                   |   44 +
 nvme-cmds.h                                   | 1749 ++++++++++++++
 nvme-models.c                                 |   11 +-
 nvme-print-json.c                             |   45 +-
 nvme-print-stdout.c                           |  104 +-
 nvme-print.c                                  |    5 +-
 nvme-print.h                                  |    7 +-
 nvme-rpmb.c                                   |   21 +-
 nvme.c                                        |   66 +-
 nvme.h                                        |    1 +
 plugin.c                                      |    4 +-
 plugins/amzn/amzn-nvme.c                      |    3 +-
 plugins/dapustor/dapustor-nvme.c              |    3 +-
 plugins/dera/dera-nvme.c                      |    7 +-
 plugins/fdp/fdp.c                             |    3 +-
 plugins/feat/feat-nvme.c                      |    6 +-
 plugins/huawei/huawei-nvme.c                  |    3 +-
 plugins/ibm/ibm-nvme.c                        |    3 +-
 plugins/inspur/inspur-nvme.c                  |    3 +-
 plugins/intel/intel-nvme.c                    |    3 +-
 plugins/lm/lm-nvme.c                          |   18 +-
 plugins/lm/lm-print-stdout.c                  |    3 +-
 plugins/memblaze/memblaze-nvme.c              |    7 +-
 plugins/meson.build                           |    5 +-
 plugins/micron/micron-nvme.c                  |   37 +-
 plugins/netapp/netapp-nvme.c                  |    2 +-
 plugins/ocp/ocp-clear-features.c              |    5 +-
 plugins/ocp/ocp-fw-activation-history.c       |    6 +-
 plugins/ocp/ocp-nvme.c                        |    6 +-
 plugins/ocp/ocp-smart-extended-log.c          |    4 +-
 plugins/ocp/ocp-telemetry-decode.c            |   86 +-
 plugins/ocp/ocp-utils.c                       |    8 +-
 plugins/sandisk/sandisk-nvme.c                |    4 +-
 plugins/sandisk/sandisk-utils.c               |   16 +-
 plugins/sandisk/sandisk-utils.h               |   17 +-
 plugins/scaleflux/sfx-nvme.c                  |    6 +-
 plugins/seagate/seagate-nvme.c                |   14 +-
 plugins/sed/sed.c                             |   10 +-
 plugins/sed/sed.h                             |    3 +-
 plugins/shannon/shannon-nvme.c                |    4 +-
 plugins/solidigm/solidigm-internal-logs.c     |    4 +-
 plugins/solidigm/solidigm-latency-tracking.c  |    5 +-
 plugins/solidigm/solidigm-log-page-dir.c      |    5 +-
 plugins/solidigm/solidigm-nvme.h              |    2 +-
 plugins/solidigm/solidigm-telemetry/config.c  |   16 +-
 .../solidigm/solidigm-telemetry/data-area.c   |   23 +-
 .../solidigm/solidigm-telemetry/debug-info.c  |    5 +-
 plugins/solidigm/solidigm-telemetry/nlog.c    |    7 +-
 .../solidigm/solidigm-telemetry/side-trace.c  |   11 +-
 .../solidigm-telemetry/telemetry-log.h        |    5 +-
 .../solidigm/solidigm-telemetry/uart-log.c    |    7 +-
 plugins/solidigm/solidigm-util.c              |    5 +-
 plugins/solidigm/solidigm-workload-tracker.c  |    6 +-
 plugins/ssstc/ssstc-nvme.c                    |    4 +-
 plugins/toshiba/toshiba-nvme.c                |    4 +-
 plugins/transcend/transcend-nvme.c            |    1 +
 plugins/virtium/virtium-nvme.c                |    1 +
 plugins/wdc/wdc-nvme.c                        |   28 +-
 plugins/wdc/wdc-utils.c                       |    4 +-
 plugins/wdc/wdc-utils.h                       |   17 +-
 plugins/ymtc/ymtc-nvme.c                      |    4 +-
 plugins/ymtc/ymtc-nvme.h                      |    9 +-
 plugins/zns/zns.c                             |    7 +-
 scripts/build.sh                              |   52 +-
 scripts/release.sh                            |   35 -
 unit/test-argconfig-parse.c                   |    6 +-
 unit/test-suffix-binary-parse.c               |    4 +-
 unit/test-suffix-si-parse.c                   |    6 +-
 unit/test-uint128-si.c                        |    2 +-
 unit/test-uint128.c                           |    4 +-
 util/argconfig.c                              |   16 +-
 util/argconfig.h                              |    6 +-
 util/base64.c                                 |    3 +-
 util/cleanup.h                                |    4 +-
 util/crc32.h                                  |    2 +-
 util/mem.c                                    |    2 +
 util/suffix.c                                 |   10 +-
 util/types.h                                  |    2 +
 167 files changed, 7972 insertions(+), 7152 deletions(-)
 create mode 100644 .github/workflows/check-accessors.yml
 create mode 100644 libnvme/src/accessors.ld
 rename libnvme/src/{libnvme.h => libnvme.h.in} (92%)
 create mode 100644 libnvme/src/libnvmf.ld
 create mode 100644 libnvme/src/nvme/accessors.c
 create mode 100644 libnvme/src/nvme/accessors.h
 create mode 100644 libnvme/src/nvme/compiler_attributes.h
 delete mode 100644 libnvme/src/nvme/generate-accessors.c
 delete mode 100644 libnvme/src/nvme/generate-accessors.md
 delete mode 100644 libnvme/src/nvme/meson.build
 delete mode 100644 libnvme/src/nvme/structs-to-include.txt
 create mode 100644 libnvme/src/nvme/uring.c
 create mode 100644 libnvme/tools/check-public-symbols.py
 create mode 100644 libnvme/tools/generator/generate-accessors.md
 create mode 100755 libnvme/tools/generator/generate-accessors.py
 create mode 100644 libnvme/tools/generator/meson.build
 create mode 100755 libnvme/tools/generator/update-accessors.sh
 create mode 100644 nvme-cmds.c
 create mode 100644 nvme-cmds.h

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 0bf62ade4e..76ccdc5ec7 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -187,6 +187,19 @@ jobs:
         run: |
           CC=musl-gcc scripts/build.sh musl
 
+  build-musl-minimal-static:
+    name: musl libc minimal static build on Debian
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/linux-nvme/debian:latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Mark repo as safe for git
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+      - name: build
+        run: |
+          scripts/build.sh minimal_static
+
   build-alpine:
     name: musl libc build on Alpine
     runs-on: ubuntu-latest
diff --git a/.github/workflows/check-accessors.yml b/.github/workflows/check-accessors.yml
new file mode 100644
index 0000000000..9fd4ed077f
--- /dev/null
+++ b/.github/workflows/check-accessors.yml
@@ -0,0 +1,48 @@
+---
+# SPDX-License-Identifier: GPL-2.0-or-later
+#
+# This file is part of nvme.
+# Copyright (c) 2025 Dell Technologies Inc. or its subsidiaries.
+#
+# Authors: Martin Belanger <Martin.Belanger@dell.com>
+#
+# Verify that the committed accessor files (accessors.h, accessors.c) are
+# up to date with the generate-accessors tool and the structs in private.h.
+#
+# If this check fails, run the following command and commit the result:
+#
+#   meson compile -C <build-dir> update-accessors
+
+name: Check accessors
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+  workflow_dispatch:
+
+jobs:
+  check-accessors:
+    name: check generated accessor files are up to date
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/linux-nvme/debian:latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Mark repo as safe for git
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+      - name: Configure
+        run: meson setup .build-ci
+      - name: Regenerate accessor files
+        run: meson compile -C .build-ci update-accessors
+      - name: Check for uncommitted differences
+        run: |
+          if ! git diff --exit-code libnvme/src/nvme/accessors.h \
+                                    libnvme/src/nvme/accessors.c; then
+            echo ""
+            echo "ERROR: accessor files are out of date."
+            echo "Run 'meson compile -C <build-dir> update-accessors' and commit the result."
+            exit 1
+          fi
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index 917f286277..7258c4a12f 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -51,13 +51,13 @@ jobs:
     # Initializes the CodeQL tools for scanning.
     - if: matrix.language == 'c-cpp'
       name: Initialize CodeQL C
-      uses: github/codeql-action/init@c793b717bc78562f491db7b0e93a3a178b099162 # v4.32.5
+      uses: github/codeql-action/init@b1bff81932f5cdfc8695c7752dcee935dcd061c8 # v4.33.0
       with:
         languages: 'c-cpp'
 
     - if: matrix.language == 'python'
       name: Initialize CodeQL Python
-      uses: github/codeql-action/init@c793b717bc78562f491db7b0e93a3a178b099162 # v4.32.5
+      uses: github/codeql-action/init@b1bff81932f5cdfc8695c7752dcee935dcd061c8 # v4.33.0
       with:
         languages: 'python'
         config-file: ./.github/codeql/codeql-config.yml
@@ -68,6 +68,6 @@ jobs:
          ninja -C .build
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@c793b717bc78562f491db7b0e93a3a178b099162 # v4.32.5
+      uses: github/codeql-action/analyze@b1bff81932f5cdfc8695c7752dcee935dcd061c8 # v4.33.0
       with:
         category: "/language:${{matrix.language}}"
diff --git a/.github/workflows/upload.yml b/.github/workflows/upload.yml
index 7b1ba4bd84..2b7f73c0bf 100644
--- a/.github/workflows/upload.yml
+++ b/.github/workflows/upload.yml
@@ -11,6 +11,8 @@ name: Upload
 on:
   push:
     branches: [master]
+    tags:
+      - 'v*'
   release:
     types: [published]
 
@@ -41,9 +43,11 @@ jobs:
           scripts/build.sh static
           mkdir upload
           cp .build-ci/nvme upload/nvme-cli-latest-x86_64
-          if [ "${GITHUB_EVENT_NAME}" = "release" ]; then
-            cp .build-ci/nvme "upload/nvme-cli-${VERSION}-x86_64"
-          fi
+          case "${GITHUB_REF}" in
+            refs/tags/v*)
+              cp .build-ci/nvme "upload/nvme-cli-${GITHUB_REF_NAME}-x86_64"
+              ;;
+          esac
 
       - uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         name: upload artifacts to github
@@ -62,19 +66,26 @@ jobs:
           name: nvme-cli
           path: upload
 
-      - name: FTP Deployer
-        uses: sand4rt/ftp-deployer@518beaad91d1b18fd55a69321de7ed89080d2ae3 # v1.8
-        with:
-          sftp: true
-          host: ${{ secrets.SFTP_SERVER }}
-          port: 22
-          username: ${{ secrets.SFTP_USERNAME }}
-          password: ${{ secrets.SFTP_PASSWORD }}
-          remote_folder: '/upload'
-          local_folder: upload
-          cleanup: false
-          include: '[ "nvme-cli-*" ]'
-          exclude: '[".github/**", ".git/**", "*.env"]'
+      - name: upload to SFTP server
+        env:
+          SFTP_USERNAME: ${{ secrets.SFTP_USERNAME }}
+          SFTP_SERVER: ${{ secrets.SFTP_SERVER }}
+          SFTP_HOST_KEY: ${{ secrets.SFTP_HOST_KEY }}
+          SFTP_PRIVATE_KEY: ${{ secrets.SFTP_PRIVATE_KEY }}
+        run: |
+          mkdir -p ~/.ssh
+          chmod 700 ~/.ssh
+          echo "${SFTP_HOST_KEY}" > ~/.ssh/known_hosts
+          echo "${SFTP_PRIVATE_KEY}" > ~/.ssh/id_ed25519
+          chmod 600 ~/.ssh/id_ed25519
+          SFTP_BATCH=$(mktemp)
+          trap 'rm -f "$SFTP_BATCH"' EXIT
+          echo "cd /upload" > "$SFTP_BATCH"
+          for f in upload/nvme-cli-*; do
+            [ -f "$f" ] || continue
+            echo "put $f $(basename "$f")" >> "$SFTP_BATCH"
+          done
+          sftp -b "$SFTP_BATCH" "${SFTP_USERNAME}@${SFTP_SERVER}"
 
   upload-release-assets:
     name: upload GitHub release assets
diff --git a/Makefile b/Makefile
index 18ee7d6e63..695fa956cc 100644
--- a/Makefile
+++ b/Makefile
@@ -45,6 +45,10 @@ install: ${NAME}
 uninstall:
 	cd ${BUILD-DIR} && meson --internal uninstall
 
+.PHONY: update-accessors
+update-accessors: ${BUILD-DIR}
+	meson compile -C ${BUILD-DIR} update-accessors
+
 .PHONY: dist
 dist: ${NAME}
 	meson dist -C ${BUILD-DIR} --formats gztar
diff --git a/README.md b/README.md
index 5640290abb..d7b900dded 100644
--- a/README.md
+++ b/README.md
@@ -61,7 +61,7 @@ Note for nvme-cli the 'default' is set to nofallback.
 #### Installing
 
 	# meson install -C .build
-	
+
 ### Build with build.sh wrapper
 
 The `scripts/build.sh` is used for the CI build but can also be used for
@@ -237,6 +237,93 @@ After that, you just need to implement the functions you defined in each
 ENTRY, then append the object file name to the meson.build "sources".
 
 
+### Updating the libnvme accessor functions
+
+libnvme exposes a set of getter and setter functions (accessors) for its core
+internal structs (`nvme_path`, `nvme_ns`, `nvme_ctrl`, `nvme_subsystem`,
+`nvme_host`, `nvme_fabric_options`). These are generated from the struct
+definitions in `libnvme/src/nvme/private.h` by the tool
+`libnvme/src/nvme/generate-accessors.c`.
+
+The generated files are committed to the source tree and are **not**
+regenerated during a normal build:
+
+```
+libnvme/src/nvme/accessors.h   # public API declarations (with Doxygen stubs)
+libnvme/src/nvme/accessors.c   # implementations
+libnvme/src/nvme/accessors.ld  # linker version script (manually maintained)
+```
+
+#### When to regenerate
+
+Regeneration is needed when a struct member is added, removed, or renamed in
+`private.h`, or when a struct is added to or removed from
+`generate-accessors-include.list` or excluded in `generate-accessors-exclude.list`.
+
+#### How to regenerate
+
+```shell
+$ make update-accessors
+```
+
+or equivalently:
+
+```shell
+$ meson compile -C .build update-accessors
+```
+
+The script compiles the generator, runs it, and atomically updates
+`accessors.h` and `accessors.c` only when their content changes.
+Commit the updated files afterward:
+
+```shell
+$ git add libnvme/src/nvme/accessors.h libnvme/src/nvme/accessors.c
+$ git commit -m "libnvme: regenerate accessors following <struct> changes"
+```
+
+#### Maintaining accessors.ld
+
+`accessors.ld` is a GNU linker version script that controls which accessor
+symbols are exported from `libnvme.so` and under which ABI version label they
+were introduced (e.g. `LIBNVME_ACCESSORS_3`).
+
+This file is **not** updated automatically, because each symbol must be placed
+in the correct version section by the maintainer. Adding a symbol to an
+already-published version section would break binary compatibility for
+existing users of the library.
+
+When `make update-accessors` detects that the symbol list has drifted from
+`accessors.ld`, it prints a report like the following:
+
+```
+WARNING: accessors.ld needs manual attention.
+
+  Symbols to ADD (place in a new version section, e.g. LIBNVME_ACCESSORS_X_Y):
+    nvme_ctrl_get_new_field
+    nvme_ctrl_set_new_field
+```
+
+New symbols must be added to a **new** version section that chains the
+previous one. For example, if the current latest section is
+`LIBNVME_ACCESSORS_3_0`, add a new section for the next release:
+
+```
+LIBNVME_ACCESSORS_3_1 {
+    global:
+        nvme_ctrl_get_new_field;
+        nvme_ctrl_set_new_field;
+} LIBNVME_ACCESSORS_3_0;
+```
+
+Then commit `accessors.ld` together with the regenerated source files.
+
+#### CI enforcement
+
+A GitHub Actions workflow (`.github/workflows/check-accessors.yml`) runs on
+every push and pull request. It regenerates the accessor files and fails if
+the result differs from what is committed, ensuring the source tree never
+drifts silently.
+
 ## Dependency
 
 libnvme depends on the /sys/class/nvme-subsystem interface which was
diff --git a/fabrics.c b/fabrics.c
index 23d10d16d0..fae909e829 100644
--- a/fabrics.c
+++ b/fabrics.c
@@ -19,25 +19,26 @@
  * Fabrics specification standard.
  */
 
+#include <dirent.h>
 #include <errno.h>
-#include <getopt.h>
 #include <fcntl.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <unistd.h>
-#include <dirent.h>
+#include <getopt.h>
 #include <inttypes.h>
 #include <libgen.h>
-#include <sys/stat.h>
+#include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <syslog.h>
 #include <time.h>
+#include <unistd.h>
 
-#include <sys/types.h>
 #include <platform/types.h>
 
+#include <sys/stat.h>
+#include <sys/types.h>
+
 #include <libnvme.h>
 
 #include "common.h"
@@ -715,7 +716,7 @@ static void nvmf_disconnect_nqn(struct nvme_global_ctx *ctx, char *nqn)
 			continue;
 		nvme_for_each_host(ctx, h) {
 			nvme_for_each_subsystem(h, s) {
-				if (strcmp(nvme_subsystem_get_nqn(s), p))
+				if (strcmp(nvme_subsystem_get_subsysnqn(s), p))
 					continue;
 				nvme_subsystem_for_each_ctrl(s, c) {
 					if (!nvme_disconnect_ctrl(c))
@@ -1061,7 +1062,7 @@ int fabrics_dim(const char *desc, int argc, char **argv)
 				continue;
 			nvme_for_each_host(ctx, h) {
 				nvme_for_each_subsystem(h, s) {
-					if (strcmp(nvme_subsystem_get_nqn(s), p))
+					if (strcmp(nvme_subsystem_get_subsysnqn(s), p))
 						continue;
 					nvme_subsystem_for_each_ctrl(s, c)
 						ret = dim_operation(c, tas, p);
diff --git a/libnvme/examples/discover-loop.c b/libnvme/examples/discover-loop.c
index f4d7d80b57..f1369e8a0d 100644
--- a/libnvme/examples/discover-loop.c
+++ b/libnvme/examples/discover-loop.c
@@ -14,14 +14,15 @@
  */
 #define __SANE_USERSPACE_TYPES__
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <errno.h>
-#include <libnvme.h>
 
 #include <ccan/endian/endian.h>
 
+#include <libnvme.h>
+
 static void print_discover_log(struct nvmf_discovery_log *log)
 {
 	int i, numrec = le64_to_cpu(log->numrec);
@@ -68,7 +69,7 @@ int main()
 		nvme_free_global_ctx(ctx);
 		return 1;
 	}
-	ret = nvme_host_get(ctx, NULL, NULL, &h);
+	ret = nvme_get_host(ctx, NULL, NULL, &h);
 	if (ret) {
 		fprintf(stderr, "Failed to allocated memory\n");
 		return 1;
diff --git a/libnvme/examples/display-columnar.c b/libnvme/examples/display-columnar.c
index a08a2acbef..ab6d9e672f 100644
--- a/libnvme/examples/display-columnar.c
+++ b/libnvme/examples/display-columnar.c
@@ -42,7 +42,7 @@ int main()
 		nvme_for_each_subsystem(h, s) {
 			bool first = true;
 			printf("%-16s %-96s ", nvme_subsystem_get_name(s),
-			       nvme_subsystem_get_nqn(s));
+			       nvme_subsystem_get_subsysnqn(s));
 
 			nvme_subsystem_for_each_ctrl(s, c) {
 				printf("%s%s", first ? "": ", ",
@@ -70,7 +70,7 @@ int main()
 				       nvme_ctrl_get_model(c),
 				       nvme_ctrl_get_firmware(c),
 				       nvme_ctrl_get_transport(c),
-				       nvme_ctrl_get_address(c),
+				       nvme_ctrl_get_traddr(c),
 				       nvme_subsystem_get_name(s));
 
 				nvme_ctrl_for_each_ns(c, n) {
diff --git a/libnvme/examples/display-tree.c b/libnvme/examples/display-tree.c
index 8de77978da..91f67676d8 100644
--- a/libnvme/examples/display-tree.c
+++ b/libnvme/examples/display-tree.c
@@ -39,7 +39,7 @@ int main()
 		nvme_for_each_subsystem_safe(h, s, _s) {
 			printf("%c-- %s - NQN=%s\n", _s ? '|' : '`',
 			       nvme_subsystem_get_name(s),
-			       nvme_subsystem_get_nqn(s));
+			       nvme_subsystem_get_subsysnqn(s));
 
 			nvme_subsystem_for_each_ns_safe(s, n, _n) {
 				printf("%c   |-- %s lba size:%d lba max:%" PRIu64 "\n",
@@ -54,7 +54,7 @@ int main()
 				       _s ? '|' : ' ', _c ? '|' : '`',
 				       nvme_ctrl_get_name(c),
 				       nvme_ctrl_get_transport(c),
-				       nvme_ctrl_get_address(c),
+				       nvme_ctrl_get_traddr(c),
 				       nvme_ctrl_get_state(c));
 
 				nvme_ctrl_for_each_ns_safe(c, n, _n)
diff --git a/libnvme/examples/meson.build b/libnvme/examples/meson.build
index aea3a543d0..dc3c8b1c32 100644
--- a/libnvme/examples/meson.build
+++ b/libnvme/examples/meson.build
@@ -39,15 +39,17 @@ executable(
     ],
 )
 
-executable(
-    'discover-loop',
-    ['discover-loop.c'],
-    dependencies: [
-        config_dep,
-        ccan_dep,
-        libnvme_dep,
-    ],
-)
+if want_fabrics
+    executable(
+        'discover-loop',
+        ['discover-loop.c'],
+        dependencies: [
+            config_dep,
+            ccan_dep,
+            libnvme_dep,
+        ],
+    )
+endif
 
 executable(
     'mi-mctp',
diff --git a/libnvme/examples/mi-conf.c b/libnvme/examples/mi-conf.c
index f834bcce3a..03b74639d7 100644
--- a/libnvme/examples/mi-conf.c
+++ b/libnvme/examples/mi-conf.c
@@ -18,13 +18,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include <libnvme-mi.h>
-
 #include <ccan/array_size/array_size.h>
 #include <ccan/endian/endian.h>
 
 #include <dbus/dbus.h>
 
+#include <libnvme-mi.h>
+
 #define MCTP_DBUS_NAME "au.com.codeconstruct.MCTP1"
 #define MCTP_DBUS_PATH "/au/com/codeconstruct/mctp1"
 #define MCTP_DBUS_EP_IFACE "au.com.codeconstruct.MCTP.Endpoint1"
diff --git a/libnvme/examples/mi-mctp-ae.c b/libnvme/examples/mi-mctp-ae.c
index 5eeecf6da5..e35ffebc75 100644
--- a/libnvme/examples/mi-mctp-ae.c
+++ b/libnvme/examples/mi-mctp-ae.c
@@ -10,19 +10,20 @@
 #include <assert.h>
 #include <ctype.h>
 #include <err.h>
+#include <errno.h>
+#include <poll.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stddef.h>
 #include <string.h>
-#include <errno.h>
 #include <unistd.h> // for usleep
 
-#include <libnvme-mi.h>
-#include <poll.h>
+#include <sys/select.h>
 
 #include <ccan/array_size/array_size.h>
 #include <ccan/endian/endian.h>
-#include <sys/select.h>
+
+#include <libnvme-mi.h>
 
 struct app_userdata {
 	uint32_t count;
diff --git a/libnvme/examples/mi-mctp-csi-test.c b/libnvme/examples/mi-mctp-csi-test.c
index a7ca2b7dca..57602fe049 100644
--- a/libnvme/examples/mi-mctp-csi-test.c
+++ b/libnvme/examples/mi-mctp-csi-test.c
@@ -11,17 +11,17 @@
 #include <assert.h>
 #include <ctype.h>
 #include <err.h>
+#include <pthread.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stddef.h>
 #include <string.h>
-#include <pthread.h>
-
-#include <libnvme-mi.h>
 
 #include <ccan/array_size/array_size.h>
 #include <ccan/endian/endian.h>
 
+#include <libnvme-mi.h>
+
 void fhexdump(FILE *fp, const unsigned char *buf, int len)
 {
 	const int row_len = 16;
diff --git a/libnvme/examples/mi-mctp.c b/libnvme/examples/mi-mctp.c
index 042e58e663..5aa4831095 100644
--- a/libnvme/examples/mi-mctp.c
+++ b/libnvme/examples/mi-mctp.c
@@ -13,16 +13,16 @@
 #include <assert.h>
 #include <ctype.h>
 #include <err.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stddef.h>
 #include <string.h>
 
-#include <libnvme-mi.h>
-
 #include <ccan/array_size/array_size.h>
 #include <ccan/endian/endian.h>
 
+#include <libnvme-mi.h>
+
 static void show_port_pcie(struct nvme_mi_read_port_info *port)
 {
 	printf("    PCIe max payload: 0x%x\n", 0x80 << port->pcie.mps);
diff --git a/libnvme/examples/telemetry-listen.c b/libnvme/examples/telemetry-listen.c
index 2029da5848..931d95d99d 100644
--- a/libnvme/examples/telemetry-listen.c
+++ b/libnvme/examples/telemetry-listen.c
@@ -11,19 +11,22 @@
  * is observed with controller telemetry data, read the log and save it to a
  * file in /var/log/ with the device's unique name and epoch timestamp.
  */
-#include "nvme/tree.h"
 #include <fcntl.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 #include <time.h>
-#include <libnvme.h>
+#include <unistd.h>
+
 #include <sys/stat.h>
 
 #include <ccan/endian/endian.h>
 
+#include <libnvme.h>
+
+#include "nvme/tree.h"
+
 struct events {
 	nvme_ctrl_t c;
 	int uevent_fd;
diff --git a/libnvme/libnvme/nvme.i b/libnvme/libnvme/nvme.i
index c606532b33..f9fd65dc7c 100644
--- a/libnvme/libnvme/nvme.i
+++ b/libnvme/libnvme/nvme.i
@@ -38,21 +38,21 @@
 		PyDict_SetItemString(p, key, val); /* Does NOT steal reference to val .. */
 		Py_XDECREF(val);                   /* .. therefore decrement ref. count. */
 	}
-	PyObject *hostnqn_from_file() {
-		char * val = nvmf_hostnqn_from_file();
+	PyObject *read_hostnqn() {
+		char * val = nvme_read_hostnqn();
 		PyObject * obj = PyUnicode_FromString(val);
 		free(val);
 		return obj;
 	}
-	PyObject *hostid_from_file() {
-		char * val = nvmf_hostid_from_file();
+	PyObject *read_hostid() {
+		char * val = nvme_read_hostid();
 		PyObject * obj = PyUnicode_FromString(val);
 		free(val);
 		return obj;
 	}
 %}
-PyObject *hostnqn_from_file();
-PyObject *hostid_from_file();
+PyObject *read_hostnqn();
+PyObject *read_hostid();
 
 %exception nvme_ctrl::connect {
 	connect_err = 0;
@@ -369,7 +369,7 @@ struct nvme_host {
 	char *hostid;
 	char *hostsymname;
 	%extend {
-		char *dhchap_key;
+		char *dhchap_host_key;
 	}
 };
 
@@ -457,6 +457,9 @@ struct nvme_ctrl {
 		char *tls_key_identity;
 		char *tls_key;
 
+		char *dhchap_host_key;
+		char *dhchap_ctrl_key;
+
 		/**
 		 * We are remapping the following members of the C code's
 		 * nvme_ctrl_t to different names in Python. Here's the mapping:
@@ -464,12 +467,8 @@ struct nvme_ctrl {
 		 * C code                 Python (SWIG)
 		 * =====================  =====================
 		 * ctrl->s                ctrl->subsystem
-		 * ctrl->dhchap_key       ctrl->dhchap_host_key
-		 * ctrl->dhchap_ctrl_key  ctrl->dhchap_key
 		 */
 		struct nvme_subsystem *subsystem; // Maps to "s" in the C code
-		char *dhchap_host_key;            // Maps to "dhchap_key" in the C code
-		char *dhchap_key;                 // Maps to "dhchap_ctrl_key" in the C code
 	}
 };
 
@@ -557,12 +556,12 @@ struct nvme_ns {
 		  const char *hostkey = NULL,
 		  const char *hostsymname = NULL) {
 		nvme_host_t h;
-		if (nvme_host_get(ctx, hostnqn, hostid, &h))
+		if (nvme_get_host(ctx, hostnqn, hostid, &h))
 			return NULL;
 		if (hostsymname)
 			nvme_host_set_hostsymname(h, hostsymname);
 		if (hostkey)
-			nvme_host_set_dhchap_key(h, hostkey);
+			nvme_host_set_dhchap_host_key(h, hostkey);
 		return h;
 	}
 	~nvme_host() {
@@ -593,11 +592,11 @@ struct nvme_ns {
 }
 
 %{
-	const char *nvme_host_dhchap_key_get(struct nvme_host *h) {
-		return nvme_host_get_dhchap_key(h);
+	const char *nvme_host_dhchap_host_key_get(struct nvme_host *h) {
+		return nvme_host_get_dhchap_host_key(h);
 	}
-	void nvme_host_dhchap_key_set(struct nvme_host *h, char *key) {
-		nvme_host_set_dhchap_key(h, key);
+	void nvme_host_dhchap_host_key_set(struct nvme_host *h, char *key) {
+		nvme_host_set_dhchap_host_key(h, key);
 	}
 %};
 
@@ -613,7 +612,7 @@ struct nvme_ns {
 		       const char *name = NULL) {
 		struct nvme_subsystem *s;
 
-		if (nvme_subsystem_get(ctx, host, name, subsysnqn, &s))
+		if (nvme_get_subsystem(ctx, host, name, subsysnqn, &s))
 			return NULL;
 
 		return s;
@@ -880,11 +879,11 @@ struct nvme_ns {
 	const char *nvme_ctrl_state_get(struct nvme_ctrl *c) {
 		return nvme_ctrl_get_state(c);
 	}
-	const char *nvme_ctrl_dhchap_key_get(struct nvme_ctrl *c) {
-		return nvme_ctrl_get_dhchap_key(c);
+	const char *nvme_ctrl_dhchap_ctrl_key_get(struct nvme_ctrl *c) {
+		return nvme_ctrl_get_dhchap_ctrl_key(c);
 	}
-	void nvme_ctrl_dhchap_key_set(struct nvme_ctrl *c, const char *key) {
-		nvme_ctrl_set_dhchap_key(c, key);
+	void nvme_ctrl_dhchap_ctrl_key_set(struct nvme_ctrl *c, const char *key) {
+		nvme_ctrl_set_dhchap_ctrl_key(c, key);
 	}
 	const char *nvme_ctrl_dhchap_host_key_get(struct nvme_ctrl *c) {
 		return nvme_ctrl_get_dhchap_host_key(c);
@@ -898,7 +897,7 @@ struct nvme_ns {
 	}
 
 	bool nvme_ctrl_persistent_get(struct nvme_ctrl *c) {
-		return nvme_ctrl_is_persistent(c);
+		return nvme_ctrl_get_persistent(c);
 	}
 	void nvme_ctrl_persistent_set(struct nvme_ctrl *c, bool persistent) {
 		nvme_ctrl_set_persistent(c, persistent);
@@ -949,7 +948,7 @@ struct nvme_ns {
 	}
 
 	const char *nvme_ctrl_address_get(nvme_ctrl_t c) {
-		return nvme_ctrl_get_address(c);
+		return nvme_ctrl_get_traddr(c);
 	}
 
 	const char *nvme_ctrl_sysfs_dir_get(nvme_ctrl_t c) {
@@ -957,14 +956,14 @@ struct nvme_ns {
 	}
 
 	bool nvme_ctrl_discovery_ctrl_get(struct nvme_ctrl *c) {
-		return nvme_ctrl_is_discovery_ctrl(c);
+		return nvme_ctrl_get_discovery_ctrl(c);
 	}
 	void nvme_ctrl_discovery_ctrl_set(struct nvme_ctrl *c, bool discovery) {
 		nvme_ctrl_set_discovery_ctrl(c, discovery);
 	}
 
 	bool nvme_ctrl_unique_discovery_ctrl_get(nvme_ctrl_t c) {
-		return nvme_ctrl_is_unique_discovery_ctrl(c);
+		return nvme_ctrl_get_unique_discovery_ctrl(c);
 	}
 	void nvme_ctrl_unique_discovery_ctrl_set(nvme_ctrl_t c, bool unique) {
 		nvme_ctrl_set_unique_discovery_ctrl(c, unique);
@@ -1245,13 +1244,13 @@ struct nvme_ns {
 		PyObject *output;
 		int ret;
 
-		ret = nvme_nbft_read(ctx, &nbft, filename);
+		ret = nvme_read_nbft(ctx, &nbft, filename);
 		if (ret) {
 			Py_RETURN_NONE;
 		}
 
 		output = nbft_to_pydict(nbft);
-		nvme_nbft_free(ctx, nbft);
+		nvme_free_nbft(ctx, nbft);
 		return output;
 	}
 %};
diff --git a/libnvme/meson.build b/libnvme/meson.build
index bbfb595842..52a76d248d 100644
--- a/libnvme/meson.build
+++ b/libnvme/meson.build
@@ -30,7 +30,9 @@ if want_libnvme
     )
 
     ############################################################################
-    subdir('src')       # declares: libnvme_dep
+    libnvme_srcroot = meson.current_source_dir() # needed by tools/generator
+    subdir('tools/generator')  # generate code needed by src below
+    subdir('src')              # declares: libnvme_dep
     subdir('libnvme')
     if get_option('tests')
         subdir('test')
diff --git a/libnvme/src/accessors.ld b/libnvme/src/accessors.ld
new file mode 100644
index 0000000000..3cd26f8f7d
--- /dev/null
+++ b/libnvme/src/accessors.ld
@@ -0,0 +1,154 @@
+# 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>
+ *
+ */
+
+LIBNVME_ACCESSORS_3 {
+	global:
+		nvme_path_get_name;
+		nvme_path_set_name;
+		nvme_path_get_sysfs_dir;
+		nvme_path_set_sysfs_dir;
+		nvme_path_get_ana_state;
+		nvme_path_set_ana_state;
+		nvme_path_get_numa_nodes;
+		nvme_path_set_numa_nodes;
+		nvme_path_get_grpid;
+		nvme_path_set_grpid;
+		nvme_ns_get_nsid;
+		nvme_ns_set_nsid;
+		nvme_ns_get_name;
+		nvme_ns_set_name;
+		nvme_ns_get_sysfs_dir;
+		nvme_ns_set_sysfs_dir;
+		nvme_ns_get_lba_shift;
+		nvme_ns_set_lba_shift;
+		nvme_ns_get_lba_size;
+		nvme_ns_set_lba_size;
+		nvme_ns_get_meta_size;
+		nvme_ns_set_meta_size;
+		nvme_ns_get_lba_count;
+		nvme_ns_set_lba_count;
+		nvme_ns_get_lba_util;
+		nvme_ns_set_lba_util;
+		nvme_ctrl_get_name;
+		nvme_ctrl_get_sysfs_dir;
+		nvme_ctrl_get_firmware;
+		nvme_ctrl_get_model;
+		nvme_ctrl_get_numa_node;
+		nvme_ctrl_get_queue_count;
+		nvme_ctrl_get_serial;
+		nvme_ctrl_get_sqsize;
+		nvme_ctrl_get_transport;
+		nvme_ctrl_get_subsysnqn;
+		nvme_ctrl_get_traddr;
+		nvme_ctrl_get_trsvcid;
+		nvme_ctrl_get_dhchap_host_key;
+		nvme_ctrl_set_dhchap_host_key;
+		nvme_ctrl_get_dhchap_ctrl_key;
+		nvme_ctrl_set_dhchap_ctrl_key;
+		nvme_ctrl_get_keyring;
+		nvme_ctrl_set_keyring;
+		nvme_ctrl_get_tls_key_identity;
+		nvme_ctrl_set_tls_key_identity;
+		nvme_ctrl_get_tls_key;
+		nvme_ctrl_set_tls_key;
+		nvme_ctrl_get_cntrltype;
+		nvme_ctrl_get_cntlid;
+		nvme_ctrl_get_dctype;
+		nvme_ctrl_get_host_traddr;
+		nvme_ctrl_get_host_iface;
+		nvme_ctrl_get_discovery_ctrl;
+		nvme_ctrl_set_discovery_ctrl;
+		nvme_ctrl_get_unique_discovery_ctrl;
+		nvme_ctrl_set_unique_discovery_ctrl;
+		nvme_ctrl_get_discovered;
+		nvme_ctrl_set_discovered;
+		nvme_ctrl_get_persistent;
+		nvme_ctrl_set_persistent;
+		nvme_ctrl_get_phy_slot;
+		nvme_subsystem_get_name;
+		nvme_subsystem_get_sysfs_dir;
+		nvme_subsystem_get_subsysnqn;
+		nvme_subsystem_get_model;
+		nvme_subsystem_get_serial;
+		nvme_subsystem_get_firmware;
+		nvme_subsystem_get_subsystype;
+		nvme_subsystem_get_application;
+		nvme_subsystem_set_application;
+		nvme_subsystem_get_iopolicy;
+		nvme_subsystem_set_iopolicy;
+		nvme_host_get_hostnqn;
+		nvme_host_get_hostid;
+		nvme_host_get_dhchap_host_key;
+		nvme_host_set_dhchap_host_key;
+		nvme_host_get_hostsymname;
+		nvme_host_set_hostsymname;
+		nvme_host_get_pdc_enabled_valid;
+		nvme_host_set_pdc_enabled_valid;
+		nvme_fabric_options_get_cntlid;
+		nvme_fabric_options_set_cntlid;
+		nvme_fabric_options_get_concat;
+		nvme_fabric_options_set_concat;
+		nvme_fabric_options_get_ctrl_loss_tmo;
+		nvme_fabric_options_set_ctrl_loss_tmo;
+		nvme_fabric_options_get_data_digest;
+		nvme_fabric_options_set_data_digest;
+		nvme_fabric_options_get_dhchap_ctrl_secret;
+		nvme_fabric_options_set_dhchap_ctrl_secret;
+		nvme_fabric_options_get_dhchap_secret;
+		nvme_fabric_options_set_dhchap_secret;
+		nvme_fabric_options_get_disable_sqflow;
+		nvme_fabric_options_set_disable_sqflow;
+		nvme_fabric_options_get_discovery;
+		nvme_fabric_options_set_discovery;
+		nvme_fabric_options_get_duplicate_connect;
+		nvme_fabric_options_set_duplicate_connect;
+		nvme_fabric_options_get_fast_io_fail_tmo;
+		nvme_fabric_options_set_fast_io_fail_tmo;
+		nvme_fabric_options_get_hdr_digest;
+		nvme_fabric_options_set_hdr_digest;
+		nvme_fabric_options_get_host_iface;
+		nvme_fabric_options_set_host_iface;
+		nvme_fabric_options_get_host_traddr;
+		nvme_fabric_options_set_host_traddr;
+		nvme_fabric_options_get_hostid;
+		nvme_fabric_options_set_hostid;
+		nvme_fabric_options_get_hostnqn;
+		nvme_fabric_options_set_hostnqn;
+		nvme_fabric_options_get_instance;
+		nvme_fabric_options_set_instance;
+		nvme_fabric_options_get_keep_alive_tmo;
+		nvme_fabric_options_set_keep_alive_tmo;
+		nvme_fabric_options_get_keyring;
+		nvme_fabric_options_set_keyring;
+		nvme_fabric_options_get_nqn;
+		nvme_fabric_options_set_nqn;
+		nvme_fabric_options_get_nr_io_queues;
+		nvme_fabric_options_set_nr_io_queues;
+		nvme_fabric_options_get_nr_poll_queues;
+		nvme_fabric_options_set_nr_poll_queues;
+		nvme_fabric_options_get_nr_write_queues;
+		nvme_fabric_options_set_nr_write_queues;
+		nvme_fabric_options_get_queue_size;
+		nvme_fabric_options_set_queue_size;
+		nvme_fabric_options_get_reconnect_delay;
+		nvme_fabric_options_set_reconnect_delay;
+		nvme_fabric_options_get_tls;
+		nvme_fabric_options_set_tls;
+		nvme_fabric_options_get_tls_key;
+		nvme_fabric_options_set_tls_key;
+		nvme_fabric_options_get_tos;
+		nvme_fabric_options_set_tos;
+		nvme_fabric_options_get_traddr;
+		nvme_fabric_options_set_traddr;
+		nvme_fabric_options_get_transport;
+		nvme_fabric_options_set_transport;
+		nvme_fabric_options_get_trsvcid;
+		nvme_fabric_options_set_trsvcid;
+};
diff --git a/libnvme/src/libnvme.h b/libnvme/src/libnvme.h.in
similarity index 92%
rename from libnvme/src/libnvme.h
rename to libnvme/src/libnvme.h.in
index e7ed221685..8168a69933 100644
--- a/libnvme/src/libnvme.h
+++ b/libnvme/src/libnvme.h.in
@@ -15,16 +15,16 @@ extern "C" {
 #endif
 
 #include <nvme/cmds.h>
-#include <nvme/fabrics.h>
+@FABRICS_INCLUDE@
 #include <nvme/filters.h>
 #include <nvme/ioctl.h>
 #include <nvme/lib-types.h>
 #include <nvme/lib.h>
 #include <nvme/linux.h>
-#include <nvme/nbft.h>
 #include <nvme/tree.h>
 #include <nvme/types.h>
 #include <nvme/util.h>
+#include <nvme/accessors.h>
 
 #ifdef __cplusplus
 }
diff --git a/libnvme/src/libnvme.ld b/libnvme/src/libnvme.ld
index b3ae6fb992..86f96026dd 100644
--- a/libnvme/src/libnvme.ld
+++ b/libnvme/src/libnvme.ld
@@ -9,59 +9,28 @@ LIBNVME_UNRELEASED {
 		strsep;
 };
 
-LIBNVME_2_0 {
+LIBNVME_3 {
 	global:
 		nvme_clear_etdas;
 		nvme_close;
 		nvme_create_ctrl;
 		nvme_create_global_ctx;
-		nvme_ctrl_config_match;
+		nvme_ctrl_match_config;
 		nvme_ctrl_first_ns;
 		nvme_ctrl_first_path;
-		nvme_ctrl_get_address;
-		nvme_ctrl_get_cntlid;
 		nvme_ctrl_get_config;
-		nvme_ctrl_get_dhchap_host_key;
-		nvme_ctrl_get_dhchap_key;
-		nvme_ctrl_get_firmware;
-		nvme_ctrl_get_host_iface;
-		nvme_ctrl_get_host_traddr;
-		nvme_ctrl_get_keyring;
-		nvme_ctrl_get_model;
-		nvme_ctrl_get_name;
-		nvme_ctrl_get_numa_node;
 		nvme_ctrl_get_phy_slot;
-		nvme_ctrl_get_queue_count;
-		nvme_ctrl_get_serial;
-		nvme_ctrl_get_sqsize;
 		nvme_ctrl_get_src_addr;
 		nvme_ctrl_get_state;
 		nvme_ctrl_get_subsysnqn;
 		nvme_ctrl_get_subsystem;
-		nvme_ctrl_get_sysfs_dir;
-		nvme_ctrl_get_tls_key;
-		nvme_ctrl_get_tls_key_identity;
-		nvme_ctrl_get_traddr;
-		nvme_ctrl_get_transport;
 		nvme_ctrl_get_transport_handle;
-		nvme_ctrl_get_trsvcid;
 		nvme_ctrl_identify;
-		nvme_ctrl_is_discovery_ctrl;
-		nvme_ctrl_is_persistent;
-		nvme_ctrl_is_unique_discovery_ctrl;
 		nvme_ctrl_next_ns;
 		nvme_ctrl_next_path;
 		nvme_ctrl_release_transport_handle;
-		nvme_ctrl_reset;
-		nvme_ctrl_set_dhchap_host_key;
-		nvme_ctrl_set_dhchap_key;
-		nvme_ctrl_set_discovery_ctrl;
-		nvme_ctrl_set_keyring;
-		nvme_ctrl_set_persistent;
-		nvme_ctrl_set_tls_key;
-		nvme_ctrl_set_tls_key_identity;
-		nvme_ctrl_set_unique_discovery_ctrl;
-		nvme_ctrls_filter;
+		nvme_reset_ctrl;
+		nvme_filter_ctrls;
 		nvme_describe_key_serial;
 		nvme_disconnect_ctrl;
 		nvme_dump_config;
@@ -77,7 +46,6 @@ LIBNVME_2_0 {
 		nvme_free_ns;
 		nvme_free_subsystem;
 		nvme_fstat;
-		nvme_fw_download_seq;
 		nvme_gen_dhchap_key;
 		nvme_generate_tls_key_identity;
 		nvme_generate_tls_key_identity_compat;
@@ -98,33 +66,25 @@ LIBNVME_2_0 {
 		nvme_get_ns_attr;
 		nvme_get_nsid;
 		nvme_get_path_attr;
-		nvme_get_property;
 		nvme_get_subsys_attr;
 		nvme_get_telemetry_log;
 		nvme_get_telemetry_max;
 		nvme_get_uuid_list;
 		nvme_get_version;
-		nvme_host_get;
-		nvme_host_get_dhchap_key;
+		nvme_get_host;
 		nvme_host_get_global_ctx;
-		nvme_host_get_hostid;
-		nvme_host_get_hostnqn;
-		nvme_host_get_hostsymname;
 		nvme_host_get_ids;
 		nvme_host_is_pdc_enabled;
 		nvme_host_release_fds;
-		nvme_host_set_dhchap_key;
-		nvme_host_set_hostsymname;
 		nvme_host_set_pdc_enabled;
+		nvme_read_hostid;
+		nvme_generate_hostid;
+		nvme_read_hostnqn;
+		nvme_generate_hostnqn;
+		nvme_generate_hostnqn_from_hostid;
 		nvme_import_tls_key;
 		nvme_import_tls_key_versioned;
-		nvme_init_copy_range;
-		nvme_init_copy_range_f1;
-		nvme_init_copy_range_f2;
-		nvme_init_copy_range_f3;
 		nvme_init_ctrl;
-		nvme_init_ctrl_list;
-		nvme_init_dsm_range;
 		nvme_insert_tls_key;
 		nvme_insert_tls_key_compat;
 		nvme_insert_tls_key_versioned;
@@ -138,13 +98,11 @@ LIBNVME_2_0 {
 		nvme_mi_aem_get_next_event;
 		nvme_mi_aem_process;
 		nvme_mi_close;
-		nvme_mi_close_transport_handle;
 		nvme_mi_control;
 		nvme_mi_ctrl_id;
 		nvme_mi_endpoint_desc;
 		nvme_mi_ep_get_timeout;
 		nvme_mi_ep_set_timeout;
-		nvme_mi_first_ctrl;
 		nvme_mi_first_endpoint;
 		nvme_mi_init_transport_handle;
 		nvme_mi_mi_config_get;
@@ -155,7 +113,6 @@ LIBNVME_2_0 {
 		nvme_mi_mi_read_mi_data_subsys;
 		nvme_mi_mi_subsystem_health_status_poll;
 		nvme_mi_mi_xfer;
-		nvme_mi_next_ctrl;
 		nvme_mi_next_endpoint;
 		nvme_mi_open_mctp;
 		nvme_mi_scan_ep;
@@ -164,16 +121,13 @@ LIBNVME_2_0 {
 		nvme_mi_status_to_string;
 		nvme_mi_submit_entry;
 		nvme_mi_submit_exit;
-		nvme_namespace_attach_ctrls;
-		nvme_namespace_detach_ctrls;
-		nvme_namespace_filter;
+		nvme_filter_namespace;
 		nvme_namespace_first_path;
 		nvme_namespace_next_path;
-		nvme_nbft_free;
-		nvme_nbft_read;
+		nvme_free_nbft;
+		nvme_read_nbft;
 		nvme_next_host;
 		nvme_next_subsystem;
-		nvme_ns_attach;
 		nvme_ns_compare;
 		nvme_ns_flush;
 		nvme_ns_get_csi;
@@ -181,39 +135,27 @@ LIBNVME_2_0 {
 		nvme_ns_get_eui64;
 		nvme_ns_get_firmware;
 		nvme_ns_get_generic_name;
-		nvme_ns_get_lba_count;
-		nvme_ns_get_lba_size;
-		nvme_ns_get_lba_util;
-		nvme_ns_get_meta_size;
 		nvme_ns_get_model;
-		nvme_ns_get_name;
 		nvme_ns_get_nguid;
-		nvme_ns_get_nsid;
 		nvme_ns_get_serial;
 		nvme_ns_get_subsystem;
-		nvme_ns_get_sysfs_dir;
 		nvme_ns_get_uuid;
 		nvme_ns_identify;
 		nvme_ns_read;
-		nvme_ns_rescan;
+		nvme_rescan_ns;
 		nvme_ns_verify;
 		nvme_ns_write;
 		nvme_ns_write_uncorrectable;
 		nvme_ns_write_zeros;
 		nvme_open;
 		nvme_parse_uri;
-		nvme_path_get_ana_state;
 		nvme_path_get_ctrl;
-		nvme_path_get_name;
 		nvme_path_get_ns;
-		nvme_path_get_numa_nodes;
 		nvme_path_get_queue_depth;
-		nvme_path_get_sysfs_dir;
-		nvme_paths_filter;
+		nvme_filter_paths;
 		nvme_read_config;
 		nvme_read_key;
 		nvme_refresh_topology;
-		nvme_release_fds;
 		nvme_rescan_ctrl;
 		nvme_revoke_tls_key;
 		nvme_scan_ctrl;
@@ -231,35 +173,22 @@ LIBNVME_2_0 {
 		nvme_set_ioctl_probing;
 		nvme_set_keyring;
 		nvme_set_logging_level;
-		nvme_set_probe_enabled;
-		nvme_set_property;
-		nvme_set_root;
 		nvme_skip_namespaces;
 		nvme_status_to_errno;
 		nvme_status_to_string;
 		nvme_strerror;
 		nvme_submit_admin_passthru;
 		nvme_submit_io_passthru;
-		nvme_subsys_filter;
+		nvme_filter_subsys;
 		nvme_subsystem_first_ctrl;
 		nvme_subsystem_first_ns;
-		nvme_subsystem_get;
-		nvme_subsystem_get_application;
-		nvme_subsystem_get_fw_rev;
+		nvme_get_subsystem;
 		nvme_subsystem_get_host;
-		nvme_subsystem_get_iopolicy;
-		nvme_subsystem_get_model;
-		nvme_subsystem_get_name;
-		nvme_subsystem_get_nqn;
-		nvme_subsystem_get_serial;
-		nvme_subsystem_get_sysfs_dir;
-		nvme_subsystem_get_type;
 		nvme_subsystem_lookup_namespace;
 		nvme_subsystem_next_ctrl;
 		nvme_subsystem_next_ns;
 		nvme_subsystem_release_fds;
-		nvme_subsystem_reset;
-		nvme_subsystem_set_application;
+		nvme_reset_subsystem;
 		nvme_transport_handle_get_fd;
 		nvme_transport_handle_get_name;
 		nvme_transport_handle_is_blkdev;
@@ -271,79 +200,10 @@ LIBNVME_2_0 {
 		nvme_transport_handle_set_submit_exit;
 		nvme_unlink_ctrl;
 		nvme_update_key;
-		nvme_uuid_find;
+		nvme_find_uuid;
 		nvme_uuid_from_string;
-		nvme_uuid_random;
+		nvme_random_uuid;
 		nvme_uuid_to_string;
-		nvmf_add_ctrl;
-		nvmf_adrfam_str;
-		nvmf_cms_str;
-		nvmf_config_modify;
-		nvmf_connect;
-		nvmf_connect_config_json;
-		nvmf_connect_ctrl;
-		nvmf_context_create;
-		nvmf_context_set_connection;
-		nvmf_context_set_crypto;
-		nvmf_context_set_device;
-		nvmf_context_set_discovery_cbs;
-		nvmf_context_set_discovery_defaults;
-		nvmf_context_set_fabrics_config;
-		nvmf_context_set_hostnqn;
-		nvmf_context_set_persistent;
-		nvmf_default_config;
-		nvmf_discovery;
-		nvmf_discovery_config_file;
-		nvmf_discovery_config_json;
-		nvmf_discovery_ctx_already_connected_set;
-		nvmf_discovery_ctx_connected_set;
-		nvmf_discovery_ctx_create;
-		nvmf_discovery_ctx_ctrlkey_set;
-		nvmf_discovery_ctx_decide_retry_set;
-		nvmf_discovery_ctx_default_fabrics_config_set;
-		nvmf_discovery_ctx_device_set;
-		nvmf_discovery_ctx_discovery_log_set;
-		nvmf_discovery_ctx_host_iface_set;
-		nvmf_discovery_ctx_host_traddr_set;
-		nvmf_discovery_ctx_hostid_set;
-		nvmf_discovery_ctx_hostkey_set;
-		nvmf_discovery_ctx_hostnqn_set;
-		nvmf_discovery_ctx_keep_alive_timeout;
-		nvmf_discovery_ctx_keyring_set;
-		nvmf_discovery_ctx_max_retries;
-		nvmf_discovery_ctx_parser_cleanup_set;
-		nvmf_discovery_ctx_parser_init_set;
-		nvmf_discovery_ctx_parser_next_line_set;
-		nvmf_discovery_ctx_persistent_set;
-		nvmf_discovery_ctx_subsysnqn_set;
-		nvmf_discovery_ctx_tls_key_identity_set;
-		nvmf_discovery_ctx_tls_key_set;
-		nvmf_discovery_ctx_traddr_set;
-		nvmf_discovery_ctx_transport_set;
-		nvmf_discovery_ctx_trsvcid_set;
-		nvmf_discovery_nbft;
-		nvmf_eflags_str;
-		nvmf_exat_ptr_next;
-		nvmf_free_uri;
-		nvmf_get_default_trsvcid;
-		nvmf_get_discovery_log;
-		nvmf_get_discovery_wargs;
-		nvmf_hostid_from_file;
-		nvmf_hostid_generate;
-		nvmf_hostnqn_from_file;
-		nvmf_hostnqn_generate;
-		nvmf_hostnqn_generate_from_hostid;
-		nvmf_is_registration_supported;
-		nvmf_nbft_free;
-		nvmf_nbft_read_files;
-		nvmf_prtype_str;
-		nvmf_qptype_str;
-		nvmf_register_ctrl;
-		nvmf_sectype_str;
-		nvmf_subtype_str;
-		nvmf_treq_str;
-		nvmf_trtype_str;
-		nvmf_update_config;
 		platform_aligned_free;
 	local:
 		*;
diff --git a/libnvme/src/libnvmf.ld b/libnvme/src/libnvmf.ld
new file mode 100644
index 0000000000..806490b064
--- /dev/null
+++ b/libnvme/src/libnvmf.ld
@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+
+LIBNVMF_3 {
+	global:
+		nvmf_add_ctrl;
+		nvmf_adrfam_str;
+		nvmf_cms_str;
+		nvmf_config_modify;
+		nvmf_connect;
+		nvmf_connect_config_json;
+		nvmf_connect_ctrl;
+		nvmf_context_create;
+		nvmf_context_set_connection;
+		nvmf_context_set_crypto;
+		nvmf_context_set_device;
+		nvmf_context_set_discovery_cbs;
+		nvmf_context_set_discovery_defaults;
+		nvmf_context_set_fabrics_config;
+		nvmf_context_set_hostnqn;
+		nvmf_context_set_persistent;
+		nvmf_default_config;
+		nvmf_discovery;
+		nvmf_discovery_config_file;
+		nvmf_discovery_config_json;
+		nvmf_discovery_nbft;
+		nvmf_eflags_str;
+		nvmf_exat_ptr_next;
+		nvmf_free_uri;
+		nvmf_get_default_trsvcid;
+		nvmf_get_discovery_log;
+		nvmf_get_discovery_wargs;
+		nvmf_is_registration_supported;
+		nvmf_nbft_free;
+		nvmf_nbft_read_files;
+		nvmf_prtype_str;
+		nvmf_qptype_str;
+		nvmf_register_ctrl;
+		nvmf_sectype_str;
+		nvmf_subtype_str;
+		nvmf_treq_str;
+		nvmf_trtype_str;
+		nvmf_update_config;
+	local:
+		*;
+};
diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index ee87030351..be53ae54e2 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -12,7 +12,6 @@ sources = [
     'nvme/ioctl.c',
     'nvme/lib.c',
     'nvme/log.c',
-    'nvme/nbft.c',
     'nvme/tree.c',
     'nvme/util.c',
 ]
@@ -26,31 +25,55 @@ if is_windows
     ]
 else
     sources += [
+        'nvme/accessors.c',
         'nvme/linux.c',
-        'nvme/fabrics.c',
-        'nvme/filters.c',
         'nvme/mi-mctp.c',
         'nvme/mi.c',
         'nvme/sysfs.c',
     ]
 endif
 
+headers = [
+    'nvme/accessors.h',
+    'nvme/cmds.h',
+    'nvme/filters.h',
+    'nvme/ioctl.h',
+    'nvme/lib-types.h',
+    'nvme/lib.h',
+    'nvme/linux.h',
+    'nvme/mi.h',
+    'nvme/tree.h',
+    'nvme/types.h',
+    'nvme/util.h',
+]
+
+if want_fabrics
+    sources += [
+        'nvme/fabrics.c',
+        'nvme/nbft.c',
+    ]
+    headers += [
+        'nvme/fabrics.h',
+        'nvme/nbft.h',
+    ]
+endif
+
+if liburing_dep.found()
+    sources += 'nvme/uring.c'
+endif
+
 if json_c_dep.found()
     sources += 'nvme/json.c'
 else
     sources += 'nvme/no-json.c'
 endif
 
-# Generate accessors (setter/getter functions)
-subdir('nvme')  # declares: accessors_dep, accessors_ld_full_path
-
 deps = [
     config_dep,
     ccan_dep,
     json_c_dep,
     keyutils_dep,
     openssl_dep,
-    accessors_dep,
 ]
 if is_windows
     deps += [
@@ -65,23 +88,43 @@ else
     ]
 endif
 
-ldfile = 'libnvme.ld'
+nvme_ld = meson.current_source_dir() / 'libnvme.ld'
+nvmf_ld = meson.current_source_dir() / 'libnvmf.ld'
+accessors_ld = meson.current_source_dir() / 'accessors.ld'
 
-libnvme_link_args = [
-    '-Wl,--version-script=@0@'.format(meson.current_source_dir() / ldfile),
+link_args = [
+    '-Wl,--version-script=@0@'.format(nvme_ld),
 ]
 # Skipping accessor generation for now on Windows. Needs to be ported.
 if not is_windows
     libnvme_link_args += [
-        '-Wl,--version-script=@0@'.format(accessors_ld_full_path),
+        '-Wl,--version-script=@0@'.format(accessors_ld),
     ]
 endif
 
+libconf = configuration_data()
+if want_fabrics
+    link_args += '-Wl,--version-script=@0@'.format(nvmf_ld)
+    libconf.set('FABRICS_INCLUDE',
+                '#include <nvme/fabrics.h>\n#include <nvme/nbft.h>')
+else
+    libconf.set('FABRICS_INCLUDE', '')
+endif
+
+libnvme_header = configure_file(
+    input: 'libnvme.h.in',
+    output: 'libnvme.h',
+    configuration: libconf,
+    install: true,
+    install_dir: prefixdir / get_option('includedir')
+)
+
 libnvme = library(
     'nvme', # produces libnvme.so
     sources,
     version: libnvme_so_version,
-    link_args: libnvme_link_args,
+    c_args: ['-fvisibility=hidden'],
+    link_args: link_args,
     dependencies: deps,
     install: true,
 )
@@ -120,26 +163,12 @@ libnvme_test_dep = declare_dependency(
 mode = 'rw-r--r--'
 install_headers(
     [
-       'libnvme.h',
        'libnvme-mi.h',
     ],
     install_mode: mode,
 )
 install_headers(
-    [
-        'nvme/cmds.h',
-        'nvme/fabrics.h',
-        'nvme/filters.h',
-        'nvme/ioctl.h',
-        'nvme/lib-types.h',
-        'nvme/lib.h',
-        'nvme/linux.h',
-        'nvme/mi.h',
-        'nvme/nbft.h',
-        'nvme/tree.h',
-        'nvme/types.h',
-        'nvme/util.h',
-    ],
+    headers,
     subdir: 'nvme',
     install_mode: mode,
 )
diff --git a/libnvme/src/nvme/accessors.c b/libnvme/src/nvme/accessors.c
new file mode 100644
index 0000000000..d3c507d7ed
--- /dev/null
+++ b/libnvme/src/nvme/accessors.c
@@ -0,0 +1,888 @@
+// 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>
+ *
+ *   ____                           _           _    ____          _
+ *  / ___| ___ _ __   ___ _ __ __ _| |_ ___  __| |  / ___|___   __| | ___
+ * | |  _ / _ \ '_ \ / _ \ '__/ _` | __/ _ \/ _` | | |   / _ \ / _` |/ _ \
+ * | |_| |  __/ | | |  __/ | | (_| | ||  __/ (_| | | |__| (_) | (_| |  __/
+ *  \____|\___|_| |_|\___|_|  \__,_|\__\___|\__,_|  \____\___/ \__,_|\___|
+ *
+ * Auto-generated struct member accessors (setter/getter)
+ *
+ * To update run: meson compile -C [BUILD-DIR] update-accessors
+ * Or:            make update-accessors
+ */
+#include <stdlib.h>
+#include <string.h>
+#include "accessors.h"
+
+#include "private.h"
+#include "compiler_attributes.h"
+
+/****************************************************************************
+ * Accessors for: struct nvme_path
+ ****************************************************************************/
+
+__public void nvme_path_set_name(struct nvme_path *p, const char *name)
+{
+	free(p->name);
+	p->name = name ? strdup(name) : NULL;
+}
+
+__public const char *nvme_path_get_name(const struct nvme_path *p)
+{
+	return p->name;
+}
+
+__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;
+}
+
+__public const char *nvme_path_get_sysfs_dir(const struct nvme_path *p)
+{
+	return p->sysfs_dir;
+}
+
+__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;
+}
+
+__public const char *nvme_path_get_ana_state(const struct nvme_path *p)
+{
+	return p->ana_state;
+}
+
+__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;
+}
+
+__public const char *nvme_path_get_numa_nodes(const struct nvme_path *p)
+{
+	return p->numa_nodes;
+}
+
+__public void nvme_path_set_grpid(struct nvme_path *p, int grpid)
+{
+	p->grpid = grpid;
+}
+
+__public int nvme_path_get_grpid(const struct nvme_path *p)
+{
+	return p->grpid;
+}
+
+/****************************************************************************
+ * Accessors for: struct nvme_ns
+ ****************************************************************************/
+
+__public void nvme_ns_set_nsid(struct nvme_ns *p, __u32 nsid)
+{
+	p->nsid = nsid;
+}
+
+__public __u32 nvme_ns_get_nsid(const struct nvme_ns *p)
+{
+	return p->nsid;
+}
+
+__public void nvme_ns_set_name(struct nvme_ns *p, const char *name)
+{
+	free(p->name);
+	p->name = name ? strdup(name) : NULL;
+}
+
+__public const char *nvme_ns_get_name(const struct nvme_ns *p)
+{
+	return p->name;
+}
+
+__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;
+}
+
+__public const char *nvme_ns_get_sysfs_dir(const struct nvme_ns *p)
+{
+	return p->sysfs_dir;
+}
+
+__public void nvme_ns_set_lba_shift(struct nvme_ns *p, int lba_shift)
+{
+	p->lba_shift = lba_shift;
+}
+
+__public int nvme_ns_get_lba_shift(const struct nvme_ns *p)
+{
+	return p->lba_shift;
+}
+
+__public void nvme_ns_set_lba_size(struct nvme_ns *p, int lba_size)
+{
+	p->lba_size = lba_size;
+}
+
+__public int nvme_ns_get_lba_size(const struct nvme_ns *p)
+{
+	return p->lba_size;
+}
+
+__public void nvme_ns_set_meta_size(struct nvme_ns *p, int meta_size)
+{
+	p->meta_size = meta_size;
+}
+
+__public int nvme_ns_get_meta_size(const struct nvme_ns *p)
+{
+	return p->meta_size;
+}
+
+__public void nvme_ns_set_lba_count(struct nvme_ns *p, uint64_t lba_count)
+{
+	p->lba_count = lba_count;
+}
+
+__public uint64_t nvme_ns_get_lba_count(const struct nvme_ns *p)
+{
+	return p->lba_count;
+}
+
+__public void nvme_ns_set_lba_util(struct nvme_ns *p, uint64_t lba_util)
+{
+	p->lba_util = lba_util;
+}
+
+__public uint64_t nvme_ns_get_lba_util(const struct nvme_ns *p)
+{
+	return p->lba_util;
+}
+
+/****************************************************************************
+ * Accessors for: struct nvme_ctrl
+ ****************************************************************************/
+
+__public const char *nvme_ctrl_get_name(const struct nvme_ctrl *p)
+{
+	return p->name;
+}
+
+__public const char *nvme_ctrl_get_sysfs_dir(const struct nvme_ctrl *p)
+{
+	return p->sysfs_dir;
+}
+
+__public const char *nvme_ctrl_get_firmware(const struct nvme_ctrl *p)
+{
+	return p->firmware;
+}
+
+__public const char *nvme_ctrl_get_model(const struct nvme_ctrl *p)
+{
+	return p->model;
+}
+
+__public const char *nvme_ctrl_get_numa_node(const struct nvme_ctrl *p)
+{
+	return p->numa_node;
+}
+
+__public const char *nvme_ctrl_get_queue_count(const struct nvme_ctrl *p)
+{
+	return p->queue_count;
+}
+
+__public const char *nvme_ctrl_get_serial(const struct nvme_ctrl *p)
+{
+	return p->serial;
+}
+
+__public const char *nvme_ctrl_get_sqsize(const struct nvme_ctrl *p)
+{
+	return p->sqsize;
+}
+
+__public const char *nvme_ctrl_get_transport(const struct nvme_ctrl *p)
+{
+	return p->transport;
+}
+
+__public const char *nvme_ctrl_get_subsysnqn(const struct nvme_ctrl *p)
+{
+	return p->subsysnqn;
+}
+
+__public const char *nvme_ctrl_get_traddr(const struct nvme_ctrl *p)
+{
+	return p->traddr;
+}
+
+__public const char *nvme_ctrl_get_trsvcid(const struct nvme_ctrl *p)
+{
+	return p->trsvcid;
+}
+
+__public void nvme_ctrl_set_dhchap_host_key(
+		struct nvme_ctrl *p,
+		const char *dhchap_host_key)
+{
+	free(p->dhchap_host_key);
+	p->dhchap_host_key = dhchap_host_key ? strdup(dhchap_host_key) : NULL;
+}
+
+__public const char *nvme_ctrl_get_dhchap_host_key(const struct nvme_ctrl *p)
+{
+	return p->dhchap_host_key;
+}
+
+__public void nvme_ctrl_set_dhchap_ctrl_key(
+		struct nvme_ctrl *p,
+		const char *dhchap_ctrl_key)
+{
+	free(p->dhchap_ctrl_key);
+	p->dhchap_ctrl_key = dhchap_ctrl_key ? strdup(dhchap_ctrl_key) : NULL;
+}
+
+__public const char *nvme_ctrl_get_dhchap_ctrl_key(const struct nvme_ctrl *p)
+{
+	return p->dhchap_ctrl_key;
+}
+
+__public void nvme_ctrl_set_keyring(struct nvme_ctrl *p, const char *keyring)
+{
+	free(p->keyring);
+	p->keyring = keyring ? strdup(keyring) : NULL;
+}
+
+__public const char *nvme_ctrl_get_keyring(const struct nvme_ctrl *p)
+{
+	return p->keyring;
+}
+
+__public void nvme_ctrl_set_tls_key_identity(
+		struct nvme_ctrl *p,
+		const char *tls_key_identity)
+{
+	free(p->tls_key_identity);
+	p->tls_key_identity =
+		tls_key_identity ? strdup(tls_key_identity) : NULL;
+}
+
+__public const char *nvme_ctrl_get_tls_key_identity(const struct nvme_ctrl *p)
+{
+	return p->tls_key_identity;
+}
+
+__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;
+}
+
+__public const char *nvme_ctrl_get_tls_key(const struct nvme_ctrl *p)
+{
+	return p->tls_key;
+}
+
+__public const char *nvme_ctrl_get_cntrltype(const struct nvme_ctrl *p)
+{
+	return p->cntrltype;
+}
+
+__public const char *nvme_ctrl_get_cntlid(const struct nvme_ctrl *p)
+{
+	return p->cntlid;
+}
+
+__public const char *nvme_ctrl_get_dctype(const struct nvme_ctrl *p)
+{
+	return p->dctype;
+}
+
+__public const char *nvme_ctrl_get_phy_slot(const struct nvme_ctrl *p)
+{
+	return p->phy_slot;
+}
+
+__public const char *nvme_ctrl_get_host_traddr(const struct nvme_ctrl *p)
+{
+	return p->host_traddr;
+}
+
+__public const char *nvme_ctrl_get_host_iface(const struct nvme_ctrl *p)
+{
+	return p->host_iface;
+}
+
+__public void nvme_ctrl_set_discovery_ctrl(
+		struct nvme_ctrl *p,
+		bool discovery_ctrl)
+{
+	p->discovery_ctrl = discovery_ctrl;
+}
+
+__public bool nvme_ctrl_get_discovery_ctrl(const struct nvme_ctrl *p)
+{
+	return p->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;
+}
+
+__public bool nvme_ctrl_get_unique_discovery_ctrl(const struct nvme_ctrl *p)
+{
+	return p->unique_discovery_ctrl;
+}
+
+__public void nvme_ctrl_set_discovered(struct nvme_ctrl *p, bool discovered)
+{
+	p->discovered = discovered;
+}
+
+__public bool nvme_ctrl_get_discovered(const struct nvme_ctrl *p)
+{
+	return p->discovered;
+}
+
+__public void nvme_ctrl_set_persistent(struct nvme_ctrl *p, bool persistent)
+{
+	p->persistent = persistent;
+}
+
+__public bool nvme_ctrl_get_persistent(const struct nvme_ctrl *p)
+{
+	return p->persistent;
+}
+
+/****************************************************************************
+ * Accessors for: struct nvme_subsystem
+ ****************************************************************************/
+
+__public const char *nvme_subsystem_get_name(const struct nvme_subsystem *p)
+{
+	return p->name;
+}
+
+__public const char *nvme_subsystem_get_sysfs_dir(
+		const struct nvme_subsystem *p)
+{
+	return p->sysfs_dir;
+}
+
+__public const char *nvme_subsystem_get_subsysnqn(
+		const struct nvme_subsystem *p)
+{
+	return p->subsysnqn;
+}
+
+__public const char *nvme_subsystem_get_model(const struct nvme_subsystem *p)
+{
+	return p->model;
+}
+
+__public const char *nvme_subsystem_get_serial(const struct nvme_subsystem *p)
+{
+	return p->serial;
+}
+
+__public const char *nvme_subsystem_get_firmware(const struct nvme_subsystem *p)
+{
+	return p->firmware;
+}
+
+__public const char *nvme_subsystem_get_subsystype(
+		const struct nvme_subsystem *p)
+{
+	return p->subsystype;
+}
+
+__public void nvme_subsystem_set_application(
+		struct nvme_subsystem *p,
+		const char *application)
+{
+	free(p->application);
+	p->application = application ? strdup(application) : NULL;
+}
+
+__public const char *nvme_subsystem_get_application(
+		const struct nvme_subsystem *p)
+{
+	return p->application;
+}
+
+__public void nvme_subsystem_set_iopolicy(
+		struct nvme_subsystem *p,
+		const char *iopolicy)
+{
+	free(p->iopolicy);
+	p->iopolicy = iopolicy ? strdup(iopolicy) : NULL;
+}
+
+__public const char *nvme_subsystem_get_iopolicy(const struct nvme_subsystem *p)
+{
+	return p->iopolicy;
+}
+
+/****************************************************************************
+ * Accessors for: struct nvme_host
+ ****************************************************************************/
+
+__public const char *nvme_host_get_hostnqn(const struct nvme_host *p)
+{
+	return p->hostnqn;
+}
+
+__public const char *nvme_host_get_hostid(const struct nvme_host *p)
+{
+	return p->hostid;
+}
+
+__public void nvme_host_set_dhchap_host_key(
+		struct nvme_host *p,
+		const char *dhchap_host_key)
+{
+	free(p->dhchap_host_key);
+	p->dhchap_host_key = dhchap_host_key ? strdup(dhchap_host_key) : NULL;
+}
+
+__public const char *nvme_host_get_dhchap_host_key(const struct nvme_host *p)
+{
+	return p->dhchap_host_key;
+}
+
+__public void nvme_host_set_hostsymname(
+		struct nvme_host *p,
+		const char *hostsymname)
+{
+	free(p->hostsymname);
+	p->hostsymname = hostsymname ? strdup(hostsymname) : NULL;
+}
+
+__public const char *nvme_host_get_hostsymname(const struct nvme_host *p)
+{
+	return p->hostsymname;
+}
+
+__public void nvme_host_set_pdc_enabled_valid(
+		struct nvme_host *p,
+		bool pdc_enabled_valid)
+{
+	p->pdc_enabled_valid = pdc_enabled_valid;
+}
+
+__public bool nvme_host_get_pdc_enabled_valid(const struct nvme_host *p)
+{
+	return p->pdc_enabled_valid;
+}
+
+/****************************************************************************
+ * Accessors for: struct nvme_fabric_options
+ ****************************************************************************/
+
+__public void nvme_fabric_options_set_cntlid(
+		struct nvme_fabric_options *p,
+		bool cntlid)
+{
+	p->cntlid = cntlid;
+}
+
+__public bool nvme_fabric_options_get_cntlid(
+		const struct nvme_fabric_options *p)
+{
+	return p->cntlid;
+}
+
+__public void nvme_fabric_options_set_concat(
+		struct nvme_fabric_options *p,
+		bool concat)
+{
+	p->concat = concat;
+}
+
+__public bool nvme_fabric_options_get_concat(
+		const struct nvme_fabric_options *p)
+{
+	return p->concat;
+}
+
+__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;
+}
+
+__public bool nvme_fabric_options_get_ctrl_loss_tmo(
+		const struct nvme_fabric_options *p)
+{
+	return p->ctrl_loss_tmo;
+}
+
+__public void nvme_fabric_options_set_data_digest(
+		struct nvme_fabric_options *p,
+		bool data_digest)
+{
+	p->data_digest = data_digest;
+}
+
+__public bool nvme_fabric_options_get_data_digest(
+		const struct nvme_fabric_options *p)
+{
+	return p->data_digest;
+}
+
+__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;
+}
+
+__public bool nvme_fabric_options_get_dhchap_ctrl_secret(
+		const struct nvme_fabric_options *p)
+{
+	return p->dhchap_ctrl_secret;
+}
+
+__public void nvme_fabric_options_set_dhchap_secret(
+		struct nvme_fabric_options *p,
+		bool dhchap_secret)
+{
+	p->dhchap_secret = dhchap_secret;
+}
+
+__public bool nvme_fabric_options_get_dhchap_secret(
+		const struct nvme_fabric_options *p)
+{
+	return p->dhchap_secret;
+}
+
+__public void nvme_fabric_options_set_disable_sqflow(
+		struct nvme_fabric_options *p,
+		bool disable_sqflow)
+{
+	p->disable_sqflow = disable_sqflow;
+}
+
+__public bool nvme_fabric_options_get_disable_sqflow(
+		const struct nvme_fabric_options *p)
+{
+	return p->disable_sqflow;
+}
+
+__public void nvme_fabric_options_set_discovery(
+		struct nvme_fabric_options *p,
+		bool discovery)
+{
+	p->discovery = discovery;
+}
+
+__public bool nvme_fabric_options_get_discovery(
+		const struct nvme_fabric_options *p)
+{
+	return p->discovery;
+}
+
+__public void nvme_fabric_options_set_duplicate_connect(
+		struct nvme_fabric_options *p,
+		bool duplicate_connect)
+{
+	p->duplicate_connect = duplicate_connect;
+}
+
+__public bool nvme_fabric_options_get_duplicate_connect(
+		const struct nvme_fabric_options *p)
+{
+	return p->duplicate_connect;
+}
+
+__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;
+}
+
+__public bool nvme_fabric_options_get_fast_io_fail_tmo(
+		const struct nvme_fabric_options *p)
+{
+	return p->fast_io_fail_tmo;
+}
+
+__public void nvme_fabric_options_set_hdr_digest(
+		struct nvme_fabric_options *p,
+		bool hdr_digest)
+{
+	p->hdr_digest = hdr_digest;
+}
+
+__public bool nvme_fabric_options_get_hdr_digest(
+		const struct nvme_fabric_options *p)
+{
+	return p->hdr_digest;
+}
+
+__public void nvme_fabric_options_set_host_iface(
+		struct nvme_fabric_options *p,
+		bool host_iface)
+{
+	p->host_iface = host_iface;
+}
+
+__public bool nvme_fabric_options_get_host_iface(
+		const struct nvme_fabric_options *p)
+{
+	return p->host_iface;
+}
+
+__public void nvme_fabric_options_set_host_traddr(
+		struct nvme_fabric_options *p,
+		bool host_traddr)
+{
+	p->host_traddr = host_traddr;
+}
+
+__public bool nvme_fabric_options_get_host_traddr(
+		const struct nvme_fabric_options *p)
+{
+	return p->host_traddr;
+}
+
+__public void nvme_fabric_options_set_hostid(
+		struct nvme_fabric_options *p,
+		bool hostid)
+{
+	p->hostid = hostid;
+}
+
+__public bool nvme_fabric_options_get_hostid(
+		const struct nvme_fabric_options *p)
+{
+	return p->hostid;
+}
+
+__public void nvme_fabric_options_set_hostnqn(
+		struct nvme_fabric_options *p,
+		bool hostnqn)
+{
+	p->hostnqn = hostnqn;
+}
+
+__public bool nvme_fabric_options_get_hostnqn(
+		const struct nvme_fabric_options *p)
+{
+	return p->hostnqn;
+}
+
+__public void nvme_fabric_options_set_instance(
+		struct nvme_fabric_options *p,
+		bool instance)
+{
+	p->instance = instance;
+}
+
+__public bool nvme_fabric_options_get_instance(
+		const struct nvme_fabric_options *p)
+{
+	return p->instance;
+}
+
+__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;
+}
+
+__public bool nvme_fabric_options_get_keep_alive_tmo(
+		const struct nvme_fabric_options *p)
+{
+	return p->keep_alive_tmo;
+}
+
+__public void nvme_fabric_options_set_keyring(
+		struct nvme_fabric_options *p,
+		bool keyring)
+{
+	p->keyring = keyring;
+}
+
+__public bool nvme_fabric_options_get_keyring(
+		const struct nvme_fabric_options *p)
+{
+	return p->keyring;
+}
+
+__public void nvme_fabric_options_set_nqn(
+		struct nvme_fabric_options *p,
+		bool nqn)
+{
+	p->nqn = nqn;
+}
+
+__public bool nvme_fabric_options_get_nqn(const struct nvme_fabric_options *p)
+{
+	return p->nqn;
+}
+
+__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;
+}
+
+__public bool nvme_fabric_options_get_nr_io_queues(
+		const struct nvme_fabric_options *p)
+{
+	return p->nr_io_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;
+}
+
+__public bool nvme_fabric_options_get_nr_poll_queues(
+		const struct nvme_fabric_options *p)
+{
+	return p->nr_poll_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;
+}
+
+__public bool nvme_fabric_options_get_nr_write_queues(
+		const struct nvme_fabric_options *p)
+{
+	return p->nr_write_queues;
+}
+
+__public void nvme_fabric_options_set_queue_size(
+		struct nvme_fabric_options *p,
+		bool queue_size)
+{
+	p->queue_size = queue_size;
+}
+
+__public bool nvme_fabric_options_get_queue_size(
+		const struct nvme_fabric_options *p)
+{
+	return p->queue_size;
+}
+
+__public void nvme_fabric_options_set_reconnect_delay(
+		struct nvme_fabric_options *p,
+		bool reconnect_delay)
+{
+	p->reconnect_delay = reconnect_delay;
+}
+
+__public bool nvme_fabric_options_get_reconnect_delay(
+		const struct nvme_fabric_options *p)
+{
+	return p->reconnect_delay;
+}
+
+__public void nvme_fabric_options_set_tls(
+		struct nvme_fabric_options *p,
+		bool tls)
+{
+	p->tls = tls;
+}
+
+__public bool nvme_fabric_options_get_tls(const struct nvme_fabric_options *p)
+{
+	return p->tls;
+}
+
+__public void nvme_fabric_options_set_tls_key(
+		struct nvme_fabric_options *p,
+		bool tls_key)
+{
+	p->tls_key = tls_key;
+}
+
+__public bool nvme_fabric_options_get_tls_key(
+		const struct nvme_fabric_options *p)
+{
+	return p->tls_key;
+}
+
+__public void nvme_fabric_options_set_tos(
+		struct nvme_fabric_options *p,
+		bool tos)
+{
+	p->tos = tos;
+}
+
+__public bool nvme_fabric_options_get_tos(const struct nvme_fabric_options *p)
+{
+	return p->tos;
+}
+
+__public void nvme_fabric_options_set_traddr(
+		struct nvme_fabric_options *p,
+		bool traddr)
+{
+	p->traddr = traddr;
+}
+
+__public bool nvme_fabric_options_get_traddr(
+		const struct nvme_fabric_options *p)
+{
+	return p->traddr;
+}
+
+__public void nvme_fabric_options_set_transport(
+		struct nvme_fabric_options *p,
+		bool transport)
+{
+	p->transport = transport;
+}
+
+__public bool nvme_fabric_options_get_transport(
+		const struct nvme_fabric_options *p)
+{
+	return p->transport;
+}
+
+__public void nvme_fabric_options_set_trsvcid(
+		struct nvme_fabric_options *p,
+		bool trsvcid)
+{
+	p->trsvcid = trsvcid;
+}
+
+__public bool nvme_fabric_options_get_trsvcid(
+		const struct nvme_fabric_options *p)
+{
+	return p->trsvcid;
+}
+
diff --git a/libnvme/src/nvme/accessors.h b/libnvme/src/nvme/accessors.h
new file mode 100644
index 0000000000..5c594dd127
--- /dev/null
+++ b/libnvme/src/nvme/accessors.h
@@ -0,0 +1,1202 @@
+/* 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>
+ *
+ *   ____                           _           _    ____          _
+ *  / ___| ___ _ __   ___ _ __ __ _| |_ ___  __| |  / ___|___   __| | ___
+ * | |  _ / _ \ '_ \ / _ \ '__/ _` | __/ _ \/ _` | | |   / _ \ / _` |/ _ \
+ * | |_| |  __/ | | |  __/ | | (_| | ||  __/ (_| | | |__| (_) | (_| |  __/
+ *  \____|\___|_| |_|\___|_|  \__,_|\__\___|\__,_|  \____\___/ \__,_|\___|
+ *
+ * Auto-generated struct member accessors (setter/getter)
+ *
+ * To update run: meson compile -C [BUILD-DIR] update-accessors
+ * Or:            make update-accessors
+ */
+#ifndef _ACCESSORS_H_
+#define _ACCESSORS_H_
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <linux/types.h> /* __u32, __u64, etc. */
+
+/* Forward declarations. These are internal (opaque) structs. */
+struct nvme_path;
+struct nvme_ns;
+struct nvme_ctrl;
+struct nvme_subsystem;
+struct nvme_host;
+struct nvme_fabric_options;
+
+/****************************************************************************
+ * Accessors for: struct nvme_path
+ ****************************************************************************/
+
+/**
+ * nvme_path_set_name() - Set name.
+ * @p: The &struct nvme_path instance to update.
+ * @name: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_path_set_name(struct nvme_path *p, const char *name);
+
+/**
+ * nvme_path_get_name() - Get name.
+ * @p: The &struct nvme_path instance to query.
+ *
+ * Return: The value of the name field, or NULL if not set.
+ */
+const char *nvme_path_get_name(const struct nvme_path *p);
+
+/**
+ * nvme_path_set_sysfs_dir() - Set sysfs_dir.
+ * @p: The &struct nvme_path instance to update.
+ * @sysfs_dir: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_path_set_sysfs_dir(struct nvme_path *p, const char *sysfs_dir);
+
+/**
+ * nvme_path_get_sysfs_dir() - Get sysfs_dir.
+ * @p: The &struct nvme_path instance to query.
+ *
+ * Return: The value of the sysfs_dir field, or NULL if not set.
+ */
+const char *nvme_path_get_sysfs_dir(const struct nvme_path *p);
+
+/**
+ * nvme_path_set_ana_state() - Set ana_state.
+ * @p: The &struct nvme_path instance to update.
+ * @ana_state: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_path_set_ana_state(struct nvme_path *p, const char *ana_state);
+
+/**
+ * nvme_path_get_ana_state() - Get ana_state.
+ * @p: The &struct nvme_path instance to query.
+ *
+ * Return: The value of the ana_state field, or NULL if not set.
+ */
+const char *nvme_path_get_ana_state(const struct nvme_path *p);
+
+/**
+ * nvme_path_set_numa_nodes() - Set numa_nodes.
+ * @p: The &struct nvme_path instance to update.
+ * @numa_nodes: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_path_set_numa_nodes(struct nvme_path *p, const char *numa_nodes);
+
+/**
+ * nvme_path_get_numa_nodes() - Get numa_nodes.
+ * @p: The &struct nvme_path instance to query.
+ *
+ * Return: The value of the numa_nodes field, or NULL if not set.
+ */
+const char *nvme_path_get_numa_nodes(const struct nvme_path *p);
+
+/**
+ * nvme_path_set_grpid() - Set grpid.
+ * @p: The &struct nvme_path instance to update.
+ * @grpid: Value to assign to the grpid field.
+ */
+void nvme_path_set_grpid(struct nvme_path *p, int grpid);
+
+/**
+ * nvme_path_get_grpid() - Get grpid.
+ * @p: The &struct nvme_path instance to query.
+ *
+ * Return: The value of the grpid field.
+ */
+int nvme_path_get_grpid(const struct nvme_path *p);
+
+/****************************************************************************
+ * Accessors for: struct nvme_ns
+ ****************************************************************************/
+
+/**
+ * nvme_ns_set_nsid() - Set nsid.
+ * @p: The &struct nvme_ns instance to update.
+ * @nsid: Value to assign to the nsid field.
+ */
+void nvme_ns_set_nsid(struct nvme_ns *p, __u32 nsid);
+
+/**
+ * nvme_ns_get_nsid() - Get nsid.
+ * @p: The &struct nvme_ns instance to query.
+ *
+ * Return: The value of the nsid field.
+ */
+__u32 nvme_ns_get_nsid(const struct nvme_ns *p);
+
+/**
+ * nvme_ns_set_name() - Set name.
+ * @p: The &struct nvme_ns instance to update.
+ * @name: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_ns_set_name(struct nvme_ns *p, const char *name);
+
+/**
+ * nvme_ns_get_name() - Get name.
+ * @p: The &struct nvme_ns instance to query.
+ *
+ * Return: The value of the name field, or NULL if not set.
+ */
+const char *nvme_ns_get_name(const struct nvme_ns *p);
+
+/**
+ * nvme_ns_set_sysfs_dir() - Set sysfs_dir.
+ * @p: The &struct nvme_ns instance to update.
+ * @sysfs_dir: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_ns_set_sysfs_dir(struct nvme_ns *p, const char *sysfs_dir);
+
+/**
+ * nvme_ns_get_sysfs_dir() - Get sysfs_dir.
+ * @p: The &struct nvme_ns instance to query.
+ *
+ * Return: The value of the sysfs_dir field, or NULL if not set.
+ */
+const char *nvme_ns_get_sysfs_dir(const struct nvme_ns *p);
+
+/**
+ * nvme_ns_set_lba_shift() - Set lba_shift.
+ * @p: The &struct nvme_ns instance to update.
+ * @lba_shift: Value to assign to the lba_shift field.
+ */
+void nvme_ns_set_lba_shift(struct nvme_ns *p, int lba_shift);
+
+/**
+ * nvme_ns_get_lba_shift() - Get lba_shift.
+ * @p: The &struct nvme_ns instance to query.
+ *
+ * Return: The value of the lba_shift field.
+ */
+int nvme_ns_get_lba_shift(const struct nvme_ns *p);
+
+/**
+ * nvme_ns_set_lba_size() - Set lba_size.
+ * @p: The &struct nvme_ns instance to update.
+ * @lba_size: Value to assign to the lba_size field.
+ */
+void nvme_ns_set_lba_size(struct nvme_ns *p, int lba_size);
+
+/**
+ * nvme_ns_get_lba_size() - Get lba_size.
+ * @p: The &struct nvme_ns instance to query.
+ *
+ * Return: The value of the lba_size field.
+ */
+int nvme_ns_get_lba_size(const struct nvme_ns *p);
+
+/**
+ * nvme_ns_set_meta_size() - Set meta_size.
+ * @p: The &struct nvme_ns instance to update.
+ * @meta_size: Value to assign to the meta_size field.
+ */
+void nvme_ns_set_meta_size(struct nvme_ns *p, int meta_size);
+
+/**
+ * nvme_ns_get_meta_size() - Get meta_size.
+ * @p: The &struct nvme_ns instance to query.
+ *
+ * Return: The value of the meta_size field.
+ */
+int nvme_ns_get_meta_size(const struct nvme_ns *p);
+
+/**
+ * nvme_ns_set_lba_count() - Set lba_count.
+ * @p: The &struct nvme_ns instance to update.
+ * @lba_count: Value to assign to the lba_count field.
+ */
+void nvme_ns_set_lba_count(struct nvme_ns *p, uint64_t lba_count);
+
+/**
+ * nvme_ns_get_lba_count() - Get lba_count.
+ * @p: The &struct nvme_ns instance to query.
+ *
+ * Return: The value of the lba_count field.
+ */
+uint64_t nvme_ns_get_lba_count(const struct nvme_ns *p);
+
+/**
+ * nvme_ns_set_lba_util() - Set lba_util.
+ * @p: The &struct nvme_ns instance to update.
+ * @lba_util: Value to assign to the lba_util field.
+ */
+void nvme_ns_set_lba_util(struct nvme_ns *p, uint64_t lba_util);
+
+/**
+ * nvme_ns_get_lba_util() - Get lba_util.
+ * @p: The &struct nvme_ns instance to query.
+ *
+ * Return: The value of the lba_util field.
+ */
+uint64_t nvme_ns_get_lba_util(const struct nvme_ns *p);
+
+/****************************************************************************
+ * Accessors for: struct nvme_ctrl
+ ****************************************************************************/
+
+/**
+ * nvme_ctrl_get_name() - Get name.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the name field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_name(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_sysfs_dir() - Get sysfs_dir.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the sysfs_dir field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_sysfs_dir(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_firmware() - Get firmware.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the firmware field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_firmware(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_model() - Get model.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the model field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_model(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_numa_node() - Get numa_node.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the numa_node field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_numa_node(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_queue_count() - Get queue_count.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the queue_count field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_queue_count(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_serial() - Get serial.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the serial field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_serial(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_sqsize() - Get sqsize.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the sqsize field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_sqsize(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_transport() - Get transport.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the transport field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_transport(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_subsysnqn() - Get subsysnqn.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the subsysnqn field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_subsysnqn(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_traddr() - Get traddr.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the traddr field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_traddr(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_trsvcid() - Get trsvcid.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the trsvcid field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_trsvcid(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_set_dhchap_host_key() - Set dhchap_host_key.
+ * @p: The &struct nvme_ctrl instance to update.
+ * @dhchap_host_key: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_ctrl_set_dhchap_host_key(
+		struct nvme_ctrl *p,
+		const char *dhchap_host_key);
+
+/**
+ * nvme_ctrl_get_dhchap_host_key() - Get dhchap_host_key.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the dhchap_host_key field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_dhchap_host_key(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_set_dhchap_ctrl_key() - Set dhchap_ctrl_key.
+ * @p: The &struct nvme_ctrl instance to update.
+ * @dhchap_ctrl_key: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_ctrl_set_dhchap_ctrl_key(
+		struct nvme_ctrl *p,
+		const char *dhchap_ctrl_key);
+
+/**
+ * nvme_ctrl_get_dhchap_ctrl_key() - Get dhchap_ctrl_key.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the dhchap_ctrl_key field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_dhchap_ctrl_key(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_set_keyring() - Set keyring.
+ * @p: The &struct nvme_ctrl instance to update.
+ * @keyring: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_ctrl_set_keyring(struct nvme_ctrl *p, const char *keyring);
+
+/**
+ * nvme_ctrl_get_keyring() - Get keyring.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the keyring field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_keyring(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_set_tls_key_identity() - Set tls_key_identity.
+ * @p: The &struct nvme_ctrl instance to update.
+ * @tls_key_identity: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_ctrl_set_tls_key_identity(
+		struct nvme_ctrl *p,
+		const char *tls_key_identity);
+
+/**
+ * nvme_ctrl_get_tls_key_identity() - Get tls_key_identity.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the tls_key_identity field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_tls_key_identity(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_set_tls_key() - Set tls_key.
+ * @p: The &struct nvme_ctrl instance to update.
+ * @tls_key: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_ctrl_set_tls_key(struct nvme_ctrl *p, const char *tls_key);
+
+/**
+ * nvme_ctrl_get_tls_key() - Get tls_key.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the tls_key field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_tls_key(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_cntrltype() - Get cntrltype.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the cntrltype field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_cntrltype(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_cntlid() - Get cntlid.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the cntlid field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_cntlid(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_dctype() - Get dctype.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the dctype field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_dctype(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_phy_slot() - Get phy_slot.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the phy_slot field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_phy_slot(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_host_traddr() - Get host_traddr.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the host_traddr field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_host_traddr(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_get_host_iface() - Get host_iface.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the host_iface field, or NULL if not set.
+ */
+const char *nvme_ctrl_get_host_iface(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_set_discovery_ctrl() - Set discovery_ctrl.
+ * @p: The &struct nvme_ctrl instance to update.
+ * @discovery_ctrl: Value to assign to the discovery_ctrl field.
+ */
+void nvme_ctrl_set_discovery_ctrl(struct nvme_ctrl *p, bool discovery_ctrl);
+
+/**
+ * nvme_ctrl_get_discovery_ctrl() - Get discovery_ctrl.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the discovery_ctrl field.
+ */
+bool nvme_ctrl_get_discovery_ctrl(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_set_unique_discovery_ctrl() - Set unique_discovery_ctrl.
+ * @p: The &struct nvme_ctrl instance to update.
+ * @unique_discovery_ctrl: Value to assign to the unique_discovery_ctrl field.
+ */
+void nvme_ctrl_set_unique_discovery_ctrl(
+		struct nvme_ctrl *p,
+		bool unique_discovery_ctrl);
+
+/**
+ * nvme_ctrl_get_unique_discovery_ctrl() - Get unique_discovery_ctrl.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the unique_discovery_ctrl field.
+ */
+bool nvme_ctrl_get_unique_discovery_ctrl(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_set_discovered() - Set discovered.
+ * @p: The &struct nvme_ctrl instance to update.
+ * @discovered: Value to assign to the discovered field.
+ */
+void nvme_ctrl_set_discovered(struct nvme_ctrl *p, bool discovered);
+
+/**
+ * nvme_ctrl_get_discovered() - Get discovered.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the discovered field.
+ */
+bool nvme_ctrl_get_discovered(const struct nvme_ctrl *p);
+
+/**
+ * nvme_ctrl_set_persistent() - Set persistent.
+ * @p: The &struct nvme_ctrl instance to update.
+ * @persistent: Value to assign to the persistent field.
+ */
+void nvme_ctrl_set_persistent(struct nvme_ctrl *p, bool persistent);
+
+/**
+ * nvme_ctrl_get_persistent() - Get persistent.
+ * @p: The &struct nvme_ctrl instance to query.
+ *
+ * Return: The value of the persistent field.
+ */
+bool nvme_ctrl_get_persistent(const struct nvme_ctrl *p);
+
+/****************************************************************************
+ * Accessors for: struct nvme_subsystem
+ ****************************************************************************/
+
+/**
+ * nvme_subsystem_get_name() - Get name.
+ * @p: The &struct nvme_subsystem instance to query.
+ *
+ * Return: The value of the name field, or NULL if not set.
+ */
+const char *nvme_subsystem_get_name(const struct nvme_subsystem *p);
+
+/**
+ * nvme_subsystem_get_sysfs_dir() - Get sysfs_dir.
+ * @p: The &struct nvme_subsystem instance to query.
+ *
+ * Return: The value of the sysfs_dir field, or NULL if not set.
+ */
+const char *nvme_subsystem_get_sysfs_dir(const struct nvme_subsystem *p);
+
+/**
+ * nvme_subsystem_get_subsysnqn() - Get subsysnqn.
+ * @p: The &struct nvme_subsystem instance to query.
+ *
+ * Return: The value of the subsysnqn field, or NULL if not set.
+ */
+const char *nvme_subsystem_get_subsysnqn(const struct nvme_subsystem *p);
+
+/**
+ * nvme_subsystem_get_model() - Get model.
+ * @p: The &struct nvme_subsystem instance to query.
+ *
+ * Return: The value of the model field, or NULL if not set.
+ */
+const char *nvme_subsystem_get_model(const struct nvme_subsystem *p);
+
+/**
+ * nvme_subsystem_get_serial() - Get serial.
+ * @p: The &struct nvme_subsystem instance to query.
+ *
+ * Return: The value of the serial field, or NULL if not set.
+ */
+const char *nvme_subsystem_get_serial(const struct nvme_subsystem *p);
+
+/**
+ * nvme_subsystem_get_firmware() - Get firmware.
+ * @p: The &struct nvme_subsystem instance to query.
+ *
+ * Return: The value of the firmware field, or NULL if not set.
+ */
+const char *nvme_subsystem_get_firmware(const struct nvme_subsystem *p);
+
+/**
+ * nvme_subsystem_get_subsystype() - Get subsystype.
+ * @p: The &struct nvme_subsystem instance to query.
+ *
+ * Return: The value of the subsystype field, or NULL if not set.
+ */
+const char *nvme_subsystem_get_subsystype(const struct nvme_subsystem *p);
+
+/**
+ * nvme_subsystem_set_application() - Set application.
+ * @p: The &struct nvme_subsystem instance to update.
+ * @application: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_subsystem_set_application(
+		struct nvme_subsystem *p,
+		const char *application);
+
+/**
+ * nvme_subsystem_get_application() - Get application.
+ * @p: The &struct nvme_subsystem instance to query.
+ *
+ * Return: The value of the application field, or NULL if not set.
+ */
+const char *nvme_subsystem_get_application(const struct nvme_subsystem *p);
+
+/**
+ * nvme_subsystem_set_iopolicy() - Set iopolicy.
+ * @p: The &struct nvme_subsystem instance to update.
+ * @iopolicy: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_subsystem_set_iopolicy(
+		struct nvme_subsystem *p,
+		const char *iopolicy);
+
+/**
+ * nvme_subsystem_get_iopolicy() - Get iopolicy.
+ * @p: The &struct nvme_subsystem instance to query.
+ *
+ * Return: The value of the iopolicy field, or NULL if not set.
+ */
+const char *nvme_subsystem_get_iopolicy(const struct nvme_subsystem *p);
+
+/****************************************************************************
+ * Accessors for: struct nvme_host
+ ****************************************************************************/
+
+/**
+ * nvme_host_get_hostnqn() - Get hostnqn.
+ * @p: The &struct nvme_host instance to query.
+ *
+ * Return: The value of the hostnqn field, or NULL if not set.
+ */
+const char *nvme_host_get_hostnqn(const struct nvme_host *p);
+
+/**
+ * nvme_host_get_hostid() - Get hostid.
+ * @p: The &struct nvme_host instance to query.
+ *
+ * Return: The value of the hostid field, or NULL if not set.
+ */
+const char *nvme_host_get_hostid(const struct nvme_host *p);
+
+/**
+ * nvme_host_set_dhchap_host_key() - Set dhchap_host_key.
+ * @p: The &struct nvme_host instance to update.
+ * @dhchap_host_key: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_host_set_dhchap_host_key(
+		struct nvme_host *p,
+		const char *dhchap_host_key);
+
+/**
+ * nvme_host_get_dhchap_host_key() - Get dhchap_host_key.
+ * @p: The &struct nvme_host instance to query.
+ *
+ * Return: The value of the dhchap_host_key field, or NULL if not set.
+ */
+const char *nvme_host_get_dhchap_host_key(const struct nvme_host *p);
+
+/**
+ * nvme_host_set_hostsymname() - Set hostsymname.
+ * @p: The &struct nvme_host instance to update.
+ * @hostsymname: New string; a copy is stored. Pass NULL to clear.
+ */
+void nvme_host_set_hostsymname(struct nvme_host *p, const char *hostsymname);
+
+/**
+ * nvme_host_get_hostsymname() - Get hostsymname.
+ * @p: The &struct nvme_host instance to query.
+ *
+ * Return: The value of the hostsymname field, or NULL if not set.
+ */
+const char *nvme_host_get_hostsymname(const struct nvme_host *p);
+
+/**
+ * nvme_host_set_pdc_enabled_valid() - Set pdc_enabled_valid.
+ * @p: The &struct nvme_host instance to update.
+ * @pdc_enabled_valid: Value to assign to the pdc_enabled_valid field.
+ */
+void nvme_host_set_pdc_enabled_valid(
+		struct nvme_host *p,
+		bool pdc_enabled_valid);
+
+/**
+ * nvme_host_get_pdc_enabled_valid() - Get pdc_enabled_valid.
+ * @p: The &struct nvme_host instance to query.
+ *
+ * Return: The value of the pdc_enabled_valid field.
+ */
+bool nvme_host_get_pdc_enabled_valid(const struct nvme_host *p);
+
+/****************************************************************************
+ * Accessors for: struct nvme_fabric_options
+ ****************************************************************************/
+
+/**
+ * nvme_fabric_options_set_cntlid() - Set cntlid.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @cntlid: Value to assign to the cntlid field.
+ */
+void nvme_fabric_options_set_cntlid(struct nvme_fabric_options *p, bool cntlid);
+
+/**
+ * nvme_fabric_options_get_cntlid() - Get cntlid.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the cntlid field.
+ */
+bool nvme_fabric_options_get_cntlid(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_concat() - Set concat.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @concat: Value to assign to the concat field.
+ */
+void nvme_fabric_options_set_concat(struct nvme_fabric_options *p, bool concat);
+
+/**
+ * nvme_fabric_options_get_concat() - Get concat.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the concat field.
+ */
+bool nvme_fabric_options_get_concat(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_ctrl_loss_tmo() - Set ctrl_loss_tmo.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @ctrl_loss_tmo: Value to assign to the ctrl_loss_tmo field.
+ */
+void nvme_fabric_options_set_ctrl_loss_tmo(
+		struct nvme_fabric_options *p,
+		bool ctrl_loss_tmo);
+
+/**
+ * nvme_fabric_options_get_ctrl_loss_tmo() - Get ctrl_loss_tmo.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the ctrl_loss_tmo field.
+ */
+bool nvme_fabric_options_get_ctrl_loss_tmo(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_data_digest() - Set data_digest.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @data_digest: Value to assign to the data_digest field.
+ */
+void nvme_fabric_options_set_data_digest(
+		struct nvme_fabric_options *p,
+		bool data_digest);
+
+/**
+ * nvme_fabric_options_get_data_digest() - Get data_digest.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the data_digest field.
+ */
+bool nvme_fabric_options_get_data_digest(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_dhchap_ctrl_secret() - Set dhchap_ctrl_secret.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @dhchap_ctrl_secret: Value to assign to the dhchap_ctrl_secret field.
+ */
+void nvme_fabric_options_set_dhchap_ctrl_secret(
+		struct nvme_fabric_options *p,
+		bool dhchap_ctrl_secret);
+
+/**
+ * nvme_fabric_options_get_dhchap_ctrl_secret() - Get dhchap_ctrl_secret.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the dhchap_ctrl_secret field.
+ */
+bool nvme_fabric_options_get_dhchap_ctrl_secret(
+		const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_dhchap_secret() - Set dhchap_secret.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @dhchap_secret: Value to assign to the dhchap_secret field.
+ */
+void nvme_fabric_options_set_dhchap_secret(
+		struct nvme_fabric_options *p,
+		bool dhchap_secret);
+
+/**
+ * nvme_fabric_options_get_dhchap_secret() - Get dhchap_secret.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the dhchap_secret field.
+ */
+bool nvme_fabric_options_get_dhchap_secret(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_disable_sqflow() - Set disable_sqflow.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @disable_sqflow: Value to assign to the disable_sqflow field.
+ */
+void nvme_fabric_options_set_disable_sqflow(
+		struct nvme_fabric_options *p,
+		bool disable_sqflow);
+
+/**
+ * nvme_fabric_options_get_disable_sqflow() - Get disable_sqflow.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the disable_sqflow field.
+ */
+bool nvme_fabric_options_get_disable_sqflow(
+		const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_discovery() - Set discovery.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @discovery: Value to assign to the discovery field.
+ */
+void nvme_fabric_options_set_discovery(
+		struct nvme_fabric_options *p,
+		bool discovery);
+
+/**
+ * nvme_fabric_options_get_discovery() - Get discovery.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the discovery field.
+ */
+bool nvme_fabric_options_get_discovery(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_duplicate_connect() - Set duplicate_connect.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @duplicate_connect: Value to assign to the duplicate_connect field.
+ */
+void nvme_fabric_options_set_duplicate_connect(
+		struct nvme_fabric_options *p,
+		bool duplicate_connect);
+
+/**
+ * nvme_fabric_options_get_duplicate_connect() - Get duplicate_connect.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the duplicate_connect field.
+ */
+bool nvme_fabric_options_get_duplicate_connect(
+		const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_fast_io_fail_tmo() - Set fast_io_fail_tmo.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @fast_io_fail_tmo: Value to assign to the fast_io_fail_tmo field.
+ */
+void nvme_fabric_options_set_fast_io_fail_tmo(
+		struct nvme_fabric_options *p,
+		bool fast_io_fail_tmo);
+
+/**
+ * nvme_fabric_options_get_fast_io_fail_tmo() - Get fast_io_fail_tmo.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the fast_io_fail_tmo field.
+ */
+bool nvme_fabric_options_get_fast_io_fail_tmo(
+		const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_hdr_digest() - Set hdr_digest.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @hdr_digest: Value to assign to the hdr_digest field.
+ */
+void nvme_fabric_options_set_hdr_digest(
+		struct nvme_fabric_options *p,
+		bool hdr_digest);
+
+/**
+ * nvme_fabric_options_get_hdr_digest() - Get hdr_digest.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the hdr_digest field.
+ */
+bool nvme_fabric_options_get_hdr_digest(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_host_iface() - Set host_iface.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @host_iface: Value to assign to the host_iface field.
+ */
+void nvme_fabric_options_set_host_iface(
+		struct nvme_fabric_options *p,
+		bool host_iface);
+
+/**
+ * nvme_fabric_options_get_host_iface() - Get host_iface.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the host_iface field.
+ */
+bool nvme_fabric_options_get_host_iface(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_host_traddr() - Set host_traddr.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @host_traddr: Value to assign to the host_traddr field.
+ */
+void nvme_fabric_options_set_host_traddr(
+		struct nvme_fabric_options *p,
+		bool host_traddr);
+
+/**
+ * nvme_fabric_options_get_host_traddr() - Get host_traddr.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the host_traddr field.
+ */
+bool nvme_fabric_options_get_host_traddr(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_hostid() - Set hostid.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @hostid: Value to assign to the hostid field.
+ */
+void nvme_fabric_options_set_hostid(struct nvme_fabric_options *p, bool hostid);
+
+/**
+ * nvme_fabric_options_get_hostid() - Get hostid.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the hostid field.
+ */
+bool nvme_fabric_options_get_hostid(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_hostnqn() - Set hostnqn.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @hostnqn: Value to assign to the hostnqn field.
+ */
+void nvme_fabric_options_set_hostnqn(
+		struct nvme_fabric_options *p,
+		bool hostnqn);
+
+/**
+ * nvme_fabric_options_get_hostnqn() - Get hostnqn.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the hostnqn field.
+ */
+bool nvme_fabric_options_get_hostnqn(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_instance() - Set instance.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @instance: Value to assign to the instance field.
+ */
+void nvme_fabric_options_set_instance(
+		struct nvme_fabric_options *p,
+		bool instance);
+
+/**
+ * nvme_fabric_options_get_instance() - Get instance.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the instance field.
+ */
+bool nvme_fabric_options_get_instance(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_keep_alive_tmo() - Set keep_alive_tmo.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @keep_alive_tmo: Value to assign to the keep_alive_tmo field.
+ */
+void nvme_fabric_options_set_keep_alive_tmo(
+		struct nvme_fabric_options *p,
+		bool keep_alive_tmo);
+
+/**
+ * nvme_fabric_options_get_keep_alive_tmo() - Get keep_alive_tmo.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the keep_alive_tmo field.
+ */
+bool nvme_fabric_options_get_keep_alive_tmo(
+		const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_keyring() - Set keyring.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @keyring: Value to assign to the keyring field.
+ */
+void nvme_fabric_options_set_keyring(
+		struct nvme_fabric_options *p,
+		bool keyring);
+
+/**
+ * nvme_fabric_options_get_keyring() - Get keyring.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the keyring field.
+ */
+bool nvme_fabric_options_get_keyring(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_nqn() - Set nqn.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @nqn: Value to assign to the nqn field.
+ */
+void nvme_fabric_options_set_nqn(struct nvme_fabric_options *p, bool nqn);
+
+/**
+ * nvme_fabric_options_get_nqn() - Get nqn.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the nqn field.
+ */
+bool nvme_fabric_options_get_nqn(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_nr_io_queues() - Set nr_io_queues.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @nr_io_queues: Value to assign to the nr_io_queues field.
+ */
+void nvme_fabric_options_set_nr_io_queues(
+		struct nvme_fabric_options *p,
+		bool nr_io_queues);
+
+/**
+ * nvme_fabric_options_get_nr_io_queues() - Get nr_io_queues.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the nr_io_queues field.
+ */
+bool nvme_fabric_options_get_nr_io_queues(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_nr_poll_queues() - Set nr_poll_queues.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @nr_poll_queues: Value to assign to the nr_poll_queues field.
+ */
+void nvme_fabric_options_set_nr_poll_queues(
+		struct nvme_fabric_options *p,
+		bool nr_poll_queues);
+
+/**
+ * nvme_fabric_options_get_nr_poll_queues() - Get nr_poll_queues.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the nr_poll_queues field.
+ */
+bool nvme_fabric_options_get_nr_poll_queues(
+		const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_nr_write_queues() - Set nr_write_queues.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @nr_write_queues: Value to assign to the nr_write_queues field.
+ */
+void nvme_fabric_options_set_nr_write_queues(
+		struct nvme_fabric_options *p,
+		bool nr_write_queues);
+
+/**
+ * nvme_fabric_options_get_nr_write_queues() - Get nr_write_queues.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the nr_write_queues field.
+ */
+bool nvme_fabric_options_get_nr_write_queues(
+		const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_queue_size() - Set queue_size.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @queue_size: Value to assign to the queue_size field.
+ */
+void nvme_fabric_options_set_queue_size(
+		struct nvme_fabric_options *p,
+		bool queue_size);
+
+/**
+ * nvme_fabric_options_get_queue_size() - Get queue_size.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the queue_size field.
+ */
+bool nvme_fabric_options_get_queue_size(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_reconnect_delay() - Set reconnect_delay.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @reconnect_delay: Value to assign to the reconnect_delay field.
+ */
+void nvme_fabric_options_set_reconnect_delay(
+		struct nvme_fabric_options *p,
+		bool reconnect_delay);
+
+/**
+ * nvme_fabric_options_get_reconnect_delay() - Get reconnect_delay.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the reconnect_delay field.
+ */
+bool nvme_fabric_options_get_reconnect_delay(
+		const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_tls() - Set tls.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @tls: Value to assign to the tls field.
+ */
+void nvme_fabric_options_set_tls(struct nvme_fabric_options *p, bool tls);
+
+/**
+ * nvme_fabric_options_get_tls() - Get tls.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the tls field.
+ */
+bool nvme_fabric_options_get_tls(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_tls_key() - Set tls_key.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @tls_key: Value to assign to the tls_key field.
+ */
+void nvme_fabric_options_set_tls_key(
+		struct nvme_fabric_options *p,
+		bool tls_key);
+
+/**
+ * nvme_fabric_options_get_tls_key() - Get tls_key.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the tls_key field.
+ */
+bool nvme_fabric_options_get_tls_key(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_tos() - Set tos.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @tos: Value to assign to the tos field.
+ */
+void nvme_fabric_options_set_tos(struct nvme_fabric_options *p, bool tos);
+
+/**
+ * nvme_fabric_options_get_tos() - Get tos.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the tos field.
+ */
+bool nvme_fabric_options_get_tos(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_traddr() - Set traddr.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @traddr: Value to assign to the traddr field.
+ */
+void nvme_fabric_options_set_traddr(struct nvme_fabric_options *p, bool traddr);
+
+/**
+ * nvme_fabric_options_get_traddr() - Get traddr.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the traddr field.
+ */
+bool nvme_fabric_options_get_traddr(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_transport() - Set transport.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @transport: Value to assign to the transport field.
+ */
+void nvme_fabric_options_set_transport(
+		struct nvme_fabric_options *p,
+		bool transport);
+
+/**
+ * nvme_fabric_options_get_transport() - Get transport.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the transport field.
+ */
+bool nvme_fabric_options_get_transport(const struct nvme_fabric_options *p);
+
+/**
+ * nvme_fabric_options_set_trsvcid() - Set trsvcid.
+ * @p: The &struct nvme_fabric_options instance to update.
+ * @trsvcid: Value to assign to the trsvcid field.
+ */
+void nvme_fabric_options_set_trsvcid(
+		struct nvme_fabric_options *p,
+		bool trsvcid);
+
+/**
+ * nvme_fabric_options_get_trsvcid() - Get trsvcid.
+ * @p: The &struct nvme_fabric_options instance to query.
+ *
+ * Return: The value of the trsvcid field.
+ */
+bool nvme_fabric_options_get_trsvcid(const struct nvme_fabric_options *p);
+
+#endif /* _ACCESSORS_H_ */
diff --git a/libnvme/src/nvme/base64.c b/libnvme/src/nvme/base64.c
index c46209707d..815d6869d7 100644
--- a/libnvme/src/nvme/base64.c
+++ b/libnvme/src/nvme/base64.c
@@ -7,10 +7,9 @@
  * Author: Hannes Reinecke <hare@suse.de>
  */
 
+#include <errno.h>
 #include <stdint.h>
 #include <string.h>
-#include <errno.h>
-#include <sys/types.h>
 
 static const char base64_table[65] =
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
diff --git a/libnvme/src/nvme/cmds.c b/libnvme/src/nvme/cmds.c
index 4ea635a8b2..921b36f39b 100644
--- a/libnvme/src/nvme/cmds.c
+++ b/libnvme/src/nvme/cmds.c
@@ -16,36 +16,225 @@
 
 #include "cleanup.h"
 #include "private.h"
+#include "compiler_attributes.h"
 
-int nvme_fw_download_seq(struct nvme_transport_handle *hdl, bool ish,
-		__u32 size, __u32 xfer, __u32 offset, void *buf)
+static bool force_4k;
+
+__attribute__((constructor))
+static void nvme_init_env(void)
+{
+	char *val;
+
+	val = getenv("LIBNVME_FORCE_4K");
+	if (!val)
+		return;
+	if (!strcmp(val, "1") ||
+	    !strcasecmp(val, "true") ||
+	    !strncasecmp(val, "enable", 6))
+		force_4k = true;
+}
+
+__public int nvme_get_log(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd, bool rae,
+		__u32 xfer_len)
+{
+	__u64 offset = 0, xfer, data_len = cmd->data_len;
+	__u64 start = (__u64)cmd->cdw13 << 32 | cmd->cdw12;
+	__u64 lpo;
+	void *ptr = (void *)(uintptr_t)cmd->addr;
+	int ret;
+	bool _rae;
+	__u32 numd;
+	__u16 numdu, numdl;
+	__u32 cdw10 = cmd->cdw10 & (NVME_VAL(LOG_CDW10_LID) |
+				    NVME_VAL(LOG_CDW10_LSP));
+	__u32 cdw11 = cmd->cdw11 & NVME_VAL(LOG_CDW11_LSI);
+
+	if (force_4k)
+		xfer_len = NVME_LOG_PAGE_PDU_SIZE;
+
+	/*
+	 * 4k is the smallest possible transfer unit, so restricting to 4k
+	 * avoids having to check the MDTS value of the controller.
+	 */
+	do {
+		if (!force_4k) {
+			xfer = data_len - offset;
+			if (xfer > xfer_len)
+				xfer  = xfer_len;
+		} else {
+			xfer = NVME_LOG_PAGE_PDU_SIZE;
+		}
+
+		/*
+		 * Always retain regardless of the RAE parameter until the very
+		 * last portion of this log page so the data remains latched
+		 * during the fetch sequence.
+		 */
+		lpo = start + offset;
+		numd = (xfer >> 2) - 1;
+		numdu = numd >> 16;
+		numdl = numd & 0xffff;
+		_rae = offset + xfer < data_len || rae;
+
+		cmd->cdw10 = cdw10 |
+			NVME_SET(!!_rae, LOG_CDW10_RAE) |
+			NVME_SET(numdl, LOG_CDW10_NUMDL);
+		cmd->cdw11 = cdw11 |
+			NVME_SET(numdu, LOG_CDW11_NUMDU);
+		cmd->cdw12 = lpo & 0xffffffff;
+		cmd->cdw13 = lpo >> 32;
+		cmd->data_len = xfer;
+		cmd->addr = (__u64)(uintptr_t)ptr;
+
+		if (hdl->uring_enabled)
+			ret = nvme_submit_admin_passthru_async(hdl, cmd);
+		else
+			ret = nvme_submit_admin_passthru(hdl, cmd);
+		if (ret)
+			return ret;
+
+		offset += xfer;
+		ptr += xfer;
+	} while (offset < data_len);
+
+	if (hdl->uring_enabled) {
+		ret = nvme_wait_complete_passthru(hdl);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int read_ana_chunk(struct nvme_transport_handle *hdl,
+		enum nvme_log_ana_lsp lsp, bool rae,
+		__u8 *log, __u8 **read, __u8 *to_read, __u8 *log_end)
 {
 	struct nvme_passthru_cmd cmd;
-	void *data = buf;
-	int err = 0;
 
-	if (ish && nvme_transport_handle_is_mi(hdl))
-		nvme_init_mi_cmd_flags(&cmd, ish);
+	if (to_read > log_end)
+		return -ENOSPC;
 
-	while (size > 0) {
-		__u32 chunk = min(xfer, size);
+	while (*read < to_read) {
+		__u32 len = min_t(__u32, log_end - *read,
+			NVME_LOG_PAGE_PDU_SIZE);
+		int ret;
 
-		err = nvme_init_fw_download(&cmd, data, chunk, offset);
-		if (err)
-			break;
-		err = nvme_submit_admin_passthru(hdl, &cmd);
-		if (err)
-			break;
+		nvme_init_get_log_ana(&cmd, lsp, *read - log, *read, len);
+		ret = nvme_get_log(hdl, &cmd, rae, NVME_LOG_PAGE_PDU_SIZE);
+		if (ret)
+			return ret;
 
-		data += chunk;
-		size -= chunk;
-		offset += chunk;
+		*read += len;
 	}
+	return 0;
+}
 
-	return err;
+static int try_read_ana(struct nvme_transport_handle *hdl,
+		enum nvme_log_ana_lsp lsp, bool rae,
+		struct nvme_ana_log *log, __u8 *log_end,
+		__u8 *read, __u8 **to_read, bool *may_retry)
+{
+	__u16 ngrps = le16_to_cpu(log->ngrps);
+
+	while (ngrps--) {
+		__u8 *group = *to_read;
+		int ret;
+		__le32 nnsids;
+
+		*to_read += sizeof(*log->descs);
+		ret = read_ana_chunk(hdl, lsp, rae,
+				     (__u8 *)log, &read, *to_read, log_end);
+		if (ret) {
+			/*
+			 * If the provided buffer isn't long enough,
+			 * the log page may have changed while reading it
+			 * and the computed length was inaccurate.
+			 * Have the caller check chgcnt and retry.
+			 */
+			*may_retry = ret == -ENOSPC;
+			return ret;
+		}
+
+		/*
+		 * struct nvme_ana_group_desc has 8-byte alignment
+		 * but the group pointer is only 4-byte aligned.
+		 * Don't dereference the misaligned pointer.
+		 */
+		memcpy(&nnsids,
+		       group + offsetof(struct nvme_ana_group_desc, nnsids),
+		       sizeof(nnsids));
+		*to_read += le32_to_cpu(nnsids) * sizeof(__le32);
+		ret = read_ana_chunk(hdl, lsp, rae,
+				     (__u8 *)log, &read, *to_read, log_end);
+		if (ret) {
+			*may_retry = ret == -ENOSPC;
+			return ret;
+		}
+	}
+
+	*may_retry = true;
+	return 0;
+}
+
+__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)
+{
+	const enum nvme_log_ana_lsp lsp =
+		rgo ? NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY : 0;
+	/* Get Log Page can only fetch multiples of dwords */
+	__u8 * const log_end = (__u8 *)log + (*len & -4);
+	__u8 *read = (__u8 *)log;
+	__u8 *to_read;
+	int ret;
+
+	if (!retries)
+		return -EINVAL;
+
+	to_read = (__u8 *)log->descs;
+	ret = read_ana_chunk(hdl, lsp, rae,
+			     (__u8 *)log, &read, to_read, log_end);
+	if (ret)
+		return ret;
+
+	do {
+		bool may_retry = false;
+		int saved_ret;
+		int saved_errno;
+		__le64 chgcnt;
+
+		saved_ret = try_read_ana(hdl, lsp, rae, log, log_end,
+					 read, &to_read, &may_retry);
+		/*
+		 * If the log page was read with multiple Get Log Page commands,
+		 * chgcnt must be checked afterwards to ensure atomicity
+		 */
+		*len = to_read - (__u8 *)log;
+		if (*len <= NVME_LOG_PAGE_PDU_SIZE || !may_retry)
+			return saved_ret;
+
+		saved_errno = errno;
+		chgcnt = log->chgcnt;
+		read = (__u8 *)log;
+		to_read = (__u8 *)log->descs;
+		ret = read_ana_chunk(hdl, lsp, rae,
+				     (__u8 *)log, &read, to_read, log_end);
+		if (ret)
+			return ret;
+
+		if (log->chgcnt == chgcnt) {
+			/* Log hasn't changed; return try_read_ana() result */
+			errno = saved_errno;
+			return saved_ret;
+		}
+	} while (--retries);
+
+	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;
@@ -72,7 +261,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;
@@ -98,7 +287,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;
@@ -123,7 +312,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;
@@ -159,7 +348,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)
@@ -263,7 +452,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)
 {
@@ -271,7 +460,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)
 {
@@ -279,7 +468,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)
 {
@@ -333,37 +522,7 @@ int nvme_get_lba_status_log(struct nvme_transport_handle *hdl, bool rae,
 	return 0;
 }
 
-static int nvme_ns_attachment(struct nvme_transport_handle *hdl, bool ish,
-		__u32 nsid, __u16 num_ctrls, __u16 *ctrlist, bool attach)
-{
-	struct nvme_ctrl_list cntlist = { 0 };
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_ctrl_list(&cntlist, num_ctrls, ctrlist);
-	if (ish && nvme_transport_handle_is_mi(hdl))
-		nvme_init_mi_cmd_flags(&cmd, ish);
-
-	if (attach)
-		nvme_init_ns_attach_ctrls(&cmd, nsid, &cntlist);
-	else
-		nvme_init_ns_detach_ctrls(&cmd, nsid, &cntlist);
-
-	return nvme_submit_admin_passthru(hdl, &cmd);
-}
-
-int nvme_namespace_attach_ctrls(struct nvme_transport_handle *hdl, bool ish,
-		__u32 nsid, __u16 num_ctrls, __u16 *ctrlist)
-{
-	return nvme_ns_attachment(hdl, ish, nsid, num_ctrls, ctrlist, true);
-}
-
-int nvme_namespace_detach_ctrls(struct nvme_transport_handle *hdl, bool ish,
-		__u32 nsid, __u16 num_ctrls, __u16 *ctrlist)
-{
-	return nvme_ns_attachment(hdl, ish, nsid, num_ctrls, ctrlist, false);
-}
-
-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);
@@ -373,7 +532,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;
@@ -392,7 +551,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;
@@ -415,105 +574,7 @@ int nvme_get_logical_block_size(struct nvme_transport_handle *hdl,
 	return 0;
 }
 
-static inline void nvme_init_copy_range_elbt(__u8 *elbt, __u64 eilbrt)
-{
-	int i;
-
-	for (i = 0; i < 8; i++)
-		elbt[9 - i] = (eilbrt >> (8 * i)) & 0xff;
-	elbt[1] = 0;
-	elbt[0] = 0;
-}
-
-void nvme_init_copy_range(struct nvme_copy_range *copy, __u16 *nlbs,
-			  __u64 *slbas, __u32 *eilbrts, __u32 *elbatms,
-			  __u32 *elbats, __u16 nr)
-{
-	int i;
-
-	for (i = 0; i < nr; i++) {
-		copy[i].nlb = cpu_to_le16(nlbs[i]);
-		copy[i].slba = cpu_to_le64(slbas[i]);
-		copy[i].eilbrt = cpu_to_le32(eilbrts[i]);
-		copy[i].elbatm = cpu_to_le16(elbatms[i]);
-		copy[i].elbat = cpu_to_le16(elbats[i]);
-	}
-}
-
-void nvme_init_copy_range_f1(struct nvme_copy_range_f1 *copy, __u16 *nlbs,
-			  __u64 *slbas, __u64 *eilbrts, __u32 *elbatms,
-			  __u32 *elbats, __u16 nr)
-{
-	int i;
-
-	for (i = 0; i < nr; i++) {
-		copy[i].nlb = cpu_to_le16(nlbs[i]);
-		copy[i].slba = cpu_to_le64(slbas[i]);
-		copy[i].elbatm = cpu_to_le16(elbatms[i]);
-		copy[i].elbat = cpu_to_le16(elbats[i]);
-		nvme_init_copy_range_elbt(copy[i].elbt, eilbrts[i]);
-	}
-}
-
-void nvme_init_copy_range_f2(struct nvme_copy_range_f2 *copy, __u32 *snsids,
-			  __u16 *nlbs, __u64 *slbas, __u16 *sopts,
-			  __u32 *eilbrts, __u32 *elbatms, __u32 *elbats,
-			  __u16 nr)
-{
-	int i;
-
-	for (i = 0; i < nr; i++) {
-		copy[i].snsid = cpu_to_le32(snsids[i]);
-		copy[i].nlb = cpu_to_le16(nlbs[i]);
-		copy[i].slba = cpu_to_le64(slbas[i]);
-		copy[i].sopt = cpu_to_le16(sopts[i]);
-		copy[i].eilbrt = cpu_to_le32(eilbrts[i]);
-		copy[i].elbatm = cpu_to_le16(elbatms[i]);
-		copy[i].elbat = cpu_to_le16(elbats[i]);
-	}
-}
-
-void nvme_init_copy_range_f3(struct nvme_copy_range_f3 *copy, __u32 *snsids,
-			  __u16 *nlbs, __u64 *slbas, __u16 *sopts,
-			  __u64 *eilbrts, __u32 *elbatms, __u32 *elbats,
-			  __u16 nr)
-{
-	int i;
-
-	for (i = 0; i < nr; i++) {
-		copy[i].snsid = cpu_to_le32(snsids[i]);
-		copy[i].nlb = cpu_to_le16(nlbs[i]);
-		copy[i].slba = cpu_to_le64(slbas[i]);
-		copy[i].sopt = cpu_to_le16(sopts[i]);
-		copy[i].elbatm = cpu_to_le16(elbatms[i]);
-		copy[i].elbat = cpu_to_le16(elbats[i]);
-		nvme_init_copy_range_elbt(copy[i].elbt, eilbrts[i]);
-	}
-}
-
-void nvme_init_dsm_range(struct nvme_dsm_range *dsm, __u32 *ctx_attrs,
-			 __u32 *llbas, __u64 *slbas, __u16 nr_ranges)
-{
-	int i;
-
-	for (i = 0; i < nr_ranges; i++) {
-		dsm[i].cattr = cpu_to_le32(ctx_attrs[i]);
-		dsm[i].nlb = cpu_to_le32(llbas[i]);
-		dsm[i].slba = cpu_to_le64(slbas[i]);
-	}
-}
-
-void nvme_init_ctrl_list(struct nvme_ctrl_list *cntlist, __u16 num_ctrls,
-			  __u16 *ctrlist)
-{
-	int i;
-
-	cntlist->num = cpu_to_le16(num_ctrls);
-	for (i = 0; i < num_ctrls; i++)
-		cntlist->identifier[i] = cpu_to_le16(ctrlist[i]);
-}
-
-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) {
@@ -586,7 +647,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/cmds.h b/libnvme/src/nvme/cmds.h
index e09e7450af..cdf2a38920 100644
--- a/libnvme/src/nvme/cmds.h
+++ b/libnvme/src/nvme/cmds.h
@@ -10,12 +10,12 @@
 
 #pragma once
 
+#include <errno.h>
+#include <string.h>
+
 #include <nvme/ioctl.h>
 #include <nvme/types.h>
 
-#include <string.h>
-#include <errno.h>
-
 enum nvme_cmd_dword_fields {
 	NVME_DEVICE_SELF_TEST_CDW10_STC_SHIFT			= 0,
 	NVME_DEVICE_SELF_TEST_CDW10_STC_MASK			= 0xf,
@@ -889,20 +889,6 @@ nvme_init_zns_identify_ctrl(struct nvme_passthru_cmd *cmd,
 			   id, sizeof(*id));
 }
 
-/**
- * nvme_get_log() - Get log page data
- * @hdl:	Transport handle
- * @cmd:	Passthru command
- * @rae:	Retain asynchronous events
- * @xfer_len:	Max log transfer size per request to split the total.
- *
- * Return: 0 on success, the nvme command status if a response was
- * received (see &enum nvme_status_field) or a negative error otherwise.
- */
-int nvme_get_log(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd, bool rae,
-		 __u32 xfer_len);
-
 /**
  * nvme_init_get_log_lpo() - Initializes passthru command with a
  * Log Page Offset
@@ -1870,31 +1856,6 @@ nvme_init_get_log_zns_changed_zones(struct nvme_passthru_cmd *cmd,
 		log, sizeof(*log));
 }
 
-/**
- * nvme_get_ana_log_atomic() - Retrieve Asymmetric Namespace Access
- * log page atomically
- * @hdl:	Transport handle
- * @rae:	Whether to retain asynchronous events
- * @rgo:	Whether to retrieve ANA groups only (no NSIDs)
- * @log:	Pointer to a buffer to receive the ANA log page
- * @len:	Input: the length of the log page buffer.
- *		Output: the actual length of the ANA log page.
- * @retries:	The maximum number of times to retry on log page changes
- *
- * See &struct nvme_ana_log for the definition of the returned structure.
- *
- * Return: If successful, returns 0 and sets *len to the actual log page length.
- * If unsuccessful, returns the nvme command status if a response was received
- * (see &enum nvme_status_field) or -1 with errno set otherwise.
- * Sets errno = EINVAL if retries == 0.
- * Sets errno = EAGAIN if unable to read the log page atomically
- * because chgcnt changed during each of the retries attempts.
- * Sets errno = ENOSPC if the full log page does not fit in the provided buffer.
- */
-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);
-
 /**
  * nvme_init_set_features() - Initialize passthru command for
  * Set Features
@@ -3971,24 +3932,21 @@ nvme_init_virtual_mgmt(struct nvme_passthru_cmd *cmd,
 }
 
 /**
- * nvme_flush() - Send an nvme flush command
- * @hdl:	Transport handle
+ * nvme_init_flush() - Initialize passthru command for Flush command
+ * @cmd:	Passthru command to use
  * @nsid:	Namespace identifier
  *
  * The Flush command requests that the contents of volatile write cache be made
  * non-volatile.
  *
- * Return: 0 on success, the nvme command status if a response was
- * received (see &enum nvme_status_field) or a negative error otherwise.
+ * Initializes the passthru command buffer for the Flush command.
  */
-static inline int nvme_flush(struct nvme_transport_handle *hdl, __u32 nsid)
+static inline void
+nvme_init_flush(struct nvme_passthru_cmd *cmd, __u32 nsid)
 {
-	struct nvme_passthru_cmd cmd = {};
-
-	cmd.opcode = nvme_cmd_flush;
-	cmd.nsid = nsid;
-
-	return nvme_submit_io_passthru(hdl, &cmd);
+	memset(cmd, 0, sizeof(*cmd));
+	cmd->opcode = nvme_cmd_flush;
+	cmd->nsid = nsid;
 }
 
 /**
@@ -5215,1776 +5173,273 @@ nvme_init_lm_get_features_ctrl_data_queue(struct nvme_passthru_cmd *cmd,
 }
 
 /**
- * nvme_identify() - Submit a generic Identify command
- * @hdl:	Transport handle for the controller.
- * @nsid:	Namespace ID (if applicable to the requested CNS).
- * @csi:	Command Set Identifier.
- * @cns:	Identify Controller or Namespace Structure (CNS) value,
- *		specifying the type of data to be returned.
- * @data:	Pointer to the buffer where the identification data will
- *		be stored.
- * @len:	Length of the data buffer in bytes.
- *
- * The generic wrapper for submitting an Identify command, allowing the host
- * to specify any combination of Identify parameters.
+ * nvme_init_mi_cmd_flags() - Initialize command flags for NVMe-MI
+ * @cmd:	Passthru command to use
+ * @ish:	Ignore Shutdown (for NVMe-MI command)
  *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * Initializes the passthru command flags
  */
-static inline int
-nvme_identify(struct nvme_transport_handle *hdl, __u32 nsid, enum nvme_csi csi,
-		enum nvme_identify_cns cns, void *data, __u32 len)
+static inline void
+nvme_init_mi_cmd_flags(struct nvme_passthru_cmd *cmd, bool ish)
 {
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_identify(&cmd, nsid, csi, cns, data, len);
-
-	return nvme_submit_admin_passthru(hdl, &cmd);
+	cmd->flags = NVME_FIELD_ENCODE(ish,
+			NVME_MI_ADMIN_CFLAGS_ISH_SHIFT,
+			NVME_MI_ADMIN_CFLAGS_ISH_MASK);
 }
+
 /**
- * nvme_identify_ctrl() - Submit an Identify Controller command
- * @hdl:	Transport handle for the controller.
- * @id:		Pointer to the buffer (&struct nvme_id_ctrl) where the
- *		controller identification data will be stored upon
- *		successful completion.
- *
- * Submits the Identify Controller command to retrieve the controller's
- * capabilities and configuration data.
+ * nvme_init_ctrl_list() - Initialize an nvme_ctrl_list structure from an array.
+ * @cntlist:   The controller list structure to initialize
+ * @num_ctrls: The number of controllers in the array, &ctrlist.
+ * @ctrlist:   An array of controller identifiers in CPU native endian.
  *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * This is intended to be used with any command that takes a controller list
+ * argument. See nvme_ns_attach_ctrls() and nvme_ns_detach().
  */
-static inline int
-nvme_identify_ctrl(struct nvme_transport_handle *hdl,
-		struct nvme_id_ctrl *id)
+static inline void
+nvme_init_ctrl_list(struct nvme_ctrl_list *cntlist, __u16 num_ctrls,
+		__u16 *ctrlist)
 {
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_identify_ctrl(&cmd, id);
+	int i;
 
-	return nvme_submit_admin_passthru(hdl, &cmd);
+	cntlist->num = htole16(num_ctrls);
+	for (i = 0; i < num_ctrls; i++)
+		cntlist->identifier[i] = htole16(ctrlist[i]);
 }
 
 /**
- * nvme_identify_active_ns_list() - Submit an Identify Active Namespace
- * List command
- * @hdl:	Transport handle for the controller.
- * @nsid:	The Namespace ID to query
- * @ns_list:	Pointer to the buffer (&struct nvme_ns_list) where the
- *		active namespace list will be stored.
+ * nvme_init_dsm_range() - Constructs a data set range structure
+ * @dsm:	DSM range array
+ * @ctx_attrs:	Array of context attributes
+ * @llbas:	Array of length in logical blocks
+ * @slbas:	Array of starting logical blocks
+ * @nr_ranges:	The size of the dsm arrays
  *
- * Submits the Identify command to retrieve a list of active Namespace IDs.
+ * Each array must be the same size of size 'nr_ranges'. This is intended to be
+ * used with constructing a payload for nvme_dsm().
  *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * Return: The nvme command status if a response was received or -errno
+ * otherwise.
  */
-static inline int
-nvme_identify_active_ns_list(struct nvme_transport_handle *hdl,
-		__u32 nsid, struct nvme_ns_list *ns_list)
+static inline void
+nvme_init_dsm_range(struct nvme_dsm_range *dsm, __u32 *ctx_attrs,
+		__u32 *llbas, __u64 *slbas, __u16 nr_ranges)
 {
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_identify_active_ns_list(&cmd, nsid, ns_list);
+	int i;
 
-	return nvme_submit_admin_passthru(hdl, &cmd);
+	for (i = 0; i < nr_ranges; i++) {
+		dsm[i].cattr = htole32(ctx_attrs[i]);
+		dsm[i].nlb = htole32(llbas[i]);
+		dsm[i].slba = htole64(slbas[i]);
+	}
 }
 
 /**
- * nvme_identify_ns() - Submit an Identify Namespace command
- * @hdl:	Transport handle for the controller.
- * @nsid:	The Namespace ID to identify.
- * @ns:		Pointer to the buffer (&struct nvme_id_ns) where the namespace
- *		identification data will be stored.
- *
- * Submits the Identify command to retrieve the Namespace Identification
- * data structure for a specified namespace.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * nvme_init_copy_range_elbt() - Constructs a copy range elbt structure
+ * @elbt:
+ * @eilbrts:	Expected initial logical block reference tag
  */
-
-static inline int
-nvme_identify_ns(struct nvme_transport_handle *hdl,
-		__u32 nsid, struct nvme_id_ns *ns)
+static inline void
+nvme_init_copy_range_elbt(__u8 *elbt, __u64 eilbrt)
 {
-	struct nvme_passthru_cmd cmd;
+	int i;
 
-	nvme_init_identify_ns(&cmd, nsid, ns);
-
-	return nvme_submit_admin_passthru(hdl, &cmd);
+	for (i = 0; i < 8; i++)
+		elbt[9 - i] = (eilbrt >> (8 * i)) & 0xff;
+	elbt[1] = 0;
+	elbt[0] = 0;
 }
 
 /**
- * nvme_identify_csi_ns() - Submit a CSI-specific Identify Namespace command
- * @hdl:	Transport handle for the controller.
- * @nsid:	The Namespace ID to identify.
- * @csi:	The Command Set Identifier
- * @uidx:	The UUID Index for the command.
- * @id_ns:	Pointer to the buffer (@struct nvme_nvm_id_ns) where the
- *		CSI-specific namespace identification data will be stored.
- *
- * Submits the Identify command to retrieve Namespace Identification data
- * specific to a Command Set Identifier (CSI).
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * nvme_init_copy_range() - Constructs a copy range structure
+ * @copy:	Copy range array
+ * @nlbs:	Number of logical blocks
+ * @slbas:	Starting LBA
+ * @eilbrts:	Expected initial logical block reference tag
+ * @elbatms:	Expected logical block application tag mask
+ * @elbats:	Expected logical block application tag
+ * @nr:		Number of descriptors to construct
  */
-static inline int
-nvme_identify_csi_ns(struct nvme_transport_handle *hdl, __u32 nsid,
-		enum nvme_csi csi, __u8 uidx, struct nvme_nvm_id_ns *id_ns)
+static inline void
+nvme_init_copy_range(struct nvme_copy_range *copy, __u16 *nlbs,
+		__u64 *slbas, __u32 *eilbrts, __u32 *elbatms,
+		__u32 *elbats, __u16 nr)
 {
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_identify_csi_ns(&cmd, nsid, csi, uidx, id_ns);
+	int i;
 
-	return nvme_submit_admin_passthru(hdl, &cmd);
+	for (i = 0; i < nr; i++) {
+		copy[i].nlb = htole16(nlbs[i]);
+		copy[i].slba = htole64(slbas[i]);
+		copy[i].eilbrt = htole32(eilbrts[i]);
+		copy[i].elbatm = htole16(elbatms[i]);
+		copy[i].elbat = htole16(elbats[i]);
+	}
 }
 
 /**
- * nvme_identify_uuid_list() - Submit an Identify UUID List command
- * @hdl:	Transport handle for the controller.
- * @uuid_list:	Pointer to the buffer (&struct nvme_id_uuid_list) where the
- *		UUID list will be stored.
- *
- * Submits the Identify command to retrieve a list of UUIDs associated
- * with the controller.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * nvme_init_copy_range_f1() - Constructs a copy range f1 structure
+ * @copy:	Copy range array
+ * @nlbs:	Number of logical blocks
+ * @slbas:	Starting LBA
+ * @eilbrts:	Expected initial logical block reference tag
+ * @elbatms:	Expected logical block application tag mask
+ * @elbats:	Expected logical block application tag
+ * @nr:		Number of descriptors to construct
  */
-static inline int
-nvme_identify_uuid_list(struct nvme_transport_handle *hdl,
-		struct nvme_id_uuid_list *uuid_list)
+static inline void
+nvme_init_copy_range_f1(struct nvme_copy_range_f1 *copy, __u16 *nlbs,
+		__u64 *slbas, __u64 *eilbrts, __u32 *elbatms,
+		__u32 *elbats, __u16 nr)
 {
-	struct nvme_passthru_cmd cmd;
+	int i;
 
-	nvme_init_identify_uuid_list(&cmd, uuid_list);
-
-	return nvme_submit_admin_passthru(hdl, &cmd);
+	for (i = 0; i < nr; i++) {
+		copy[i].nlb = htole16(nlbs[i]);
+		copy[i].slba = htole64(slbas[i]);
+		copy[i].elbatm = htole16(elbatms[i]);
+		copy[i].elbat = htole16(elbats[i]);
+		nvme_init_copy_range_elbt(copy[i].elbt, eilbrts[i]);
+	}
 }
 
 /**
- * nvme_identify_csi_ns_user_data_format() - Submit an Identify CSI Namespace
- * User Data Format command
- * @hdl:	Transport handle for the controller.
- * @csi:	Command Set Identifier.
- * @fidx:	Format Index, specifying which format entry to return.
- * @uidx:	The UUID Index for the command.
- * @data:	Pointer to the buffer where the format data will be stored.
- *
- * Submits the Identify command to retrieve a CSI-specific Namespace User
- * Data Format data structure.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * nvme_init_copy_range_f2() - Constructs a copy range f2 structure
+ * @copy:	Copy range array
+ * @snsids:	Source namespace identifier
+ * @nlbs:	Number of logical blocks
+ * @slbas:	Starting LBA
+ * @sopts:	Source options
+ * @eilbrts:	Expected initial logical block reference tag
+ * @elbatms:	Expected logical block application tag mask
+ * @elbats:	Expected logical block application tag
+ * @nr:		Number of descriptors to construct
  */
-static inline int
-nvme_identify_csi_ns_user_data_format(struct nvme_transport_handle *hdl,
-		enum nvme_csi csi, __u16 fidx, __u8 uidx, void *data)
+static inline void
+nvme_init_copy_range_f2(struct nvme_copy_range_f2 *copy,
+		__u32 *snsids, __u16 *nlbs, __u64 *slbas, __u16 *sopts,
+		__u32 *eilbrts, __u32 *elbatms, __u32 *elbats,
+		__u16 nr)
 {
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_identify_csi_ns_user_data_format(&cmd, csi, fidx, uidx, data);
+	int i;
 
-	return nvme_submit_admin_passthru(hdl, &cmd);
+	for (i = 0; i < nr; i++) {
+		copy[i].snsid = htole32(snsids[i]);
+		copy[i].nlb = htole16(nlbs[i]);
+		copy[i].slba = htole64(slbas[i]);
+		copy[i].sopt = htole16(sopts[i]);
+		copy[i].eilbrt = htole32(eilbrts[i]);
+		copy[i].elbatm = htole16(elbatms[i]);
+		copy[i].elbat = htole16(elbats[i]);
+	}
 }
 
 /**
- * nvme_identify_ns_granularity() - Submit an Identify Namespace Granularity
- * List command
- * @hdl:	Transport handle for the controller.
- * @gr_list:	Pointer to the buffer (&struct nvme_id_ns_granularity_list)
- *		where the granularity list will be stored.
- *
- * Submits the Identify command to retrieve the Namespace Granularity List.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * nvme_init_copy_range_f3() - Constructs a copy range f3 structure
+ * @copy:	Copy range array
+ * @snsids:	Source namespace identifier
+ * @nlbs:	Number of logical blocks
+ * @slbas:	Starting LBA
+ * @sopts:	Source options
+ * @eilbrts:	Expected initial logical block reference tag
+ * @elbatms:	Expected logical block application tag mask
+ * @elbats:	Expected logical block application tag
+ * @nr:		Number of descriptors to construct
  */
-static inline int
-nvme_identify_ns_granularity(struct nvme_transport_handle *hdl,
-		struct nvme_id_ns_granularity_list *gr_list)
+static inline void
+nvme_init_copy_range_f3(struct nvme_copy_range_f3 *copy, __u32 *snsids,
+		__u16 *nlbs, __u64 *slbas, __u16 *sopts,
+		__u64 *eilbrts, __u32 *elbatms, __u32 *elbats,
+		__u16 nr)
 {
-	struct nvme_passthru_cmd cmd;
+	int i;
 
-	nvme_init_identify_ns_granularity(&cmd, gr_list);
-
-	return nvme_submit_admin_passthru(hdl, &cmd);
+	for (i = 0; i < nr; i++) {
+		copy[i].snsid = htole32(snsids[i]);
+		copy[i].nlb = htole16(nlbs[i]);
+		copy[i].slba = htole64(slbas[i]);
+		copy[i].sopt = htole16(sopts[i]);
+		copy[i].elbatm = htole16(elbatms[i]);
+		copy[i].elbat = htole16(elbats[i]);
+		nvme_init_copy_range_elbt(copy[i].elbt, eilbrts[i]);
+	}
 }
 
 /**
- * nvme_identify_ns_descs_list() - Submit an Identify Namespace ID Descriptor
- * List command
- * @hdl:	Transport handle for the controller.
- * @nsid:	The Namespace ID to query.
- * @descs:	Pointer to the buffer (&struct nvme_ns_id_desc) where the
- *		descriptor list will be stored.
- *
- * Submits the Identify command to retrieve the Namespace ID Descriptor List
- * for a specified namespace.
+ * nvme_get_log() - Get log page data
+ * @hdl:	Transport handle
+ * @cmd:	Passthru command
+ * @rae:	Retain asynchronous events
+ * @xfer_len:	Max log transfer size per request to split the total.
  *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * Return: 0 on success, the nvme command status if a response was
+ * received (see &enum nvme_status_field) or a negative error otherwise.
  */
-static inline int
-nvme_identify_ns_descs_list(struct nvme_transport_handle *hdl,
-		__u32 nsid, struct nvme_ns_id_desc *descs)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_identify_ns_descs_list(&cmd, nsid, descs);
-
-	return nvme_submit_admin_passthru(hdl, &cmd);
-}
+int nvme_get_log(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd, bool rae,
+		 __u32 xfer_len);
 
 /**
- * nvme_zns_identify_ns() - Submit a ZNS-specific Identify Namespace command
- * @hdl:	Transport handle for the controller.
- * @nsid:	The Namespace ID to identify.
- * @data:	Pointer to the buffer (&struct nvme_zns_id_ns) where the ZNS
- *		namespace identification data will be stored.
- *
- * Submits the Identify command to retrieve the Zoned Namespace (ZNS)
- * specific identification data structure for a specified namespace.
+ * nvme_set_etdas() - Set the Extended Telemetry Data Area 4 Supported bit
+ * @hdl:	Transport handle
+ * @changed:	boolean to indicate whether or not the host
+ *		behavior support feature had been changed
  *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * Return: The nvme command status if a response was received (see
+ * &enum nvme_status_field) or -1 with errno set otherwise.
  */
-static inline int
-nvme_zns_identify_ns(struct nvme_transport_handle *hdl,
-		__u32 nsid, struct nvme_zns_id_ns *data)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_zns_identify_ns(&cmd, nsid, data);
-
-	return nvme_submit_admin_passthru(hdl, &cmd);
-}
+int nvme_set_etdas(struct nvme_transport_handle *hdl, bool *changed);
 
 /**
- * nvme_get_log_simple() - Retrieve a log page using default parameters
- * @hdl:	Transport handle for the controller.
- * @lid:	Log Identifier, specifying the log page to retrieve
- *		(@enum nvme_cmd_get_log_lid).
- * @data:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the data buffer in bytes.
- *
- * Submits the Get Log Page command using the common settings:
- * NVME\_NSID\_ALL, Retain Asynchronous Event (RAE) set to false,
- * and assuming the NVM Command Set.
+ * nvme_clear_etdas() - Clear the Extended Telemetry Data Area 4 Supported bit
+ * @hdl:	Transport handle
+ * @changed:	boolean to indicate whether or not the host
+ *		behavior support feature had been changed
  *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * Return: The nvme command status if a response was received (see
+ * &enum nvme_status_field) or -1 with errno set otherwise.
  */
-static inline int
-nvme_get_log_simple(struct nvme_transport_handle *hdl,
-		enum nvme_cmd_get_log_lid lid, void *data, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log(&cmd, NVME_NSID_ALL, lid, NVME_CSI_NVM, data, len);
-
-	return nvme_get_log(hdl, &cmd, false, NVME_LOG_PAGE_PDU_SIZE);
-}
+int nvme_clear_etdas(struct nvme_transport_handle *hdl, bool *changed);
 
 /**
- * nvme_get_log_supported_log_pages() - Retrieve the Supported Log Pages
- * Log Page
- * @hdl:	Transport handle for the controller.
- * @log:	Pointer to the buffer (@struct nvme_supported_log_pages) where
- *		the log page data will be stored.
- *
- * Submits the Get Log Page command specifically for the Supported Log Pages
- * Log.
+ * nvme_get_uuid_list - Returns the uuid list (if supported)
+ * @hdl:	Transport handle
+ * @uuid_list:	UUID list returned by identify UUID
  *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * Return: The nvme command status if a response was received (see
+ * &enum nvme_status_field) or -1 with errno set otherwise.
  */
-static inline int
-nvme_get_log_supported_log_pages(struct nvme_transport_handle *hdl,
-		struct nvme_supported_log_pages *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log(&cmd, NVME_NSID_ALL, NVME_LOG_LID_SUPPORTED_LOG_PAGES,
-		NVME_CSI_NVM, log, sizeof(*log));
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
-}
-
+int nvme_get_uuid_list(struct nvme_transport_handle *hdl,
+		struct nvme_id_uuid_list *uuid_list);
 
 /**
- * nvme_get_log_error() - Retrieve the Error Information Log Page
- * @hdl:	Transport handle for the controller.
- * @nsid:	Namespace ID to request the log for (usually NVME_NSID_ALL).
- * @nr_entries:	The maximum number of error log entries to retrieve.
- * @err_log:	Pointer to the buffer (array of @struct nvme_error_log_page)
- *		where the log page data will be stored.
- *
- * This log page describes extended error information for a command that
- * completed with error, or may report an error that is not specific to a
- * particular command. The total size requested is determined by
- * @nr_entries * sizeof(@struct nvme_error_log_page).
+ * nvme_get_telemetry_max() - Get telemetry limits
+ * @hdl:	Transport handle
+ * @da:		On success return max supported data area
+ * @max_data_tx: On success set to max transfer chunk supported by
+ *		the controller
  *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
+ * Return: 0 on success, the nvme command status if a response was
+ * received (see &enum nvme_status_field) or a negative error otherwise.
  */
-static inline int
-nvme_get_log_error(struct nvme_transport_handle *hdl, __u32 nsid,
-		unsigned int nr_entries, struct nvme_error_log_page *err_log)
-{
-	struct nvme_passthru_cmd cmd;
-	size_t len = sizeof(*err_log) * nr_entries;
-
-	nvme_init_get_log(&cmd, nsid, NVME_LOG_LID_ERROR,
-		NVME_CSI_NVM, err_log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
+int nvme_get_telemetry_max(struct nvme_transport_handle *hdl,
+		enum nvme_telemetry_da *da, size_t *max_data_tx);
 
 /**
- * nvme_get_log_fw_slot() - Retrieve the Firmware Slot Information Log Page
- * @hdl:	Transport handle for the controller.
- * @nsid:	Namespace ID to request the log for (use NVME_NSID_ALL).
- * @fw_log:	Pointer to the buffer (@struct nvme_firmware_slot) where the log
- *		page data will be stored.
- *
- * This log page describes the firmware revision stored in each firmware slot
- * supported. The firmware revision is indicated as an ASCII string. The log
- * page also indicates the active slot number.
+ * nvme_get_telemetry_log() - Get specified telemetry log
+ * @hdl:	Transport handle
+ * @create:	Generate new host initated telemetry capture
+ * @ctrl:	Get controller Initiated log
+ * @rae:	Retain asynchronous events
+ * @max_data_tx: Set the max data transfer size to be used retrieving telemetry.
+ * @da:		Log page data area, valid values: &enum nvme_telemetry_da.
+ * @log:	On success, set to the value of the allocated and retrieved log.
+ * @size:	Ptr to the telemetry log size, so it can be returned
  *
- * This command is typically issued for the controller scope, thus using
- * NVME_NSID_ALL.
+ * The total size allocated can be calculated as:
+ *   (nvme_telemetry_log da size  + 1) * NVME_LOG_TELEM_BLOCK_SIZE.
  *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_fw_slot(struct nvme_transport_handle *hdl, __u32 nsid,
-		struct nvme_firmware_slot *fw_log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log(&cmd, nsid, NVME_LOG_LID_FW_SLOT,
-		NVME_CSI_NVM, fw_log, sizeof(*fw_log));
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*fw_log));
-}
-
-/**
- * nvme_get_log_changed_ns_list() - Retrieve the Namespace Change Log Page
- * @hdl:	Transport handle for the controller.
- * @nsid:	Namespace ID to request the log for (use NVME_NSID_ALL).
- * @ns_log:	Pointer to the buffer (@struct nvme_ns_list) where the log
- *		page data will be stored.
- *
- * This log page describes namespaces attached to this controller that have
- * changed since the last time the namespace was identified, been added, or
- * deleted.
- *
- * This command is typically issued for the controller scope, thus using
- * NVME_NSID_ALL. The Retain Asynchronous Event (RAE) is true to retain
- * asynchronous events associated with the log page
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_changed_ns_list(struct nvme_transport_handle *hdl, __u32 nsid,
-		struct nvme_ns_list *ns_log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log(&cmd, nsid, NVME_LOG_LID_CHANGED_NS,
-		NVME_CSI_NVM, ns_log, sizeof(*ns_log));
-
-	return nvme_get_log(hdl, &cmd, true, sizeof(*ns_log));
-}
-
-/**
- * nvme_get_log_cmd_effects() - Retrieve the Command Effects Log Page
- * @hdl:	Transport handle for the controller.
- * @csi:	Command Set Identifier for the requested log page.
- * @effects_log:Pointer to the buffer (@struct nvme_cmd_effects_log) where the
- *		log page data will be stored.
- *
- * This log page describes the commands that the controller supports and the
- * effects of those commands on the state of the NVM subsystem.
- *
- * It automatically sets the Log Identifier (LID) and Retain Asynchronous
- * Event (RAE) to false. This command is typically issued for the controller
- * scope, thus using NVME_NSID_ALL.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_cmd_effects(struct nvme_transport_handle *hdl,
-		enum nvme_csi csi, struct nvme_cmd_effects_log *effects_log)
-{
-	struct nvme_passthru_cmd cmd;
-	size_t len = sizeof(*effects_log);
-
-	nvme_init_get_log_cmd_effects(&cmd, csi, effects_log);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_device_self_test() - Retrieve the Device Self-Test Log Page
- * @hdl:	Transport handle for the controller.
- * @log:	Pointer to the buffer (@struct nvme_self_test_log) where the log
- *		page data will be stored.
- *
- * This log page indicates the status of an in-progress self-test and the
- * percent complete of that operation, and the results of the previous 20
- * self-test operations.
- *
- * It automatically sets the Log Identifier (LID) and Retain Asynchronous
- * Event (RAE) to false. This command is typically issued for the controller
- * scope, thus using NVME_NSID_ALL.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_device_self_test(struct nvme_transport_handle *hdl,
-		struct nvme_self_test_log *log)
-{
-	struct nvme_passthru_cmd cmd;
-	size_t len = sizeof(*log);
-
-	nvme_init_get_log(&cmd, NVME_NSID_ALL, NVME_LOG_LID_DEVICE_SELF_TEST,
-		NVME_CSI_NVM, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_create_telemetry_host_mcda() - Create the Host Initiated
- * Telemetry Log
- * @hdl:	Transport handle for the controller.
- * @mcda:	Maximum Created Data Area. Specifies the maximum amount of data
- *		that may be returned by the controller.
- * @log:	Pointer to the buffer (@struct nvme_telemetry_log) where the log
- *		page data will be stored.
- *
- * Submits the Get Log Page command to initiate the creation of a Host Initiated
- * Telemetry Log. It sets the Log Identifier (LID) to Telemetry Host and
- * includes the Maximum Created Data Area (MCDA) in the Log Specific Parameter
- * (LSP) field along with the Create bit.
- *
- * It automatically sets Retain Asynchronous Event (RAE) to false.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_create_telemetry_host_mcda(struct nvme_transport_handle *hdl,
-		enum nvme_telemetry_da mcda, struct nvme_telemetry_log *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_create_telemetry_host_mcda(&cmd, mcda, log);
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
-}
-
-/**
- * nvme_get_log_create_telemetry_host() - Create the Host Initiated Telemetry
- * Log (Controller Determined Size)
- * @hdl:	Transport handle for the controller.
- * @log:	Pointer to the buffer (@struct nvme_telemetry_log) where the log
- *		page data will be stored.
- *
- * Submits the Get Log Page command to initiate the creation of a Host Initiated
- * Telemetry Log. This is a convenience wrapper that automatically uses the
- * Controller Determined size for the Maximum Created Data Area (MCDA).
- *
- * It automatically sets Retain Asynchronous Event (RAE) to false.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_create_telemetry_host(struct nvme_transport_handle *hdl,
-		struct nvme_telemetry_log *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_create_telemetry_host(&cmd, log);
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
-}
-
-/**
- * nvme_get_log_telemetry_host() - Retrieve the Host-Initiated
- * Telemetry Log Page (Retain)
- * @hdl:	Transport handle for the controller.
- * @lpo:	Offset (in bytes) into the telemetry data to start the
- *		retrieval.
- * @log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command to retrieve a previously captured
- * Host-Initiated Telemetry Log, starting at a specified offset (@lpo). The Log
- * Specific Parameter (LSP) field is set to indicate the capture should be
- * retained (not deleted after read).
- *
- * It automatically sets the Log Identifier (LID) and Retain Asynchronous Event
- * (RAE) to false.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_telemetry_host(struct nvme_transport_handle *hdl,
-		__u64 lpo, void *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_telemetry_host(&cmd, lpo, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_telemetry_ctrl() - Retrieve the Controller-Initiated
- * Telemetry Log Page
- * @hdl:	Transport handle for the controller.
- * @rae:	Retain asynchronous events
- * @lpo:	Offset (in bytes) into the telemetry data to start the
- *		retrieval.
- * @log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Controller-Initiated
- * Telemetry Log, allowing retrieval of data starting at a specified offset
- * (@lpo).
- *
- * It automatically sets the Log Identifier (LID).
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_telemetry_ctrl(struct nvme_transport_handle *hdl, bool rae,
-		__u64 lpo, void *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_telemetry_ctrl(&cmd, lpo, log, len);
-
-	return nvme_get_log(hdl, &cmd, rae, len);
-}
-
-/**
- * nvme_get_log_endurance_group() - Retrieve the Endurance Group Log Page
- * @hdl:	Transport handle for the controller.
- * @endgid:	Starting Endurance Group Identifier (ENDGID) to return in
- *		the list.
- * @log:	Pointer to the buffer (@struct nvme_endurance_group_log) where
- *		the log page data will be stored.
- *
- * This log page indicates if an Endurance Group Event has occurred for a
- * particular Endurance Group. The ENDGID is placed in the Log Specific
- * Identifier (LSI) field of the Get Log Page command.
- *
- * It automatically sets the Log Identifier (LID) and Retain Asynchronous
- * Event (RAE) to false. This command is typically issued for the controller
- * scope, thus using NVME_NSID_NONE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_endurance_group(struct nvme_transport_handle *hdl,
-		__u16 endgid, struct nvme_endurance_group_log *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_endurance_group(&cmd, endgid, log);
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
-}
-
-/**
- * nvme_get_log_predictable_lat_nvmset() - Retrieve the Predictable Latency
- * Per NVM Set Log Page
- * @hdl:	Transport handle for the controller.
- * @nvmsetid:	The NVM Set Identifier (NVMSETID) for which to retrieve the log.
- * @log:	Pointer to the buffer (@struct nvme_nvmset_predictable_lat_log)
- *		where the log page data will be stored.
- *
- * Submits the Get Log Page command specifically for the Predictable Latency Per
- * NVM Set Log. The NVMSETID is placed in the Log Specific Identifier (LSI)
- * field of the command.
- *
- * It automatically sets the Log Identifier (LID) and Retain Asynchronous
- * Event (RAE) to false. This command is typically issued for the controller
- * scope, thus using NVME_NSID_NONE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_predictable_lat_nvmset(struct nvme_transport_handle *hdl,
-		__u16 nvmsetid, struct nvme_nvmset_predictable_lat_log *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_predictable_lat_nvmset(&cmd, nvmsetid, log);
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
-}
-
-/**
- * nvme_get_log_predictable_lat_event() - Retrieve the Predictable Latency Event
- * Aggregate Log Page
- * @hdl:	Transport handle for the controller.
- * @rae:	Retain asynchronous events
- * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
- * @log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Predictable Latency
- * Event Aggregate Log, allowing retrieval of data starting at a specified
- * offset (@lpo).
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_PREDICTABLE_LAT_AGG.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_predictable_lat_event(struct nvme_transport_handle *hdl,
-		bool rae, __u64 lpo, void *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_predictable_lat_event(&cmd, lpo, log, len);
-
-	return nvme_get_log(hdl, &cmd, rae, len);
-}
-
-/**
- * nvme_get_log_fdp_configurations() - Retrieve the Flexible Data Placement
- * (FDP) Configurations Log Page
- * @hdl:	Transport handle for the controller.
- * @egid:	Endurance Group Identifier (EGID) to return in the
- *		list (used in LSI).
- * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
- * @log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the FDP Configurations Log.
- * The EGID is placed in the Log Specific Identifier (LSI) field.
- *
- * It automatically sets the Log Identifier (LID) and Retain Asynchronous
- * Event (RAE) to false. This command is typically issued for the controller
- * scope, thus using NVME_NSID_NONE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_fdp_configurations(struct nvme_transport_handle *hdl,
-		__u16 egid, __u64 lpo, void *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_fdp_configurations(&cmd, egid, lpo, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_reclaim_unit_handle_usage() - Retrieve the FDP Reclaim Unit
- * Handle (RUH) Usage Log Page
- * @hdl:	Transport handle for the controller.
- * @egid:	Endurance Group Identifier (EGID) (used in LSI).
- * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
- * @log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the FDP Reclaim Unit Handle
- * Usage Log. The EGID is placed in the Log Specific Identifier (LSI) field.
- *
- * It automatically sets the Log Identifier (LID) and Retain Asynchronous
- * Event (RAE) to false. This command is typically issued for the controller
- * scope, thus using NVME_NSID_NONE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_reclaim_unit_handle_usage(struct nvme_transport_handle *hdl,
-		__u16 egid, __u64 lpo, void *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_reclaim_unit_handle_usage(&cmd, egid, lpo, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_fdp_stats() - Retrieve the Flexible Data Placement (FDP)
- * Statistics Log Page
- * @hdl:	Transport handle for the controller.
- * @egid:	Endurance Group Identifier (EGID) (used in LSI).
- * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
- * @log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the FDP Statistics Log.
- * The EGID is placed in the Log Specific Identifier (LSI) field.
- *
- * It automatically sets the Log Identifier (LID) and Retain Asynchronous
- * Event (RAE) to false. This command is typically issued for the controller
- * scope, thus using NVME_NSID_NONE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_fdp_stats(struct nvme_transport_handle *hdl,
-		__u16 egid, __u64 lpo, void *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_fdp_stats(&cmd, egid, lpo, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_fdp_events() - Retrieve the Flexible Data Placement (FDP)
- * Events Log Page
- * @hdl:	Transport handle for the controller.
- * @egid:	Endurance Group Identifier (EGID) (used in LSI).
- * @host_events:Whether to report host-initiated events (true) or
- *		controller-initiated events (false).
- * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
- * @log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the FDP Events Log.
- * The EGID is placed in the Log Specific Identifier (LSI) field, and the
- * @host_events flag is used to set the Log Specific Parameter (LSP) field.
- *
- * It automatically sets the Log Identifier (LID) and Retain Asynchronous
- * Event (RAE) to false. This command is typically issued for the controller
- * scope, thus using NVME_NSID_NONE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_fdp_events(struct nvme_transport_handle *hdl,
-		__u16 egid, bool host_events, __u64 lpo, void *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_fdp_events(&cmd, egid, host_events, lpo, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_ana() - Retrieve the Asymmetric Namespace Access (ANA) Log Page
- * @hdl:	Transport handle for the controller.
- * @rae:	Retain asynchronous events
- * @lsp:	Log specific parameter, see &enum nvme_get_log_ana_lsp.
- * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
- * @log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * This log consists of a header describing the log and descriptors containing
- * the ANA information for groups that contain namespaces attached to the
- * controller. The @lsp parameter is placed in the Log Specific Parameter field
- * of the command.
- *
- * See &struct nvme_ana_log for the definition of the returned structure.
- *
- * It automatically sets the Log Identifier (LID) to NVME_LOG_LID_ANA.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_ana(struct nvme_transport_handle *hdl, bool rae,
-		 enum nvme_log_ana_lsp lsp, __u64 lpo, void *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_ana(&cmd, lsp, lpo, log, len);
-
-	return nvme_get_log(hdl, &cmd, rae, len);
-}
-
-/**
- * nvme_get_log_ana_groups() - Retrieve the Asymmetric Namespace Access (ANA)
- * Groups Only Log Page
- * @hdl:	Transport handle for the controller.
- * @rae:	Retain asynchronous events
- * @log:	Pointer to the buffer (@struct nvme_ana_log) where the log page
- *		data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * This function retrieves only the ANA Group Descriptors by setting the Log
- * Specific Parameter (LSP) field to NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY. It is a
- * convenience wrapper around nvme_get_log_ana, using a Log Page Offset (LPO) of
- * 0.
- *
- * See &struct nvme_ana_log for the definition of the returned structure.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_ana_groups(struct nvme_transport_handle *hdl, bool rae,
-		struct nvme_ana_log *log, __u32 len)
-{
-	return nvme_get_log_ana(hdl, rae, NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY,
-		0, log, len);
-}
-
-/**
- * nvme_get_log_lba_status() - Retrieve the LBA Status Log Page
- * @hdl:	Transport handle for the controller.
- * @rae:	Retain asynchronous events
- * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
- * @log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the LBA Status Log.
- *
- * It automatically sets the Log Identifier (LID) to NVME_LOG_LID_LBA_STATUS.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_lba_status(struct nvme_transport_handle *hdl,
-		bool rae, __u64 lpo, void *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_lba_status(&cmd, lpo, log, len);
-
-	return nvme_get_log(hdl, &cmd, rae, len);
-}
-
-/**
- * nvme_get_log_endurance_grp_evt() - Retrieve the Endurance Group Event
- * Aggregate Log Page
- * @hdl:	Transport handle for the controller.
- * @rae:	Retain asynchronous events
- * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
- * @log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Endurance Group Event
- * Aggregate Log, allowing retrieval of data starting at a specified offset
- * (@lpo).
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_ENDURANCE_GRP_EVT.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_endurance_grp_evt(struct nvme_transport_handle *hdl,
-		bool rae, __u64 lpo, void *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_endurance_grp_evt(&cmd, lpo, log, len);
-
-	return nvme_get_log(hdl, &cmd, rae, len);
-}
-
-/**
- * nvme_get_log_fid_supported_effects() - Retrieve the Feature Identifiers
- * Supported and Effects Log Page
- * @hdl:	Transport handle for the controller.
- * @csi:	Command set identifier, see &enum nvme_csi for known values
- * @log:	Pointer to the buffer (@struct nvme_fid_supported_effects_log)
- *		where the log page data will be stored.
- *
- * Submits the Get Log Page command specifically for the Feature Identifiers
- * Supported and Effects Log. It automatically sets the Log Identifier (LID).
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_fid_supported_effects(struct nvme_transport_handle *hdl,
-		enum nvme_csi csi, struct nvme_fid_supported_effects_log *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_fid_supported_effects(&cmd, csi, log);
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
-}
-
-/**
- * nvme_get_log_mi_cmd_supported_effects() - Retrieve the Management Interface
- * (MI) Commands Supported and Effects Log Page
- * @hdl:	Transport handle for the controller.
- * @log:	Pointer to the buffer
- *		(@struct nvme_mi_cmd_supported_effects_log) where the log page
- *		data will be stored.
- *
- * Submits the Get Log Page command specifically for the MI Commands Supported
- * and Effects Log. It automatically sets the Log Identifier (LID). This command
- * is typically issued with a namespace ID of 0xFFFFFFFF (NVME_NSID_NONE).
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_mi_cmd_supported_effects(struct nvme_transport_handle *hdl,
-		struct nvme_mi_cmd_supported_effects_log *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_mi_cmd_supported_effects(&cmd, log);
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
-}
-
-/**
- * nvme_get_log_boot_partition() - Retrieve the Boot Partition Log Page
- * @hdl:	Transport handle for the controller.
- * @lsp:	The Log Specific Parameter (LSP) field for this Log
- *		Identifier (LID).
- * @part:	Pointer to the buffer (@struct nvme_boot_partition) where
- *		the log page data will be stored.
- * @len:	Length of the buffer provided in @part.
- *
- * Submits the Get Log Page command specifically for the Boot Partition Log.
- * The LSP field is set based on the @lsp parameter.
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_BOOT_PARTITION.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_boot_partition(struct nvme_transport_handle *hdl,
-		__u8 lsp, struct nvme_boot_partition *part, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_boot_partition(&cmd, lsp, part, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_rotational_media_info() - Retrieve the Rotational Media
- * Information Log Page
- * @hdl:	Transport handle for the controller.
- * @endgid:	The Endurance Group Identifier (ENDGID) to retrieve the
- *		log for (used in LSI).
- * @log:	Pointer to the buffer (@struct nvme_rotational_media_info_log)
- *		where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Rotational Media
- * Information Log. The ENDGID is placed in the Log Specific Identifier (LSI)
- * field of the command.
- *
- * It automatically sets the Log Identifier (LID) and Retain Asynchronous
- * Event (RAE) to false. This command is typically issued for the controller
- * scope, thus using NVME_NSID_NONE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_rotational_media_info(struct nvme_transport_handle *hdl,
-		__u16 endgid, struct nvme_rotational_media_info_log *log,
-		__u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_rotational_media_info(&cmd, endgid, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_dispersed_ns_participating_nss() - Retrieve the Dispersed
- * Namespace Participating NVM Subsystems Log Page
- * @hdl:	Transport handle for the controller.
- * @nsid:	Namespace ID to request the log for.
- * @log:	Pointer to the buffer
- *		(@struct nvme_dispersed_ns_participating_nss_log)
- *		where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Dispersed Namespace
- * Participating NVM Subsystems Log. It automatically sets the Log Identifier
- * (LID) and Retain Asynchronous Event (RAE) to false.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_dispersed_ns_participating_nss(struct nvme_transport_handle *hdl,
-		__u32 nsid, struct nvme_dispersed_ns_participating_nss_log *log,
-		__u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_dispersed_ns_participating_nss(&cmd, nsid, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_mgmt_addr_list() - Retrieve the Management Address List Log Page
- * @hdl:	Transport handle for the controller.
- * @log:	Pointer to the buffer (@struct nvme_mgmt_addr_list_log) where
- *		the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Management Address List
-   Log.
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_MGMT_ADDR_LIST, Retain Asynchronous Event (RAE) to false, and
- * uses NVME_NSID_NONE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_mgmt_addr_list(struct nvme_transport_handle *hdl,
-		struct nvme_mgmt_addr_list_log *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_mgmt_addr_list(&cmd, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_phy_rx_eom() - Retrieve the Physical Interface Receiver Eye
- * Opening Measurement Log Page
- * @hdl:	Transport handle for the controller.
- * @lsp:	Log Specific Parameter (LSP), which controls the action
- *		and measurement quality.
- * @controller:	Target Controller ID (used in LSI).
- * @log:	Pointer to the buffer (@struct nvme_phy_rx_eom_log) where
- *		the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Physical Interface
- * Receiver Eye Opening Measurement Log. The Controller ID is placed in the
- * Log Specific Identifier (LSI) field.
- *
- * It automatically sets the Log Identifier (LID) to NVME_LOG_LID_PHY_RX_EOM,
- * and Retain Asynchronous Event (RAE) to false. This command is typically
- * issued for the controller scope, thus using NVME_NSID_NONE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_phy_rx_eom(struct nvme_transport_handle *hdl,
-		__u8 lsp, __u16 controller, struct nvme_phy_rx_eom_log *log,
-		__u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_phy_rx_eom(&cmd, lsp, controller, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_reachability_groups() - Retrieve the Reachability Groups
- * Log Page
- * @hdl:	Transport handle for the controller.
- * @nsid:	Namespace ID to request the log for.
- * @rgo:	Return Groups Only. Set to true to return only the Reachability
- *		Group Descriptors.
- * @log:	Pointer to the buffer (@struct nvme_reachability_groups_log)
- *		where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Reachability Groups
- * Log. The @rgo parameter is placed in the Log Specific Parameter (LSP) field.
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_REACHABILITY_GROUPS.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_reachability_groups(struct nvme_transport_handle *hdl,
-		__u32 nsid, bool rgo, struct nvme_reachability_groups_log *log,
-		__u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_reachability_groups(&cmd, rgo, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_reachability_associations() - Retrieve the Reachability
- * Associations Log Page
- * @hdl:	Transport handle for the controller.
- * @rae:	Retain asynchronous events
- * @rao:	Return Associations Only. Set to true to return only the
- *		Reachability Association Descriptors.
- * @log:	Pointer to the buffer
- *		(@struct nvme_reachability_associations_log) where the log
- *		page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Reachability
- * Associations Log. The @rao parameter is placed in the Log Specific Parameter
- * (LSP) field.
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_REACHABILITY_ASSOCIATIONS.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_reachability_associations(struct nvme_transport_handle *hdl,
-		bool rae, bool rao,
-		struct nvme_reachability_associations_log *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_reachability_associations(&cmd, rao, log, len);
-
-	return nvme_get_log(hdl, &cmd, rae, len);
-}
-
-/**
- * nvme_get_log_changed_alloc_ns_list() - Retrieve the Changed Allocated
- * Namespace List Log Page
- * @hdl:	Transport handle for the controller.
- * @log:	Pointer to the buffer (@struct nvme_ns_list) where the log page
- *		data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Changed Allocated
- * Namespace List Log.
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_CHANGED_ALLOC_NS_LIST.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_changed_alloc_ns_list(struct nvme_transport_handle *hdl,
-		struct nvme_ns_list *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_changed_ns(&cmd, log);
-
-	return nvme_get_log(hdl, &cmd, true, len);
-}
-
-/**
- * nvme_get_log_discovery() - Retrieve the Discovery Log Page
- * @hdl:	Transport handle for the controller.
- * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
- * @log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Discovery Log.
- * Supported only by NVMe-oF Discovery controllers, returning discovery records.
- *
- * It automatically sets the Log Identifier (LID) to NVME_LOG_LID_DISCOVERY.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_discovery(struct nvme_transport_handle *hdl,
-		__u64 lpo, __u32 len, void *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_discovery(&cmd, lpo, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_host_discovery() - Retrieve the Host Discovery Log Page
- * @hdl:	Transport handle for the controller.
- * @rae:	Retain asynchronous events
- * @allhoste:	All Host Entries. Set to true to report all host entries.
- * @log:	Pointer to the buffer (@struct nvme_host_discover_log)
- *		where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Host Discovery Log.
- * The @allhoste parameter is placed in the Log Specific Parameter (LSP) field.
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_HOST_DISCOVERY.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_host_discovery(struct nvme_transport_handle *hdl,
-			   bool rae, bool allhoste,
-			   struct nvme_host_discover_log *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_host_discovery(&cmd, allhoste, log, len);
-
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_ave_discovery() - Retrieve the Asynchronous Event
- * Group (AVE) Discovery Log Page
- * @hdl:	Transport handle for the controller.
- * @rae:	Retain asynchronous events
- * @log:	Pointer to the buffer (@struct nvme_ave_discover_log) where
- *		the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Asynchronous Event
- * Group (AVE) Discovery Log. It automatically sets the Log Identifier (LID).
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_ave_discovery(struct nvme_transport_handle *hdl,
-		bool rae, struct nvme_ave_discover_log *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_ave_discovery(&cmd, log, len);
-
-	return nvme_get_log(hdl, &cmd, rae, len);
-}
-
-/**
- * nvme_get_log_pull_model_ddc_req() - Retrieve the Pull Model DDC Request
- * Log Page
- * @hdl:	Transport handle for the controller.
- * @rae:	Retain asynchronous events
- * @log:	Pointer to the buffer (@struct nvme_pull_model_ddc_req_log)
- *		where the log page data will be stored.
- * @len:	Length of the buffer provided in @log.
- *
- * Submits the Get Log Page command specifically for the Pull Model DDC Request
- * Log. It automatically sets the Log Identifier (LID).
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_pull_model_ddc_req(struct nvme_transport_handle *hdl,
-		bool rae, struct nvme_pull_model_ddc_req_log *log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_pull_model_ddc_req(&cmd, log, len);
-
-	return nvme_get_log(hdl, &cmd, rae, len);
-}
-
-/**
- * nvme_get_log_media_unit_stat() - Retrieve the Media Unit Status Log Page
- * @hdl:	Transport handle for the controller.
- * @domid:	The Domain Identifier (DOMID) selection, if supported
- *		(used in LSI).
- * @mus:	Pointer to the buffer (@struct nvme_media_unit_stat_log)
- *		where the log page data will be stored.
- *
- * Submits the Get Log Page command specifically for the Media Unit Status Log.
- * The DOMID is placed in the Log Specific Identifier (LSI) field of the
- * command.
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_MEDIA_UNIT_STATUS, and Retain Asynchronous Event (RAE) to false.
- * This command is typically issued for the controller scope, thus using
- * NVME_NSID_NONE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_media_unit_stat(struct nvme_transport_handle *hdl,
-		__u16 domid, struct nvme_media_unit_stat_log *mus)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_media_unit_stat(&cmd, domid, mus);
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*mus));
-}
-
-/**
- * nvme_get_log_support_cap_config_list() - Retrieve the Supported Capacity
- * Configuration List Log Page
- * @hdl:	Transport handle for the controller.
- * @domid:	The Domain Identifier (DOMID) selection, if
- *		supported (used in LSI).
- * @cap:	Pointer to the buffer
- *		(@struct nvme_supported_cap_config_list_log) where the log
- *		page data will be stored.
- *
- * Submits the Get Log Page command specifically for the Supported Capacity
- * Configuration List Log. The DOMID is placed in the Log Specific Identifier
- * (LSI) field of the command.
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_SUPPORTED_CAP_CONFIG_LIST, and Retain Asynchronous Event (RAE)
- * to false. This command is typically issued for the controller scope, thus
- * using NVME_NSID_NONE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_support_cap_config_list(struct nvme_transport_handle *hdl,
-		__u16 domid, struct nvme_supported_cap_config_list_log *cap)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_support_cap_config_list(&cmd, domid, cap);
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*cap));
-}
-
-/**
- * nvme_get_log_reservation() - Retrieve the Reservation Notification Log Page
- * @hdl:	Transport handle for the controller.
- * @log:	Pointer to the buffer (@struct nvme_resv_notification_log)
- *		where the log page data will be stored.
- *
- * Submits the Get Log Page command specifically for the Reservation
- * Notification Log. It automatically sets the Log Identifier (LID).
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_reservation(struct nvme_transport_handle *hdl,
-		struct nvme_resv_notification_log *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_reservation(&cmd, log);
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
-}
-
-/**
- * nvme_get_log_sanitize() - Retrieve the Sanitize Status Log Page
- * @hdl:	Transport handle for the controller.
- * @rae:	Retain asynchronous events
- * @log:	Pointer to the buffer (@struct nvme_sanitize_log_page)
- *		where the log page data will be stored.
- *
- * Submits the Get Log Page command specifically for the Sanitize Status Log.
- * The log page reports sanitize operation time estimates and information about
- * the most recent sanitize operation.
- *
- * It automatically sets the Log Identifier (LID) to NVME_LOG_LID_SANITIZE.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_sanitize(struct nvme_transport_handle *hdl,
-		bool rae, struct nvme_sanitize_log_page *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_sanitize(&cmd, log);
-
-	return nvme_get_log(hdl, &cmd, rae, sizeof(*log));
-}
-
-/**
- * nvme_get_log_zns_changed_zones() - Retrieve the ZNS Changed Zones Log Page
- * @hdl:	Transport handle for the controller.
- * @nsid:	Namespace ID to request the log for.
- * @rae:	Retain asynchronous events
- * @log:	Pointer to the buffer (@struct nvme_zns_changed_zone_log)
- *		where the log page data will be stored.
- *
- * Submits the Get Log Page command specifically for the ZNS Changed Zones Log.
- * This log lists zones that have changed state due to an exceptional event.
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_ZNS_CHANGED_ZONES.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_zns_changed_zones(struct nvme_transport_handle *hdl,
-		__u32 nsid, bool rae, struct nvme_zns_changed_zone_log *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_zns_changed_zones(&cmd, nsid, log);
-
-	return nvme_get_log(hdl, &cmd, rae, sizeof(*log));
-}
-
-/**
- * nvme_get_log_persistent_event() - Retrieve the Persistent Event Log Page
- * @hdl:	Transport handle for the controller.
- * @action:	Action the controller should take during processing this
- *		command, see &enum nvme_pevent_log_action (used in LSP).
- * @pevent_log:	Pointer to the buffer where the log page data will be stored.
- * @len:	Length of the buffer provided in @pevent_log.
- *
- * Submits the Get Log Page command specifically for the Persistent Event Log.
- * The @action parameter is placed in the Log Specific Parameter (LSP) field.
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_PERSISTENT_EVENT and Retain Asynchronous Event (RAE) to false.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_persistent_event(struct nvme_transport_handle *hdl,
-		enum nvme_pevent_log_action action, void *pevent_log, __u32 len)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_persistent_event(&cmd, action, pevent_log, len);
-
-	/*
-	 * Call the generic log execution function.
-	 * The data length is determined by the 'len' parameter.
-	 */
-	return nvme_get_log(hdl, &cmd, false, len);
-}
-
-/**
- * nvme_get_log_lockdown() - Retrieve the Command and Feature Lockdown Log Page
- * @hdl:	Transport handle for the controller.
- * @cnscp:	Contents and Scope (CNSCP) of Command and Feature
- *		Identifier Lists (used in LSP).
- * @log:	Pointer to the buffer (@struct nvme_lockdown_log) where the log
- *		page data will be stored.
- *
- * Submits the Get Log Page command specifically for the Command and Feature
- * Lockdown Log. The @cnscp parameter is placed in the Log Specific Parameter
- * (LSP) field.
- *
- * It automatically sets the Log Identifier (LID) to
- * NVME_LOG_LID_CMD_AND_FEAT_LOCKDOWN and Retain Asynchronous Event (RAE) to
- * false.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_lockdown(struct nvme_transport_handle *hdl,
-		__u8 cnscp, struct nvme_lockdown_log *log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_lockdown(&cmd, cnscp, log);
-
-	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
-}
-
-/**
- * nvme_get_log_smart() - Retrieve the SMART / Health Information Log Page
- * @hdl:	Transport handle for the controller.
- * @nsid:	Namespace ID to request the log for.
- * @smart_log:	Pointer to the buffer (@struct nvme_smart_log) where the log
- *		page data will be stored.
- *
- * Submits the Get Log Page command specifically for the SMART / Health
- * Information Log. It automatically sets the Log Identifier (LID) and
- * Retain Asynchronous Event (RAE) to false.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_log_smart(struct nvme_transport_handle *hdl,
-		__u32 nsid, struct nvme_smart_log *smart_log)
-{
-	struct nvme_passthru_cmd cmd;
-
-	nvme_init_get_log_smart(&cmd, nsid, smart_log);
-
-	return nvme_get_log(hdl, &cmd, false, NVME_LOG_PAGE_PDU_SIZE);
-}
-
-/**
- * nvme_set_features() - Submit a generic Set Features command
- * @hdl:	Transport handle for the controller.
- * @nsid:	Namespace ID	sto apply the feature to.
- * @fid:	Feature Identifier (FID) to be set.
- * @sv:		Save Value (SV): If true, the feature value persists
- *		across power states.
- * @cdw11:	Command Dword 11 parameter (feature-specific).
- * @cdw12:	Command Dword 12 parameter (feature-specific).
- * @cdw13:	Command Dword 13 parameter (feature-specific).
- * @uidx:	UUID Index (UIDX) for the command, encoded into cdw14
- * @cdw15:	Command Dword 15 parameter (feature-specific).
- * @data:	Pointer to the data buffer to transfer (if applicable).
- * @len:	Length of the data buffer in bytes.
- * @result:	The command completion result (CQE dword0) on success.
- *
- * Submits the Set Features command, allowing all standard command
- * fields (cdw11-cdw15) and data buffer fields to be specified directly.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_set_features(struct nvme_transport_handle *hdl, __u32 nsid, __u8 fid,
-		bool sv, __u32 cdw11, __u32 cdw12, __u32 cdw13, __u8 uidx,
-		__u32 cdw15, void *data, __u32 len, __u64 *result)
-{
-	struct nvme_passthru_cmd cmd;
-	int err;
-
-	nvme_init_set_features(&cmd, fid, sv);
-	cmd.nsid = nsid;
-	cmd.cdw11 = cdw11;
-	cmd.cdw12 = cdw12;
-	cmd.cdw13 = cdw13;
-	cmd.cdw14 = NVME_FIELD_ENCODE(uidx,
-				      NVME_SET_FEATURES_CDW14_UUID_SHIFT,
-				      NVME_SET_FEATURES_CDW14_UUID_MASK);
-	cmd.cdw15 = cdw15;
-	cmd.data_len = len;
-	cmd.addr = (__u64)(uintptr_t)data;
-
-	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (result)
-		*result = cmd.result;
-	return err;
-}
-
-/**
- * nvme_set_features_simple() - Submit a Set Features command using only cdw11
- * @hdl:	Transport handle for the controller.
- * @nsid:	Namespace ID to apply the feature to.
- * @fid:	Feature Identifier (FID) to be set.
- * @sv:		Save Value (SV): If true, the feature value persists across
- *		power states.
- * @cdw11:	Command Dword 11 parameter (feature-specific value).
- * @result:	The command completion result (CQE dword0) on success.
- *
- * Submits the Set Features command for features that only require
- * parameters in cdw11.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_set_features_simple(struct nvme_transport_handle *hdl,
-		__u32 nsid, __u8 fid, bool sv, __u32 cdw11, __u64 *result)
-{
-	struct nvme_passthru_cmd cmd;
-	int err;
-
-	nvme_init_set_features(&cmd, fid, sv);
-	cmd.nsid = nsid;
-	cmd.cdw11 = cdw11;
-
-	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (result)
-		*result = cmd.result;
-	return err;
-}
-
-/**
- * nvme_get_features() - Submit a Get Features command
- * @hdl:	Transport handle for the controller.
- * @nsid:	Namespace ID, if applicable
- * @fid:	Feature identifier, see &enum nvme_features_id
- * @sel:	Select which type of attribute to return,
- *		see &enum nvme_get_features_sel
- * @cdw11:	Feature specific command dword11 field
- * @uidx:	UUID Index for differentiating vendor specific encoding
- * @data:	User address of feature data, if applicable
- * @len:	Length of feature data, if applicable, in bytes
- * @result:	The command completion result (CQE dword0) on success.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_features(struct nvme_transport_handle *hdl, __u32 nsid,
-		__u8 fid, enum nvme_get_features_sel sel,
-		__u32 cdw11, __u8 uidx, void *data,
-		__u32 len, __u64 *result)
-{
-	struct nvme_passthru_cmd cmd;
-	int err;
-
-	nvme_init_get_features(&cmd, fid, sel);
-
-	cmd.nsid = nsid;
-	cmd.cdw11 = cdw11;
-	cmd.cdw14 = NVME_FIELD_ENCODE(uidx,
-			NVME_GET_FEATURES_CDW14_UUID_SHIFT,
-			NVME_GET_FEATURES_CDW14_UUID_MASK);
-	cmd.data_len = len;
-	cmd.addr = (__u64)(uintptr_t)data;
-
-	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (result)
-		*result = cmd.result;
-	return err;
-}
-
-/**
- * nvme_get_features_simple() - Submit a simple Get Features command
- * @hdl:	Transport handle for the controller.
- * @fid:	Feature Identifier (FID) to be retrieved.
- * @sel:	Select (SEL), specifying which feature value
- *		to return (&struct nvme_get_features_sel).
- * @result:	The command completion result (CQE dword0) on success.
- *
- * Submits the Get Features command for features that only require parameters in
- * the CQE dword0 and do not need any parameters in cdw11 through cdw15.
- *
- * Return: 0 on success, the NVMe command status on error, or a negative
- * errno otherwise.
- */
-static inline int
-nvme_get_features_simple(struct nvme_transport_handle *hdl, __u8 fid,
-		enum nvme_get_features_sel sel, __u64 *result)
-{
-	struct nvme_passthru_cmd cmd;
-	int err;
-
-	nvme_init_get_features(&cmd, fid, sel);
-
-	err = nvme_submit_admin_passthru(hdl, &cmd);
-	if (result)
-		*result = cmd.result;
-	return err;
-}
-
-/**
- * nvme_init_mi_cmd_flags() - Initialize command flags for NVMe-MI
- * @cmd:	Passthru command to use
- * @ish:	Ignore Shutdown (for NVMe-MI command)
- *
- * Initializes the passthru command flags
- */
-static inline void
-nvme_init_mi_cmd_flags(struct nvme_passthru_cmd *cmd, bool ish)
-{
-	cmd->flags = NVME_FIELD_ENCODE(ish,
-			NVME_MI_ADMIN_CFLAGS_ISH_SHIFT,
-			NVME_MI_ADMIN_CFLAGS_ISH_MASK);
-}
-
-/**
- * nvme_fw_download_seq() - Firmware download sequence
- * @hdl:	Transport handle
- * @ish:	Ignore Shutdown (for NVMe-MI command)
- * @size:	Total size of the firmware image to transfer
- * @xfer:	Maximum size to send with each partial transfer
- * @offset:	Starting offset to send with this firmware download
- * @buf:	Address of buffer containing all or part of the firmware image.
- *
- * Return: 0 on success, the nvme command status if a response was
- * received (see &enum nvme_status_field) or a negative error otherwise.
- */
-int nvme_fw_download_seq(struct nvme_transport_handle *hdl, bool ish,
-			__u32 size, __u32 xfer, __u32 offset, void *buf);
-
-/**
- * nvme_set_etdas() - Set the Extended Telemetry Data Area 4 Supported bit
- * @hdl:	Transport handle
- * @changed:	boolean to indicate whether or not the host
- *		behavior support feature had been changed
- *
- * Return: The nvme command status if a response was received (see
- * &enum nvme_status_field) or -1 with errno set otherwise.
- */
-int nvme_set_etdas(struct nvme_transport_handle *hdl, bool *changed);
-
-/**
- * nvme_clear_etdas() - Clear the Extended Telemetry Data Area 4 Supported bit
- * @hdl:	Transport handle
- * @changed:	boolean to indicate whether or not the host
- *		behavior support feature had been changed
- *
- * Return: The nvme command status if a response was received (see
- * &enum nvme_status_field) or -1 with errno set otherwise.
- */
-int nvme_clear_etdas(struct nvme_transport_handle *hdl, bool *changed);
-
-/**
- * nvme_get_uuid_list - Returns the uuid list (if supported)
- * @hdl:	Transport handle
- * @uuid_list:	UUID list returned by identify UUID
- *
- * Return: The nvme command status if a response was received (see
- * &enum nvme_status_field) or -1 with errno set otherwise.
- */
-int nvme_get_uuid_list(struct nvme_transport_handle *hdl,
-		struct nvme_id_uuid_list *uuid_list);
-
-/**
- * nvme_get_telemetry_max() - Get telemetry limits
- * @hdl:	Transport handle
- * @da:		On success return max supported data area
- * @max_data_tx: On success set to max transfer chunk supported by
- *		the controller
- *
- * Return: 0 on success, the nvme command status if a response was
- * received (see &enum nvme_status_field) or a negative error otherwise.
- */
-int nvme_get_telemetry_max(struct nvme_transport_handle *hdl,
-		enum nvme_telemetry_da *da, size_t *max_data_tx);
-
-/**
- * nvme_get_telemetry_log() - Get specified telemetry log
- * @hdl:	Transport handle
- * @create:	Generate new host initated telemetry capture
- * @ctrl:	Get controller Initiated log
- * @rae:	Retain asynchronous events
- * @max_data_tx: Set the max data transfer size to be used retrieving telemetry.
- * @da:		Log page data area, valid values: &enum nvme_telemetry_da.
- * @log:	On success, set to the value of the allocated and retrieved log.
- * @size:	Ptr to the telemetry log size, so it can be returned
- *
- * The total size allocated can be calculated as:
- *   (nvme_telemetry_log da size  + 1) * NVME_LOG_TELEM_BLOCK_SIZE.
- *
- * Return: 0 on success, the nvme command status if a response was
- * received (see &enum nvme_status_field) or a negative error otherwise.
+ * Return: 0 on success, the nvme command status if a response was
+ * received (see &enum nvme_status_field) or a negative error otherwise.
  */
 int nvme_get_telemetry_log(struct nvme_transport_handle *hdl, bool create,
 		bool ctrl, bool rae, size_t max_data_tx,
@@ -7053,6 +5508,31 @@ int nvme_get_new_host_telemetry(struct nvme_transport_handle *hdl,
 size_t nvme_get_ana_log_len_from_id_ctrl(const struct nvme_id_ctrl *id_ctrl,
 		bool rgo);
 
+/**
+ * nvme_get_ana_log_atomic() - Retrieve Asymmetric Namespace Access
+ * log page atomically
+ * @hdl:	Transport handle
+ * @rae:	Whether to retain asynchronous events
+ * @rgo:	Whether to retrieve ANA groups only (no NSIDs)
+ * @log:	Pointer to a buffer to receive the ANA log page
+ * @len:	Input: the length of the log page buffer.
+ *		Output: the actual length of the ANA log page.
+ * @retries:	The maximum number of times to retry on log page changes
+ *
+ * See &struct nvme_ana_log for the definition of the returned structure.
+ *
+ * Return: If successful, returns 0 and sets *len to the actual log page length.
+ * If unsuccessful, returns the nvme command status if a response was received
+ * (see &enum nvme_status_field) or -1 with errno set otherwise.
+ * Sets errno = EINVAL if retries == 0.
+ * Sets errno = EAGAIN if unable to read the log page atomically
+ * because chgcnt changed during each of the retries attempts.
+ * Sets errno = ENOSPC if the full log page does not fit in the provided buffer.
+ */
+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);
+
 /**
  * nvme_get_ana_log_len() - Retrieve size of the current ANA log
  * @hdl:	Transport handle
@@ -7087,125 +5567,6 @@ int nvme_get_logical_block_size(struct nvme_transport_handle *hdl, __u32 nsid,
 int nvme_get_lba_status_log(struct nvme_transport_handle *hdl, bool rae,
 		struct nvme_lba_status_log **log);
 
-/**
- * nvme_namespace_attach_ctrls() - Attach namespace to controller(s)
- * @hdl:	Transport handle
- * @ish:	Ignore Shutdown (for NVMe-MI command)
- * @nsid:	Namespace ID to attach
- * @num_ctrls:	Number of controllers in ctrlist
- * @ctrlist:	List of controller IDs to perform the attach action
- *
- * Return: 0 on success, the nvme command status if a response was
- * received (see &enum nvme_status_field) or a negative error otherwise.
- */
-int nvme_namespace_attach_ctrls(struct nvme_transport_handle *hdl, bool ish,
-				__u32 nsid, __u16 num_ctrls, __u16 *ctrlist);
-
-/**
- * nvme_namespace_detach_ctrls() - Detach namespace from controller(s)
- * @hdl:	Transport handle
- * @ish:	Ignore Shutdown (for NVMe-MI command)
- * @nsid:	Namespace ID to detach
- * @num_ctrls:	Number of controllers in ctrlist
- * @ctrlist:	List of controller IDs to perform the detach action
- *
- * Return: 0 on success, the nvme command status if a response was
- * received (see &enum nvme_status_field) or a negative error otherwise.
- */
-int nvme_namespace_detach_ctrls(struct nvme_transport_handle *hdl, bool ish,
-			__u32 nsid, __u16 num_ctrls, __u16 *ctrlist);
-
-/**
- * nvme_init_ctrl_list() - Initialize an nvme_ctrl_list structure from an array.
- * @cntlist:   The controller list structure to initialize
- * @num_ctrls: The number of controllers in the array, &ctrlist.
- * @ctrlist:   An array of controller identifiers in CPU native endian.
- *
- * This is intended to be used with any command that takes a controller list
- * argument. See nvme_ns_attach_ctrls() and nvme_ns_detach().
- */
-void nvme_init_ctrl_list(struct nvme_ctrl_list *cntlist, __u16 num_ctrls,
-			 __u16 *ctrlist);
-
-/**
- * nvme_init_dsm_range() - Constructs a data set range structure
- * @dsm:	DSM range array
- * @ctx_attrs:	Array of context attributes
- * @llbas:	Array of length in logical blocks
- * @slbas:	Array of starting logical blocks
- * @nr_ranges:	The size of the dsm arrays
- *
- * Each array must be the same size of size 'nr_ranges'. This is intended to be
- * used with constructing a payload for nvme_dsm().
- *
- * Return: The nvme command status if a response was received or -errno
- * otherwise.
- */
-void nvme_init_dsm_range(struct nvme_dsm_range *dsm, __u32 *ctx_attrs,
-			  __u32 *llbas, __u64 *slbas, __u16 nr_ranges);
-
-/**
- * nvme_init_copy_range() - Constructs a copy range structure
- * @copy:	Copy range array
- * @nlbs:	Number of logical blocks
- * @slbas:	Starting LBA
- * @eilbrts:	Expected initial logical block reference tag
- * @elbatms:	Expected logical block application tag mask
- * @elbats:	Expected logical block application tag
- * @nr:		Number of descriptors to construct
- */
-void nvme_init_copy_range(struct nvme_copy_range *copy, __u16 *nlbs,
-			  __u64 *slbas, __u32 *eilbrts, __u32 *elbatms,
-			  __u32 *elbats, __u16 nr);
-
-/**
- * nvme_init_copy_range_f1() - Constructs a copy range f1 structure
- * @copy:	Copy range array
- * @nlbs:	Number of logical blocks
- * @slbas:	Starting LBA
- * @eilbrts:	Expected initial logical block reference tag
- * @elbatms:	Expected logical block application tag mask
- * @elbats:	Expected logical block application tag
- * @nr:		Number of descriptors to construct
- */
-void nvme_init_copy_range_f1(struct nvme_copy_range_f1 *copy, __u16 *nlbs,
-			     __u64 *slbas, __u64 *eilbrts, __u32 *elbatms,
-			     __u32 *elbats, __u16 nr);
-
-/**
- * nvme_init_copy_range_f2() - Constructs a copy range f2 structure
- * @copy:	Copy range array
- * @snsids:	Source namespace identifier
- * @nlbs:	Number of logical blocks
- * @slbas:	Starting LBA
- * @sopts:	Source options
- * @eilbrts:	Expected initial logical block reference tag
- * @elbatms:	Expected logical block application tag mask
- * @elbats:	Expected logical block application tag
- * @nr:		Number of descriptors to construct
- */
-void nvme_init_copy_range_f2(struct nvme_copy_range_f2 *copy, __u32 *snsids,
-			     __u16 *nlbs, __u64 *slbas, __u16 *sopts,
-			     __u32 *eilbrts, __u32 *elbatms, __u32 *elbats,
-			     __u16 nr);
-
-/**
- * nvme_init_copy_range_f3() - Constructs a copy range f3 structure
- * @copy:	Copy range array
- * @snsids:	Source namespace identifier
- * @nlbs:	Number of logical blocks
- * @slbas:	Starting LBA
- * @sopts:	Source options
- * @eilbrts:	Expected initial logical block reference tag
- * @elbatms:	Expected logical block application tag mask
- * @elbats:	Expected logical block application tag
- * @nr:		Number of descriptors to construct
- */
-void nvme_init_copy_range_f3(struct nvme_copy_range_f3 *copy, __u32 *snsids,
-			     __u16 *nlbs, __u64 *slbas, __u16 *sopts,
-			     __u64 *eilbrts, __u32 *elbatms, __u32 *elbats,
-			     __u16 nr);
-
 /**
  * nvme_get_feature_length() - Retrieve the command payload length for a
  *			       specific feature identifier
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/crc32.h b/libnvme/src/nvme/crc32.h
index c53eff181f..e811421c71 100644
--- a/libnvme/src/nvme/crc32.h
+++ b/libnvme/src/nvme/crc32.h
@@ -4,7 +4,7 @@
  */
 #pragma once
 
-#include <stdint.h>
 #include <stddef.h>
+#include <stdint.h>
 
 uint32_t crc32(uint32_t crc, const void *buf, size_t len);
diff --git a/libnvme/src/nvme/fabrics.c b/libnvme/src/nvme/fabrics.c
index fb6cfa5c19..62d76c5d28 100644
--- a/libnvme/src/nvme/fabrics.c
+++ b/libnvme/src/nvme/fabrics.c
@@ -7,35 +7,36 @@
  * 	    Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
  */
 
+#include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <fnmatch.h>
+#include <inttypes.h>
 #include <limits.h>
 #include <stdbool.h>
 #include <stddef.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include <fnmatch.h>
-#include <dirent.h>
-#include <inttypes.h>
 
-#include "platform/includes.h"
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <netdb.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 
+#include <ccan/array_size/array_size.h>
 #include <ccan/endian/endian.h>
 #include <ccan/list/list.h>
-#include <ccan/array_size/array_size.h>
 #include <ccan/str/str.h>
 
 #include <libnvme.h>
 
 #include "cleanup.h"
 #include "private.h"
-
-#define NVMF_HOSTID_SIZE	37
-
-#define NVMF_HOSTNQN_FILE	SYSCONFDIR "/nvme/hostnqn"
-#define NVMF_HOSTID_FILE	SYSCONFDIR "/nvme/hostid"
+#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;
 
@@ -333,13 +334,6 @@ static const struct nvme_fabric_options default_supported_options = {
 	.trsvcid = true,
 };
 
-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;
-}
-
 #define MERGE_CFG_OPTION(c, n, o, d)			\
 	if ((c)->o == d) (c)->o = (n)->o
 static struct nvme_fabrics_config *merge_config(nvme_ctrl_t c,
@@ -371,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);
 
@@ -679,7 +673,7 @@ static int build_options(nvme_host_t h, nvme_ctrl_t c, char **argstr)
 {
 	struct nvme_fabrics_config *cfg = nvme_ctrl_get_config(c);
 	const char *transport = nvme_ctrl_get_transport(c);
-	const char *hostnqn, *hostid, *hostkey, *ctrlkey;
+	const char *hostnqn, *hostid, *hostkey, *ctrlkey = NULL;
 	bool discover = false, discovery_nqn = false;
 	struct nvme_global_ctx *ctx = h->ctx;
 	long keyring_id = 0;
@@ -710,16 +704,17 @@ static int build_options(nvme_host_t h, nvme_ctrl_t c, char **argstr)
 		discovery_nqn = true;
 	}
 
-	if (nvme_ctrl_is_discovery_ctrl(c))
+	if (nvme_ctrl_get_discovery_ctrl(c))
 		discover = true;
 
 	hostnqn = nvme_host_get_hostnqn(h);
 	hostid = nvme_host_get_hostid(h);
-	hostkey = nvme_host_get_dhchap_key(h);
+	hostkey = nvme_host_get_dhchap_host_key(h);
 	if (!hostkey)
 		hostkey = nvme_ctrl_get_dhchap_host_key(c);
 
-	ctrlkey = nvme_ctrl_get_dhchap_key(c);
+	if (hostkey)
+		ctrlkey = nvme_ctrl_get_dhchap_ctrl_key(c);
 
 	if (cfg->tls && cfg->concat) {
 		nvme_msg(h->ctx, LOG_ERR, "cannot specify --tls and --concat together\n");
@@ -731,11 +726,6 @@ static int build_options(nvme_host_t h, nvme_ctrl_t c, char **argstr)
 		return -ENVME_CONNECT_INVAL;
 	}
 
-	if (cfg->concat && ctrlkey) {
-		nvme_msg(h->ctx, LOG_ERR, "cannot specify [--dhchap-ctrl-secret | -C] with --concat\n");
-		return -ENVME_CONNECT_INVAL;
-	}
-
 	if (cfg->tls) {
 		ret = __nvme_import_keys_from_config(h, c,
 			&keyring_id, &key_id);
@@ -763,9 +753,9 @@ static int build_options(nvme_host_t h, nvme_ctrl_t c, char **argstr)
 	    (hostid && add_argument(ctx, argstr, hostid, hostid)) ||
 	    (discover && !discovery_nqn &&
 	     add_bool_argument(ctx, argstr, discovery, true)) ||
-	    (!discover && hostkey &&
+	    (hostkey &&
 	     add_argument(ctx, argstr, dhchap_secret, hostkey)) ||
-	    (!discover && ctrlkey &&
+	    (ctrlkey &&
 	     add_argument(ctx, argstr, dhchap_ctrl_secret, ctrlkey)) ||
 	    (!discover &&
 	     add_int_argument(ctx, argstr, nr_io_queues,
@@ -992,7 +982,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;
@@ -1027,9 +1017,9 @@ int nvmf_add_ctrl(nvme_host_t h, nvme_ctrl_t c,
 			key = nvme_ctrl_get_dhchap_host_key(fc);
 			if (key)
 				nvme_ctrl_set_dhchap_host_key(c, key);
-			key = nvme_ctrl_get_dhchap_key(fc);
+			key = nvme_ctrl_get_dhchap_ctrl_key(fc);
 			if (key)
-				nvme_ctrl_set_dhchap_key(c, key);
+				nvme_ctrl_set_dhchap_ctrl_key(c, key);
 			key = nvme_ctrl_get_keyring(fc);
 			if (key)
 				nvme_ctrl_set_keyring(c, key);
@@ -1046,7 +1036,7 @@ int nvmf_add_ctrl(nvme_host_t h, nvme_ctrl_t c,
 	root_app = nvme_get_application(h->ctx);
 	if (root_app) {
 		app = nvme_subsystem_get_application(s);
-		if (!app && nvme_ctrl_is_discovery_ctrl(c))
+		if (!app && nvme_ctrl_get_discovery_ctrl(c))
 			app = lookup_context(h->ctx, c);
 
 		/*
@@ -1057,7 +1047,7 @@ int nvmf_add_ctrl(nvme_host_t h, nvme_ctrl_t c,
 		 */
 		if (app && strcmp(app, root_app)) {
 			nvme_msg(h->ctx, LOG_INFO, "skip %s, not managed by %s\n",
-				 nvme_subsystem_get_nqn(s), root_app);
+				 nvme_subsystem_get_subsysnqn(s), root_app);
 			return -ENVME_CONNECT_IGNORED;
 		}
 	}
@@ -1086,7 +1076,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;
@@ -1188,7 +1178,7 @@ static int nvmf_connect_disc_entry(nvme_host_t h,
 		break;
 	}
 
-	if (nvme_ctrl_is_discovered(c)) {
+	if (nvme_ctrl_get_discovered(c)) {
 		nvme_free_ctrl(c);
 		return -EAGAIN;
 	}
@@ -1355,7 +1345,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 = {
@@ -1369,7 +1359,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;
@@ -1386,244 +1376,6 @@ int nvmf_get_discovery_wargs(struct nvme_get_discovery_args *args,
 	return 0;
 }
 
-static int uuid_from_device_tree(char *system_uuid)
-{
-	_cleanup_fd_ int f = -1;
-	ssize_t len;
-
-	f = open(nvme_uuid_ibm_filename(), O_RDONLY);
-	if (f < 0)
-		return -ENXIO;
-
-	memset(system_uuid, 0, NVME_UUID_LEN_STRING);
-	len = read(f, system_uuid, NVME_UUID_LEN_STRING - 1);
-	if (len < 0)
-		return -ENXIO;
-
-	return strlen(system_uuid) ? 0 : -ENXIO;
-}
-
-/*
- * See System Management BIOS (SMBIOS) Reference Specification
- * https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.2.0.pdf
- */
-#define DMI_SYSTEM_INFORMATION	1
-
-static bool is_dmi_uuid_valid(const char *buf, size_t len)
-{
-	int i;
-
-	/* UUID bytes are from byte 8 to 23 */
-	if (len < 24)
-		return false;
-
-	/* Test it's a invalid UUID with all zeros */
-	for (i = 8; i < 24; i++) {
-		if (buf[i])
-			break;
-	}
-	if (i == 24)
-		return false;
-
-	return true;
-}
-
-static int uuid_from_dmi_entries(char *system_uuid)
-{
-	_cleanup_dir_ DIR *d = NULL;
-	const char *entries_dir = nvme_dmi_entries_dir();
-	int f;
-	struct dirent *de;
-	char buf[512] = {0};
-
-	system_uuid[0] = '\0';
-	d = opendir(entries_dir);
-	if (!d)
-		return -ENXIO;
-	while ((de = readdir(d))) {
-		char filename[PATH_MAX];
-		int len, type;
-
-		if (de->d_name[0] == '.')
-			continue;
-		sprintf(filename, "%s/%s/type", entries_dir, de->d_name);
-		f = open(filename, O_RDONLY);
-		if (f < 0)
-			continue;
-		len = read(f, buf, 512);
-		close(f);
-		if (len <= 0)
-			continue;
-		if (sscanf(buf, "%d", &type) != 1)
-			continue;
-		if (type != DMI_SYSTEM_INFORMATION)
-			continue;
-		sprintf(filename, "%s/%s/raw", entries_dir, de->d_name);
-		f = open(filename, O_RDONLY);
-		if (f < 0)
-			continue;
-		len = read(f, buf, 512);
-		close(f);
-		if (len <= 0)
-			continue;
-
-		if (!is_dmi_uuid_valid(buf, len))
-			continue;
-
-		/* Sigh. https://en.wikipedia.org/wiki/Overengineering */
-		/* DMTF SMBIOS 3.0 Section 7.2.1 System UUID */
-		sprintf(system_uuid,
-			"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-"
-			"%02x%02x%02x%02x%02x%02x",
-			(uint8_t)buf[8 + 3], (uint8_t)buf[8 + 2],
-			(uint8_t)buf[8 + 1], (uint8_t)buf[8 + 0],
-			(uint8_t)buf[8 + 5], (uint8_t)buf[8 + 4],
-			(uint8_t)buf[8 + 7], (uint8_t)buf[8 + 6],
-			(uint8_t)buf[8 + 8], (uint8_t)buf[8 + 9],
-			(uint8_t)buf[8 + 10], (uint8_t)buf[8 + 11],
-			(uint8_t)buf[8 + 12], (uint8_t)buf[8 + 13],
-			(uint8_t)buf[8 + 14], (uint8_t)buf[8 + 15]);
-		break;
-	}
-	return strlen(system_uuid) ? 0 : -ENXIO;
-}
-
-#define PATH_DMI_PROD_UUID  "/sys/class/dmi/id/product_uuid"
-
-/**
- * uuid_from_product_uuid() - Get system UUID from product_uuid
- * @system_uuid: Where to save the system UUID.
- *
- * Return: 0 on success, -ENXIO otherwise.
- */
-static int uuid_from_product_uuid(char *system_uuid)
-{
-	_cleanup_file_ FILE *stream = NULL;
-	ssize_t nread;
-	_cleanup_free_ char *line = NULL;
-	size_t len = 0;
-
-	stream = fopen(PATH_DMI_PROD_UUID, "re");
-	if (!stream)
-		return -ENXIO;
-	system_uuid[0] = '\0';
-
-	nread = getline(&line, &len, stream);
-	if (nread != NVME_UUID_LEN_STRING)
-		return -ENXIO;
-
-	/* The kernel is handling the byte swapping according DMTF
-	 * SMBIOS 3.0 Section 7.2.1 System UUID */
-
-	memcpy(system_uuid, line, NVME_UUID_LEN_STRING - 1);
-	system_uuid[NVME_UUID_LEN_STRING - 1] = '\0';
-
-	return 0;
-}
-
-/**
- * uuid_from_dmi() - read system UUID
- * @system_uuid: buffer for the UUID
- *
- * The system UUID can be read from two different locations:
- *
- *     1) /sys/class/dmi/id/product_uuid
- *     2) /sys/firmware/dmi/entries
- *
- * Note that the second location is not present on Debian-based systems.
- *
- * Return: 0 on success, negative errno otherwise.
- */
-static int uuid_from_dmi(char *system_uuid)
-{
-	int ret = uuid_from_product_uuid(system_uuid);
-	if (ret != 0)
-		ret = uuid_from_dmi_entries(system_uuid);
-	return ret;
-}
-
-char *nvmf_hostid_generate()
-{
-	int ret;
-	char uuid_str[NVME_UUID_LEN_STRING];
-	unsigned char uuid[NVME_UUID_LEN];
-
-	ret = uuid_from_dmi(uuid_str);
-	if (ret < 0)
-		ret = uuid_from_device_tree(uuid_str);
-	if (ret < 0) {
-		if (nvme_uuid_random(uuid) < 0)
-			memset(uuid, 0, NVME_UUID_LEN);
-		nvme_uuid_to_string(uuid, uuid_str);
-	}
-
-	return strdup(uuid_str);
-}
-
-char *nvmf_hostnqn_generate_from_hostid(char *hostid)
-{
-	char *hid = NULL;
-	char *hostnqn;
-	int ret;
-
-	if (!hostid)
-		hostid = hid = nvmf_hostid_generate();
-
-	ret = asprintf(&hostnqn, "nqn.2014-08.org.nvmexpress:uuid:%s", hostid);
-	free(hid);
-
-	return (ret < 0) ? NULL : hostnqn;
-}
-
-char *nvmf_hostnqn_generate()
-{
-	return nvmf_hostnqn_generate_from_hostid(NULL);
-}
-
-static char *nvmf_read_file(const char *f, int len)
-{
-	char buf[len];
-	_cleanup_fd_ int fd = -1;
-	int ret;
-
-	fd = open(f, O_RDONLY);
-	if (fd < 0)
-		return NULL;
-
-	memset(buf, 0, len);
-	ret = read(fd, buf, len - 1);
-
-	if (ret < 0 || !strlen(buf))
-		return NULL;
-	return strndup(buf, strcspn(buf, "\n"));
-}
-
-char *nvmf_hostnqn_from_file()
-{
-	char *hostnqn = getenv("LIBNVME_HOSTNQN");
-
-	if (hostnqn) {
-		if (!strcmp(hostnqn, ""))
-			return NULL;
-		return strdup(hostnqn);
-	}
-
-	return nvmf_read_file(NVMF_HOSTNQN_FILE, NVMF_NQN_SIZE);
-}
-
-char *nvmf_hostid_from_file()
-{
-	char *hostid = getenv("LIBNVME_HOSTID");
-
-	if (hostid) {
-		if (!strcmp(hostid, ""))
-			return NULL;
-		return strdup(hostid);
-	}
-
-	return nvmf_read_file(NVMF_HOSTID_FILE, NVMF_HOSTID_SIZE);
-}
-
 /**
  * nvmf_get_tel() - Calculate the amount of memory needed for a DIE.
  * @hostsymname:	Symbolic name (may be NULL)
@@ -1889,7 +1641,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))
@@ -1898,7 +1650,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;
@@ -1939,7 +1691,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;
@@ -2036,7 +1788,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;
 
@@ -2054,19 +1806,19 @@ void nvmf_free_uri(struct nvme_fabrics_uri *uri)
 	free(uri);
 }
 
-static nvme_ctrl_t lookup_ctrl(nvme_host_t h, struct fabric_args *trcfg)
+static nvme_ctrl_t lookup_ctrl(nvme_host_t h, struct nvmf_context *fctx)
 {
 	nvme_subsystem_t s;
 	nvme_ctrl_t c;
 
 	nvme_for_each_subsystem(h, s) {
 		c = nvme_ctrl_find(s,
-				   trcfg->transport,
-				   trcfg->traddr,
-				   trcfg->trsvcid,
-				   trcfg->subsysnqn,
-				   trcfg->host_traddr,
-				   trcfg->host_iface);
+				   fctx->transport,
+				   fctx->traddr,
+				   fctx->trsvcid,
+				   fctx->subsysnqn,
+				   fctx->host_traddr,
+				   fctx->host_iface);
 		if (c)
 			return c;
 	}
@@ -2099,7 +1851,7 @@ static int setup_connection(struct nvmf_context *fctx, struct nvme_host *h,
 		bool discovery)
 {
 	if (fctx->hostkey)
-		nvme_host_set_dhchap_key(h, fctx->hostkey);
+		nvme_host_set_dhchap_host_key(h, fctx->hostkey);
 
 	if (!fctx->trsvcid)
 		fctx->trsvcid = nvmf_get_default_trsvcid(fctx->transport,
@@ -2193,24 +1945,22 @@ static int _nvmf_discovery(struct nvme_global_ctx *ctx,
 		bool disconnect;
 		nvme_ctrl_t child = { 0 };
 		int tmo = fctx->cfg->keep_alive_tmo;
+		struct nvmf_context nfctx = *fctx;
 
-		struct fabric_args trcfg = {
-			.subsysnqn	= e->subnqn,
-			.transport	= nvmf_trtype_str(e->trtype),
-			.traddr		= e->traddr,
-			.trsvcid	= e->trsvcid,
-			.host_traddr	= fctx->host_traddr,
-			.host_iface	= fctx->host_iface,
-		};
+		nfctx.subsysnqn = e->subnqn;
+		nfctx.transport = nvmf_trtype_str(e->trtype);
+		nfctx.traddr = e->traddr;
+		nfctx.trsvcid = e->trsvcid;
+		nfctx.cfg = fctx->cfg;
 
 		/* Already connected ? */
-		cl = lookup_ctrl(h, &trcfg);
+		cl = lookup_ctrl(h, &nfctx);
 		if (cl && nvme_ctrl_get_name(cl))
 			continue;
 
 		/* Skip connect if the transport types don't match */
 		if (strcmp(nvme_ctrl_get_transport(c),
-			   nvmf_trtype_str(e->trtype)))
+			   nfctx.transport))
 			continue;
 
 		if (e->subtype == NVME_NQN_DISC ||
@@ -2227,7 +1977,7 @@ static int _nvmf_discovery(struct nvme_global_ctx *ctx,
 			 * Are we supposed to keep the discovery
 			 * controller around?
 			 */
-			disconnect = !fctx->persistent;
+			disconnect = !nfctx.persistent;
 
 			if (strcmp(e->subnqn, NVME_DISC_SUBSYS_NAME)) {
 				/*
@@ -2240,21 +1990,21 @@ static int _nvmf_discovery(struct nvme_global_ctx *ctx,
 					disconnect = false;
 			}
 
-			set_discovery_kato(fctx, fctx->cfg);
+			set_discovery_kato(&nfctx, fctx->cfg);
 		} else {
 			/* NVME_NQN_NVME */
 			disconnect = false;
 		}
 
-		err = nvmf_connect_disc_entry(h, e, fctx->host_traddr,
-			fctx->host_iface, fctx->cfg,
+		err = nvmf_connect_disc_entry(h, e, nfctx.host_traddr,
+			nfctx.host_iface, nfctx.cfg,
 			&discover, &child);
 
-		fctx->cfg->keep_alive_tmo = tmo;
+		nfctx.cfg->keep_alive_tmo = tmo;
 
 		if (!child) {
 			if (discover)
-				_nvmf_discovery(ctx, fctx, true, child);
+				_nvmf_discovery(ctx, &nfctx, true, child);
 
 			if (child && disconnect) {
 				nvme_disconnect_ctrl(child);
@@ -2263,16 +2013,16 @@ static int _nvmf_discovery(struct nvme_global_ctx *ctx,
 		} else if (err == -ENVME_CONNECT_ALREADY) {
 			struct nvmf_disc_log_entry *e = &log->entries[i];
 
-			fctx->already_connected(fctx, h, e->subnqn,
+			nfctx.already_connected(&nfctx, h, e->subnqn,
 				nvmf_trtype_str(e->trtype), e->traddr,
-				e->trsvcid, fctx->user_data);
+				e->trsvcid, nfctx.user_data);
 		}
 	}
 
 	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)
@@ -2294,7 +2044,7 @@ const char *nvmf_get_default_trsvcid(const char *transport,
 static bool is_persistent_discovery_ctrl(nvme_host_t h, nvme_ctrl_t c)
 {
 	if (nvme_host_is_pdc_enabled(h, DEFAULT_PDC_ENABLED))
-		return nvme_ctrl_is_unique_discovery_ctrl(c);
+		return nvme_ctrl_get_unique_discovery_ctrl(c);
 
 	return false;
 }
@@ -2317,23 +2067,28 @@ static int nvme_add_ctrl(struct nvmf_context *fctx,
 
 static int __create_discovery_ctrl(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx, nvme_host_t h,
-		struct nvme_fabrics_config *cfg, struct fabric_args *trcfg,
-		struct nvme_ctrl **ctrl)
+		struct nvme_fabrics_config *cfg, struct nvme_ctrl **ctrl)
 {
 	nvme_ctrl_t c;
 	int tmo, ret;
 
-	ret = nvme_create_ctrl(ctx, trcfg->subsysnqn, trcfg->transport,
-			     trcfg->traddr, trcfg->host_traddr,
-			     trcfg->host_iface, trcfg->trsvcid, &c);
+	ret = nvme_create_ctrl(ctx, fctx->subsysnqn, fctx->transport,
+			     fctx->traddr, fctx->host_traddr,
+			     fctx->host_iface, fctx->trsvcid, &c);
 	if (ret)
 		return ret;
 
 	nvme_ctrl_set_discovery_ctrl(c, true);
 	nvme_ctrl_set_unique_discovery_ctrl(c,
-		     strcmp(trcfg->subsysnqn, NVME_DISC_SUBSYS_NAME));
+		     strcmp(fctx->subsysnqn, NVME_DISC_SUBSYS_NAME));
 	tmo = set_discovery_kato(fctx, cfg);
 
+	if (nvme_ctrl_get_unique_discovery_ctrl(c) && fctx->hostkey) {
+		nvme_ctrl_set_dhchap_host_key(c, fctx->hostkey);
+		if (fctx->ctrlkey)
+			nvme_ctrl_set_dhchap_ctrl_key(c, fctx->ctrlkey);
+	}
+
 	ret = nvme_add_ctrl(fctx, h, c, cfg);
 	cfg->keep_alive_tmo = tmo;
 	if (ret) {
@@ -2348,18 +2103,17 @@ static int __create_discovery_ctrl(struct nvme_global_ctx *ctx,
 static int nvmf_create_discovery_ctrl(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx, nvme_host_t h,
 		struct nvme_fabrics_config *cfg,
-		struct fabric_args *trcfg,
 		struct nvme_ctrl **ctrl)
 {
 	_cleanup_nvme_free_ struct nvme_id_ctrl *id = NULL;
 	struct nvme_ctrl *c;
 	int ret;
 
-	ret = __create_discovery_ctrl(ctx, fctx, h, cfg, trcfg, &c);
+	ret = __create_discovery_ctrl(ctx, fctx, h, cfg, &c);
 	if (ret)
 		return ret;
 
-	if (nvme_ctrl_is_unique_discovery_ctrl(c)) {
+	if (nvme_ctrl_get_unique_discovery_ctrl(c)) {
 		*ctrl = c;
 		return 0;
 	}
@@ -2399,8 +2153,8 @@ static int nvmf_create_discovery_ctrl(struct nvme_global_ctx *ctx,
 	nvme_disconnect_ctrl(c);
 	nvme_free_ctrl(c);
 
-	trcfg->subsysnqn = id->subnqn;
-	ret = __create_discovery_ctrl(ctx, fctx, h, cfg, trcfg, &c);
+	fctx->subsysnqn = id->subnqn;
+	ret = __create_discovery_ctrl(ctx, fctx, h, cfg, &c);
 	if (ret)
 		return ret;
 
@@ -2412,80 +2166,73 @@ int _discovery_config_json(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx, nvme_host_t h, nvme_ctrl_t c,
 		bool connect, bool force)
 {
-	const char *transport, *traddr, *host_traddr;
-	const char *host_iface, *trsvcid, *subsysnqn;
+	struct nvmf_context nfctx = *fctx;
 	struct nvme_fabrics_config cfg;
 	nvme_ctrl_t cn;
 	int ret = 0;
 
-	transport = nvme_ctrl_get_transport(c);
-	traddr = nvme_ctrl_get_traddr(c);
-	host_traddr = nvme_ctrl_get_host_traddr(c);
-	host_iface = nvme_ctrl_get_host_iface(c);
+	nfctx.transport = nvme_ctrl_get_transport(c);
+	nfctx.traddr = nvme_ctrl_get_traddr(c);
+	nfctx.host_traddr = nvme_ctrl_get_host_traddr(c);
+	nfctx.host_iface = nvme_ctrl_get_host_iface(c);
 
-	if (!transport && !traddr)
+	if (!nfctx.transport && !nfctx.traddr)
 		return 0;
 
 	/* ignore none fabric transports */
-	if (strcmp(transport, "tcp") &&
-	    strcmp(transport, "rdma") &&
-	    strcmp(transport, "fc"))
+	if (strcmp(nfctx.transport, "tcp") &&
+	    strcmp(nfctx.transport, "rdma") &&
+	    strcmp(nfctx.transport, "fc"))
 		return 0;
 
 	/* ignore if no host_traddr for fc */
-	if (!strcmp(transport, "fc")) {
-		if (!host_traddr) {
-			nvme_msg(ctx, LOG_ERR, "host_traddr required for fc\n");
+	if (!strcmp(nfctx.transport, "fc")) {
+		if (!nfctx.host_traddr) {
+			nvme_msg(ctx, LOG_ERR,
+				 "host_traddr required for fc\n");
 			return 0;
 		}
 	}
 
 	/* ignore if host_iface set for any transport other than tcp */
-	if (!strcmp(transport, "rdma") || !strcmp(transport, "fc")) {
-		if (host_iface) {
+	if (!strcmp(nfctx.transport, "rdma") ||
+	    !strcmp(nfctx.transport, "fc")) {
+		if (nfctx.host_iface) {
 			nvme_msg(ctx, LOG_ERR,
 				 "host_iface not permitted for rdma or fc\n");
 			return 0;
 		}
 	}
 
-	trsvcid = nvme_ctrl_get_trsvcid(c);
-	if (!trsvcid || !strcmp(trsvcid, ""))
-		trsvcid = nvmf_get_default_trsvcid(transport, true);
+	nfctx.trsvcid = nvme_ctrl_get_trsvcid(c);
+	if (!nfctx.trsvcid || !strcmp(nfctx.trsvcid, ""))
+		nfctx.trsvcid =
+			nvmf_get_default_trsvcid(nfctx.transport, true);
 
 	if (force)
-		subsysnqn = nvme_ctrl_get_subsysnqn(c);
+		nfctx.subsysnqn = nvme_ctrl_get_subsysnqn(c);
 	else
-		subsysnqn = NVME_DISC_SUBSYS_NAME;
+		nfctx.subsysnqn = NVME_DISC_SUBSYS_NAME;
 
-	if (nvme_ctrl_is_persistent(c))
-		fctx->persistent = true;
+	if (nvme_ctrl_get_persistent(c))
+		nfctx.persistent = true;
 
 	memcpy(&cfg, fctx->cfg, sizeof(cfg));
 
-	struct fabric_args trcfg = {
-		.subsysnqn	= subsysnqn,
-		.transport	= transport,
-		.traddr		= traddr,
-		.trsvcid	= trsvcid,
-		.host_traddr	= host_traddr,
-		.host_iface	= host_iface,
-	};
-
 	if (!force) {
-		cn = lookup_ctrl(h, &trcfg);
+		cn = lookup_ctrl(h, &nfctx);
 		if (cn) {
-			fctx->persistent = true;
-			_nvmf_discovery(ctx, fctx, connect, cn);
+			nfctx.persistent = true;
+			_nvmf_discovery(ctx, &nfctx, connect, cn);
 			return 0;
 		}
 	}
 
-	ret = nvmf_create_discovery_ctrl(ctx, fctx, h, &cfg, &trcfg, &cn);
+	ret = nvmf_create_discovery_ctrl(ctx, &nfctx, h, &cfg, &cn);
 	if (ret)
 		return 0;
 
-	_nvmf_discovery(ctx, fctx, connect, cn);
+	_nvmf_discovery(ctx, &nfctx, connect, cn);
 	if (!(fctx->persistent || is_persistent_discovery_ctrl(h, cn)))
 		ret = nvme_disconnect_ctrl(cn);
 	nvme_free_ctrl(cn);
@@ -2493,7 +2240,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;
@@ -2529,7 +2276,7 @@ int nvmf_discovery_config_json(struct nvme_global_ctx *ctx,
 						"failed to connect to hostnqn=%s,nqn=%s,%s\n",
 						nvme_host_get_hostnqn(h),
 						nvme_subsystem_get_name(s),
-						nvme_ctrl_get_address(c));
+						nvme_ctrl_get_traddr(c));
 
 					if (!ret)
 						ret = err;
@@ -2541,7 +2288,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;
@@ -2588,7 +2335,7 @@ int nvmf_connect_config_json(struct nvme_global_ctx *ctx,
 						 "failed to connect to hostnqn=%s,nqn=%s,%s\n",
 						 nvme_host_get_hostnqn(h),
 						 nvme_subsystem_get_name(s),
-						 nvme_ctrl_get_address(c));
+						 nvme_ctrl_get_traddr(c));
 
 					if (!ret)
 						ret = err;
@@ -2600,7 +2347,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;
@@ -2624,30 +2371,24 @@ int nvmf_discovery_config_file(struct nvme_global_ctx *ctx,
 		if (err)
 			break;
 
-		struct fabric_args trcfg = {
-			.subsysnqn	= fctx->subsysnqn,
-			.transport	= fctx->transport,
-			.traddr		= fctx->traddr,
-			.trsvcid	= fctx->trsvcid,
-			.host_traddr	= fctx->host_traddr,
-			.host_iface	= fctx->host_iface,
-		};
+		struct nvmf_context nfctx = *fctx;
 
 		if (!force) {
-			c = lookup_ctrl(h, &trcfg);
+			c = lookup_ctrl(h, &nfctx);
 			if (c) {
-				_nvmf_discovery(ctx, fctx, connect, c);
+				_nvmf_discovery(ctx, &nfctx, connect, c);
 				continue;
 			}
 		}
 
-		err = nvmf_create_discovery_ctrl(ctx, fctx, h, fctx->cfg,
-			&trcfg, &c);
+		err = nvmf_create_discovery_ctrl(ctx, &nfctx, h, fctx->cfg,
+			&c);
 		if (err)
 			continue;
 
-		_nvmf_discovery(ctx, fctx, connect, c);
-		if (!(fctx->persistent || is_persistent_discovery_ctrl(h, c)))
+		_nvmf_discovery(ctx, &nfctx, connect, c);
+		if (!(nfctx.persistent ||
+		      is_persistent_discovery_ctrl(h, c)))
 			err = nvme_disconnect_ctrl(c);
 		nvme_free_ctrl(c);
 	} while (!err);
@@ -2660,7 +2401,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;
@@ -2670,9 +2411,9 @@ int nvmf_config_modify(struct nvme_global_ctx *ctx,
 	struct nvme_ctrl *c;
 
 	if (!fctx->hostnqn)
-		fctx->hostnqn = hnqn = nvmf_hostnqn_from_file();
+		fctx->hostnqn = hnqn = nvme_read_hostnqn();
 	if (!fctx->hostid && hnqn)
-		fctx->hostid = hid = nvmf_hostid_from_file();
+		fctx->hostid = hid = nvme_read_hostid();
 
 	h = nvme_lookup_host(ctx, fctx->hostnqn, fctx->hostid);
 	if (!h) {
@@ -2682,7 +2423,7 @@ int nvmf_config_modify(struct nvme_global_ctx *ctx,
 	}
 
 	if (fctx->hostkey)
-		nvme_host_set_dhchap_key(h, fctx->hostkey);
+		nvme_host_set_dhchap_host_key(h, fctx->hostkey);
 
 	s = nvme_lookup_subsystem(h, NULL, fctx->subsysnqn);
 	if (!s) {
@@ -2700,7 +2441,7 @@ int nvmf_config_modify(struct nvme_global_ctx *ctx,
 	}
 
 	if (fctx->ctrlkey)
-		nvme_ctrl_set_dhchap_key(c, fctx->ctrlkey);
+		nvme_ctrl_set_dhchap_ctrl_key(c, fctx->ctrlkey);
 
 	nvme_parse_tls_args(fctx->keyring, fctx->tls_key,
 			    fctx->tls_key_identity, fctx->cfg, c);
@@ -2717,7 +2458,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;
@@ -2734,7 +2475,7 @@ int nvmf_nbft_read_files(struct nvme_global_ctx *ctx, char *path,
 		snprintf(filename, sizeof(filename), "%s/%s", path,
 			dent[i]->d_name);
 
-		ret = nvme_nbft_read(ctx, &nbft, filename);
+		ret = nvme_read_nbft(ctx, &nbft, filename);
 		if (!ret) {
 			struct nbft_file_entry *new;
 
@@ -2756,12 +2497,12 @@ 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;
 
-		nvme_nbft_free(ctx, head->nbft);
+		nvme_free_nbft(ctx, head->nbft);
 		free(head);
 
 		head = next;
@@ -2797,7 +2538,7 @@ static bool validate_uri(struct nvme_global_ctx *ctx,
 static int nbft_connect(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx, struct nvme_host *h,
 		struct nvmf_disc_log_entry *e,
-		struct nbft_info_subsystem_ns *ss, struct fabric_args *trcfg,
+		struct nbft_info_subsystem_ns *ss,
 		struct nvme_fabrics_config *cfg)
 {
 	nvme_ctrl_t c;
@@ -2809,14 +2550,13 @@ static int nbft_connect(struct nvme_global_ctx *ctx,
 	saved_log_level = nvme_get_logging_level(ctx, &saved_log_tstamp,
 		&saved_log_pid);
 
-	/* Already connected ? */
-	c = lookup_ctrl(h, trcfg);
+	c = lookup_ctrl(h, fctx);
 	if (c && nvme_ctrl_get_name(c))
 		return 0;
 
-	ret = nvme_create_ctrl(ctx, trcfg->subsysnqn, trcfg->transport,
-			     trcfg->traddr, trcfg->host_traddr,
-			     trcfg->host_iface, trcfg->trsvcid, &c);
+	ret = nvme_create_ctrl(ctx, fctx->subsysnqn, fctx->transport,
+			     fctx->traddr, fctx->host_traddr,
+			     fctx->host_iface, fctx->trsvcid, &c);
 	if (ret)
 		return ret;
 
@@ -2863,7 +2603,7 @@ static int nbft_connect(struct nvme_global_ctx *ctx,
 static int nbft_discovery(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx, struct nbft_info_discovery *dd,
 		struct nvme_host *h, struct nvme_ctrl *c,
-		struct nvme_fabrics_config *defcfg, struct fabric_args *deftrcfg)
+		struct nvme_fabrics_config *defcfg)
 {
 	struct nvmf_discovery_log *log = NULL;
 	int ret;
@@ -2888,44 +2628,42 @@ static int nbft_discovery(struct nvme_global_ctx *ctx,
 
 	for (i = 0; i < le64_to_cpu(log->numrec); i++) {
 		struct nvmf_disc_log_entry *e = &log->entries[i];
+		struct nvmf_context nfctx = *fctx;
 		nvme_ctrl_t cl;
 		int tmo = defcfg->keep_alive_tmo;
 
-		struct fabric_args trcfg = {
-			.subsysnqn	= e->subnqn,
-			.transport	= nvmf_trtype_str(e->trtype),
-			.traddr		= e->traddr,
-			.host_traddr	= fctx->host_traddr,
-			.host_iface	= fctx->host_iface,
-			.trsvcid	= e->trsvcid,
-		};
+		nfctx.subsysnqn = e->subnqn;
+		nfctx.transport = nvmf_trtype_str(e->trtype);
+		nfctx.traddr = e->traddr;
+		nfctx.trsvcid = e->trsvcid;
 
 		if (e->subtype == NVME_NQN_CURR)
 			continue;
 
 		/* Already connected ? */
-		cl = lookup_ctrl(h, &trcfg);
+		cl = lookup_ctrl(h, &nfctx);
 		if (cl && nvme_ctrl_get_name(cl))
 			continue;
 
 		/* Skip connect if the transport types don't match */
 		if (strcmp(nvme_ctrl_get_transport(c),
-			   nvmf_trtype_str(e->trtype)))
+			   nfctx.transport))
 			continue;
 
 		if (e->subtype == NVME_NQN_DISC) {
 			nvme_ctrl_t child;
 
-			ret = nvmf_connect_disc_entry(h, e, fctx->host_traddr,
-				fctx->host_iface, defcfg, NULL, &child);
+			ret = nvmf_connect_disc_entry(h, e,
+				nfctx.host_traddr, nfctx.host_iface,
+				defcfg, NULL, &child);
 			if (ret)
 				continue;
-			nbft_discovery(ctx, fctx, dd, h, child, defcfg, &trcfg);
+			nbft_discovery(ctx, &nfctx, dd, h, child, defcfg);
 			nvme_disconnect_ctrl(child);
 			nvme_free_ctrl(child);
 		} else {
-			ret = nbft_connect(ctx, fctx, h, e, NULL,
-				&trcfg, defcfg);
+			ret = nbft_connect(ctx, &nfctx, h, e, NULL,
+				defcfg);
 
 			/*
 			 * With TCP/DHCP, it can happen that the OS
@@ -2933,13 +2671,13 @@ static int nbft_discovery(struct nvme_global_ctx *ctx,
 			 * firmware had. Retry without host_traddr.
 			 */
 			if (ret == -ENVME_CONNECT_ADDRNOTAVAIL &&
-			    !strcmp(trcfg.transport, "tcp") &&
+			    !strcmp(nfctx.transport, "tcp") &&
 			    strlen(dd->hfi->tcp_info.dhcp_server_ipaddr) > 0) {
-				const char *htradr = trcfg.host_traddr;
+				const char *htradr = nfctx.host_traddr;
 
-				trcfg.host_traddr = NULL;
-				ret = nbft_connect(ctx, fctx, h, e, NULL,
-					&trcfg, defcfg);
+				nfctx.host_traddr = NULL;
+				ret = nbft_connect(ctx, &nfctx, h, e, NULL,
+					defcfg);
 
 				if (ret == 0)
 					nvme_msg(ctx, LOG_INFO,
@@ -2963,7 +2701,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;
@@ -3025,6 +2763,8 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 		/* Subsystem Namespace Descriptor List */
 		for (ss = entry->nbft->subsystem_ns_list; ss && *ss; ss++)
 			for (i = 0; i < (*ss)->num_hfis; i++) {
+				struct nvmf_context nfctx = *fctx;
+
 				hfi = (*ss)->hfis[i];
 
 				/* Skip discovery NQN records */
@@ -3036,22 +2776,20 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 					continue;
 				}
 
-				host_traddr = NULL;
+				nfctx.host_traddr = NULL;
 				if (!fctx->host_traddr &&
 				    !strncmp((*ss)->transport, "tcp", 3))
-					host_traddr = hfi->tcp_info.ipaddr;
+					nfctx.host_traddr =
+						hfi->tcp_info.ipaddr;
 
-				struct fabric_args trcfg = {
-					.subsysnqn	= (*ss)->subsys_nqn,
-					.transport	= (*ss)->transport,
-					.traddr		= (*ss)->traddr,
-					.trsvcid	= (*ss)->trsvcid,
-					.host_traddr	= host_traddr,
-					.host_iface	= NULL,
-				};
+				nfctx.subsysnqn = (*ss)->subsys_nqn;
+				nfctx.transport = (*ss)->transport;
+				nfctx.traddr = (*ss)->traddr;
+				nfctx.trsvcid = (*ss)->trsvcid;
+				nfctx.host_iface = NULL;
 
-				rr = nbft_connect(ctx, fctx, h, NULL,
-					*ss, &trcfg, fctx->cfg);
+				rr = nbft_connect(ctx, &nfctx, h, NULL,
+					*ss, fctx->cfg);
 
 				/*
 				 * With TCP/DHCP, it can happen that the OS
@@ -3059,12 +2797,12 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 				 * firmware had. Retry without host_traddr.
 				 */
 				if (rr == -ENVME_CONNECT_ADDRNOTAVAIL &&
-				    !strcmp(trcfg.transport, "tcp") &&
+				    !strcmp(nfctx.transport, "tcp") &&
 				    strlen(hfi->tcp_info.dhcp_server_ipaddr) > 0) {
-					trcfg.host_traddr = NULL;
+					nfctx.host_traddr = NULL;
 
-					rr = nbft_connect(ctx, fctx, h, NULL,
-						*ss, &trcfg, fctx->cfg);
+					rr = nbft_connect(ctx, &nfctx, h, NULL,
+						*ss, fctx->cfg);
 
 					if (rr == 0)
 						nvme_msg(ctx, LOG_INFO,
@@ -3089,6 +2827,7 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 		for (dd = entry->nbft->discovery_list; dd && *dd; dd++) {
 			_cleanup_uri_ struct nvme_fabrics_uri *uri = NULL;
 			_cleanup_free_ char *trsvcid = NULL;
+			struct nvmf_context nfctx = *fctx;
 			bool persistent = false;
 			bool linked = false;
 			nvme_ctrl_t c;
@@ -3131,29 +2870,27 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 					strdup(nvmf_get_default_trsvcid(
 						uri->protocol, true));
 
-			struct fabric_args trcfg = {
-				.subsysnqn	= NVME_DISC_SUBSYS_NAME,
-				.transport	= uri->protocol,
-				.traddr		= uri->host,
-				.trsvcid	= trsvcid,
-				.host_traddr	= host_traddr,
-				.host_iface	= NULL,
-			};
+			nfctx.subsysnqn = NVME_DISC_SUBSYS_NAME;
+			nfctx.transport =  uri->protocol;
+			nfctx.traddr = uri->host;
+			nfctx.trsvcid = trsvcid;
+			nfctx.host_traddr = host_traddr;
+			nfctx.host_iface = NULL;
 
 			/* Lookup existing discovery controller */
-			c = lookup_ctrl(h, &trcfg);
+			c = lookup_ctrl(h, &nfctx);
 			if (c && nvme_ctrl_get_name(c))
 				persistent = true;
 
 			if (!c) {
-				ret = nvmf_create_discovery_ctrl(ctx, fctx, h,
-					fctx->cfg, &trcfg, &c);
+				ret = nvmf_create_discovery_ctrl(ctx, &nfctx,
+					h, fctx->cfg, &c);
 				if (ret == -ENVME_CONNECT_ADDRNOTAVAIL &&
-				    !strcmp(trcfg.transport, "tcp") &&
+				    !strcmp(nfctx.transport, "tcp") &&
 				    strlen(hfi->tcp_info.dhcp_server_ipaddr) > 0) {
-					trcfg.host_traddr = NULL;
+					nfctx.traddr = NULL;
 					ret = nvmf_create_discovery_ctrl(ctx,
-						fctx, h, fctx->cfg, &trcfg, &c);
+						&nfctx, h, fctx->cfg, &c);
 				}
 			} else
 				ret = 0;
@@ -3165,8 +2902,7 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 				goto out_free;
 			}
 
-			rr = nbft_discovery(ctx, fctx, *dd, h, c, fctx->cfg,
-				&trcfg);
+			rr = nbft_discovery(ctx, &nfctx, *dd, h, c, fctx->cfg);
 			if (!persistent)
 				nvme_disconnect_ctrl(c);
 			nvme_free_ctrl(c);
@@ -3181,93 +2917,7 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 	return ret;
 }
 
-static int __create_discover_ctrl(struct nvme_global_ctx *ctx,
-		struct nvmf_context *fctx, nvme_host_t h,
-		struct nvme_fabrics_config *cfg, struct fabric_args *trcfg,
-		struct nvme_ctrl **ctrl)
-{
-	struct nvme_ctrl *c;
-	int tmo, ret;
-
-	ret = nvme_create_ctrl(ctx, trcfg->subsysnqn, trcfg->transport,
-			       trcfg->traddr, trcfg->host_traddr,
-			       trcfg->host_iface, trcfg->trsvcid, &c);
-	if (ret)
-		return ret;
-
-	nvme_ctrl_set_discovery_ctrl(c, true);
-	nvme_ctrl_set_unique_discovery_ctrl(c,
-		     strcmp(trcfg->subsysnqn, NVME_DISC_SUBSYS_NAME));
-	tmo = set_discovery_kato(fctx, cfg);
-
-	ret = nvme_add_ctrl(fctx, h, c, cfg);
-	cfg->keep_alive_tmo = tmo;
-	if (ret) {
-		nvme_free_ctrl(c);
-		return ret;
-	}
-
-	*ctrl = c;
-	return 0;
-}
-
-static int nvmf_create_discover_ctrl(struct nvme_global_ctx *ctx,
-		struct nvmf_context *fctx,
-		struct nvme_host *h, struct nvme_fabrics_config *cfg,
-		struct fabric_args *trcfg, struct nvme_ctrl **ctrl)
-{
-	_cleanup_nvme_free_ struct nvme_id_ctrl *id = NULL;
-	struct nvme_ctrl *c;
-	int ret;
-
-	ret = __create_discover_ctrl(ctx, fctx, h, cfg, trcfg, &c);
-	if (ret)
-		return ret;
-
-	if (nvme_ctrl_is_unique_discovery_ctrl(c)) {
-		*ctrl = c;
-		return 0;
-	}
-
-	id = __nvme_alloc(sizeof(*id));
-	if (!id) {
-		nvme_free_ctrl(c);
-		return -ENOMEM;
-	}
-
-	/* Find out the name of discovery controller */
-	ret = nvme_ctrl_identify(c, id);
-	if (ret) {
-		nvme_msg(ctx, LOG_ERR,
-			 "failed to identify controller, error %s\n",
-			 nvme_strerror(-ret));
-		nvme_disconnect_ctrl(c);
-		nvme_free_ctrl(c);
-		return ret;
-	}
-
-	if (!strcmp(id->subnqn, NVME_DISC_SUBSYS_NAME)) {
-		*ctrl = c;
-		return 0;
-	}
-
-	/*
-	 * The subsysnqn is not the well-known name. Prefer the unique
-	 * subsysnqn over the well-known one.
-	 */
-	nvme_disconnect_ctrl(c);
-	nvme_free_ctrl(c);
-
-	trcfg->subsysnqn = id->subnqn;
-	ret = __create_discover_ctrl(ctx, fctx, h, cfg, trcfg, &c);
-	if (ret)
-		return ret;
-
-	*ctrl = c;
-	return 0;
-}
-
-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;
@@ -3286,7 +2936,7 @@ int nvmf_discovery(struct nvme_global_ctx *ctx, struct nvmf_context *fctx,
 		ret = nvme_scan_ctrl(ctx, fctx->device, &c);
 		if (!ret) {
 			/* Check if device matches command-line options */
-			if (!nvme_ctrl_config_match(c, fctx->transport,
+			if (!nvme_ctrl_match_config(c, fctx->transport,
 				fctx->traddr, fctx->trsvcid,
 					fctx->subsysnqn, fctx->host_traddr,
 					fctx->host_iface)) {
@@ -3295,7 +2945,7 @@ int nvmf_discovery(struct nvme_global_ctx *ctx, struct nvmf_context *fctx,
 				    fctx->device);
 			}
 
-			if (!nvme_ctrl_is_discovery_ctrl(c)) {
+			if (!nvme_ctrl_get_discovery_ctrl(c)) {
 				nvme_msg(
 					ctx, LOG_ERR,
 					"ctrl device %s found, ignoring non discovery controller\n",
@@ -3340,24 +2990,14 @@ int nvmf_discovery(struct nvme_global_ctx *ctx, struct nvmf_context *fctx,
 		}
 	}
 
-	struct fabric_args trcfg = {
-		.subsysnqn	= fctx->subsysnqn,
-		.transport	= fctx->transport,
-		.traddr		= fctx->traddr,
-		.trsvcid	= fctx->trsvcid,
-		.host_traddr	= fctx->host_traddr,
-		.host_iface	= fctx->host_iface,
-	};
-
 	if (!c && !force) {
-		c = lookup_ctrl(h, &trcfg);
+		c = lookup_ctrl(h, fctx);
 		if (c)
 			fctx->persistent = true;
 	}
 	if (!c) {
 		/* No device or non-matching device, create a new controller */
-		ret = nvmf_create_discover_ctrl(ctx, fctx, h, fctx->cfg,
-			&trcfg, &c);
+		ret = nvmf_create_discovery_ctrl(ctx, fctx, h, fctx->cfg, &c);
 		if (ret) {
 			if (ret != -ENVME_CONNECT_IGNORED)
 				nvme_msg(ctx, LOG_ERR,
@@ -3375,7 +3015,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;
@@ -3389,16 +3029,7 @@ int nvmf_connect(struct nvme_global_ctx *ctx, struct nvmf_context *fctx)
 	if (err)
 		return err;
 
-	struct fabric_args trcfg = {
-		.subsysnqn	= fctx->subsysnqn,
-		.transport	= fctx->transport,
-		.traddr		= fctx->traddr,
-		.trsvcid	= fctx->trsvcid,
-		.host_traddr	= fctx->host_traddr,
-		.host_iface	= fctx->host_iface,
-	};
-
-	c = lookup_ctrl(h, &trcfg);
+	c = lookup_ctrl(h, fctx);
 	if (c && nvme_ctrl_get_name(c) && !fctx->cfg->duplicate_connect) {
 		fctx->already_connected(fctx, h, nvme_ctrl_get_subsysnqn(c),
 			nvme_ctrl_get_transport(c), nvme_ctrl_get_traddr(c),
@@ -3406,14 +3037,17 @@ int nvmf_connect(struct nvme_global_ctx *ctx, struct nvmf_context *fctx)
 		return -EALREADY;
 	}
 
-	err = nvme_create_ctrl(ctx, trcfg.subsysnqn, trcfg.transport,
-		trcfg.traddr, trcfg.host_traddr, trcfg.host_iface,
-		trcfg.trsvcid, &c);
+	err = nvme_create_ctrl(ctx, fctx->subsysnqn, fctx->transport,
+		fctx->traddr, fctx->host_traddr, fctx->host_iface,
+		fctx->trsvcid, &c);
 	if (err)
 		return err;
 
-	if (fctx->ctrlkey)
-		nvme_ctrl_set_dhchap_key(c, fctx->ctrlkey);
+	if (fctx->hostkey) {
+		nvme_ctrl_set_dhchap_host_key(c, fctx->hostkey);
+		if (fctx->ctrlkey)
+			nvme_ctrl_set_dhchap_ctrl_key(c, fctx->ctrlkey);
+	}
 
 	nvme_parse_tls_args(fctx->keyring, fctx->tls_key,
 		fctx->tls_key_identity, fctx->cfg, c);
@@ -3422,7 +3056,7 @@ int nvmf_connect(struct nvme_global_ctx *ctx, struct nvmf_context *fctx)
 	 * We are connecting to a discovery controller, so let's treat
 	 * this as a persistent connection and specify a KATO.
 	 */
-	if (!strcmp(trcfg.subsysnqn, NVME_DISC_SUBSYS_NAME)) {
+	if (!strcmp(fctx->subsysnqn, NVME_DISC_SUBSYS_NAME)) {
 		fctx->persistent = true;
 
 		set_discovery_kato(fctx, fctx->cfg);
diff --git a/libnvme/src/nvme/fabrics.h b/libnvme/src/nvme/fabrics.h
index 9f9549dc51..5a441ec2a0 100644
--- a/libnvme/src/nvme/fabrics.h
+++ b/libnvme/src/nvme/fabrics.h
@@ -283,57 +283,6 @@ struct nvme_get_discovery_args {
 int nvmf_get_discovery_wargs(struct nvme_get_discovery_args *args,
 			     struct nvmf_discovery_log **log);
 
-/**
- * nvmf_hostnqn_generate() - Generate a machine specific host nqn
- * Returns: An nvm namespace qualified name string based on the machine
- * identifier, or NULL if not successful.
- */
-char *nvmf_hostnqn_generate();
-
-/**
- * nvmf_hostnqn_generate_from_hostid() - Generate a host nqn from host identifier
- * @hostid:		Host identifier
- *
- * If @hostid is NULL, the function generates it based on the machine
- * identifier.
- *
- * Return: On success, an NVMe Qualified Name for host identification. This
- * name is based on the given host identifier. On failure, NULL.
- */
-char *nvmf_hostnqn_generate_from_hostid(char *hostid);
-
-/**
- * nvmf_hostid_generate() - Generate a machine specific host identifier
- *
- * Return: On success, an identifier string based on the machine identifier to
- * be used as NVMe Host Identifier, or NULL on failure.
- */
-char *nvmf_hostid_generate();
-
-/**
- * nvmf_hostnqn_from_file() - Reads the host nvm qualified name from the config
- *			      default location
- *
- * Retrieve the qualified name from the config file located in $SYSCONFIDR/nvme.
- * $SYSCONFDIR is usually /etc.
- *
- * Return: The host nqn, or NULL if unsuccessful. If found, the caller
- * is responsible to free the string.
- */
-char *nvmf_hostnqn_from_file();
-
-/**
- * nvmf_hostid_from_file() - Reads the host identifier from the config default
- *			     location
- *
- * Retrieve the host idenditifer from the config file located in $SYSCONFDIR/nvme/.
- * $SYSCONFDIR is usually /etc.
- *
- * Return: The host identifier, or NULL if unsuccessful. If found, the caller
- *	   is responsible to free the string.
- */
-char *nvmf_hostid_from_file();
-
 /**
  * nvmf_is_registration_supported - check whether registration can be performed.
  * @c:	Controller instance
@@ -645,15 +594,7 @@ int nvmf_connect_config_json(struct nvme_global_ctx *ctx,
 int nvmf_config_modify(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx);
 
-/**
- * struct nbft_file_entry - Linked list entry for NBFT files
- * @next: Pointer to next entry
- * @nbft: Pointer to NBFT info structure
- */
-struct nbft_file_entry {
-	struct nbft_file_entry *next;
-	struct nbft_info *nbft;
-};
+struct nbft_file_entry;
 
 /**
  * nvmf_nbft_read_files() - Read NBFT files from path
diff --git a/libnvme/src/nvme/filters.c b/libnvme/src/nvme/filters.c
index e2f50e3137..e960420821 100644
--- a/libnvme/src/nvme/filters.c
+++ b/libnvme/src/nvme/filters.c
@@ -6,15 +6,16 @@
  * Authors: Keith Busch <keith.busch@wdc.com>
  * 	    Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
  */
+#include <dirent.h>
 #include <stdio.h>
 #include <string.h>
-#include <dirent.h>
 
 #include <libnvme.h>
 
 #include "private.h"
+#include "compiler_attributes.h"
 
-int nvme_namespace_filter(const struct dirent *d)
+__public int nvme_filter_namespace(const struct dirent *d)
 {
 	int i, n;
 
@@ -28,7 +29,7 @@ int nvme_namespace_filter(const struct dirent *d)
 	return 0;
 }
 
-int nvme_paths_filter(const struct dirent *d)
+__public int nvme_filter_paths(const struct dirent *d)
 {
 	int i, c, n;
 
@@ -42,7 +43,7 @@ int nvme_paths_filter(const struct dirent *d)
 	return 0;
 }
 
-int nvme_ctrls_filter(const struct dirent *d)
+__public int nvme_filter_ctrls(const struct dirent *d)
 {
 	int i, c, n;
 
@@ -61,7 +62,7 @@ int nvme_ctrls_filter(const struct dirent *d)
 	return 0;
 }
 
-int nvme_subsys_filter(const struct dirent *d)
+__public int nvme_filter_subsys(const struct dirent *d)
 {
 	int i;
 
@@ -75,60 +76,60 @@ int nvme_subsys_filter(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;
 
-	ret = scandir(dir, subsys, nvme_subsys_filter, alphasort);
+	ret = scandir(dir, subsys, nvme_filter_subsys, alphasort);
 	if (ret < 0)
 		return -errno;
 
 	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;
 
 	ret = scandir(nvme_subsystem_get_sysfs_dir(s), ns,
-		       nvme_namespace_filter, alphasort);
+		       nvme_filter_namespace, alphasort);
 	if (ret < 0)
 		return -errno;
 
 	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;
 
-	ret = scandir(dir, ctrls, nvme_ctrls_filter, alphasort);
+	ret = scandir(dir, ctrls, nvme_filter_ctrls, alphasort);
 	if (ret < 0)
 		return -errno;
 
 	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;
 
 	ret = scandir(nvme_ctrl_get_sysfs_dir(c), paths,
-		       nvme_paths_filter, alphasort);
+		       nvme_filter_paths, alphasort);
 	if (ret < 0)
 		return -errno;
 
 	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;
 
 	ret = scandir(nvme_ctrl_get_sysfs_dir(c), ns,
-		       nvme_namespace_filter, alphasort);
+		       nvme_filter_namespace, alphasort);
 	if (ret < 0)
 		return -errno;
 
@@ -140,7 +141,7 @@ int nvme_scan_ns_head_paths(nvme_ns_head_t head, struct dirent ***paths)
 	int ret;
 
 	ret = scandir(nvme_ns_head_get_sysfs_dir(head), paths,
-		       nvme_paths_filter, alphasort);
+		       nvme_filter_paths, alphasort);
 	if (ret < 0)
 		return -errno;
 
diff --git a/libnvme/src/nvme/filters.h b/libnvme/src/nvme/filters.h
index 44f26ab2b3..05fd02a6f6 100644
--- a/libnvme/src/nvme/filters.h
+++ b/libnvme/src/nvme/filters.h
@@ -20,36 +20,36 @@
  */
 
 /**
- * nvme_namespace_filter() - Filter for namespaces
+ * nvme_filter_namespace() - Filter for namespaces
  * @d: dirent to check
  *
  * Return: 1 if @d matches, 0 otherwise
  */
-int nvme_namespace_filter(const struct dirent *d);
+int nvme_filter_namespace(const struct dirent *d);
 
 /**
- * nvme_paths_filter() - Filter for paths
+ * nvme_filter_paths() - Filter for paths
  * @d: dirent to check
  *
  * Return: 1 if @d matches, 0 otherwise
  */
-int nvme_paths_filter(const struct dirent *d);
+int nvme_filter_paths(const struct dirent *d);
 
 /**
- * nvme_ctrls_filter() - Filter for controllers
+ * nvme_filter_ctrls() - Filter for controllers
  * @d: dirent to check
  *
  * Return: 1 if @d matches, 0 otherwise
  */
-int nvme_ctrls_filter(const struct dirent *d);
+int nvme_filter_ctrls(const struct dirent *d);
 
 /**
- * nvme_subsys_filter() - Filter for subsystems
+ * nvme_filter_subsys() - Filter for subsystems
  * @d: dirent to check
  *
  * Return: 1 if @d matches, 0 otherwise
  */
-int nvme_subsys_filter(const struct dirent *d);
+int nvme_filter_subsys(const struct dirent *d);
 
 /**
  * nvme_scan_subsystems() - Scan for subsystems
diff --git a/libnvme/src/nvme/generate-accessors.c b/libnvme/src/nvme/generate-accessors.c
deleted file mode 100644
index 80afacc0cf..0000000000
--- a/libnvme/src/nvme/generate-accessors.c
+++ /dev/null
@@ -1,1783 +0,0 @@
-// 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>
- *
- * This program parses C header files and generates accessor
- * functions (setter/getter) for each member found within.
- *
- * Limitations:
- *   - Does not support typedef struct. For example,
- *     typedef struct {
- *         ...
- *     } my_struct_t;
- *
- *   - Does not support struct within struct. For example,
- *     struct my_struct {
- *         struct another_struct {
- *            ...
- *         } my_var;
- *         ...
- *     };
- *
- * Example usage:
- *   ./generate-accessors private.h
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <regex.h>
-#include <stdbool.h>
-#include <getopt.h>
-#include <glob.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <errno.h>
-#include <string.h>
-#include <libgen.h>
-#include <stdio.h>
-#include <ctype.h>
-
-#ifdef NVME_HAVE_SENDFILE
-#include <sys/sendfile.h>
-#endif
-
-#define OUTPUT_FNAME_DEFAULT_C "accessors.c"
-#define OUTPUT_FNAME_DEFAULT_H "accessors.h"
-#define OUTPUT_FNAME_DEFAULT_LD "accessors.ld"
-
-#define STRUCT_RE     "struct[[:space:]]+([A-Za-z_][A-Za-z0-9_]*)[[:space:]]*\\{([^}]*)\\}[[:space:]]*;"
-#define CHAR_ARRAY_RE "^(const[[:space:]]+)?char[[:space:]]+([A-Za-z_][A-Za-z0-9_]*)[[:space:]]*\\[[[:space:]]*([A-Za-z0-9_]+)[[:space:]]*\\][[:space:]]*;"
-#define MEMBER_RE     "^(const[[:space:]]+)?([A-Za-z_][A-Za-z0-9_]*)([*[:space:]]+)([A-Za-z_][A-Za-z0-9_]*)[[:space:]]*;"
-
-#define SPACES        " \t\n\r"
-#define streq(a, b)   (strcmp((a), (b)) == 0)
-
-static const char *banner =
-	"// SPDX-License-Identifier: LGPL-2.1-or-later\n"
-	"/**\n"
-	" * This file is part of libnvme.\n"
-	" *\n"
-	" *   ____                           _           _    ____          _\n"
-	" *  / ___| ___ _ __   ___ _ __ __ _| |_ ___  __| |  / ___|___   __| | ___\n"
-	" * | |  _ / _ \\ '_ \\ / _ \\ '__/ _` | __/ _ \\/ _` | | |   / _ \\ / _` |/ _ \\\n"
-	" * | |_| |  __/ | | |  __/ | | (_| | ||  __/ (_| | | |__| (_) | (_| |  __/\n"
-	" *  \\____|\\___|_| |_|\\___|_|  \\__,_|\\__\\___|\\__,_|  \\____\\___/ \\__,_|\\___|\n"
-	" *\n"
-	" * Auto-generated struct member accessors (setter/getter)\n"
-	" */\n";
-
-/**
- * @brief Remove leading whitespace characters from string
- *        in-place.
- *
- * Removes leading whitespace defined by SPACES by returning
- * a pointer within @s to the first character that is not a
- * whitespace.
- *
- * @param s: The writable string to trim. If NULL, return NULL.
- *
- * @return Pointer to the first character of s that is not a
- *         white space, or NULL if @s is NULL.
- */
-static inline char *ltrim(const char *s)
-{
-	return s ? (char *)s + strspn(s, SPACES) : NULL;
-}
-
-/**
- * @brief Remove trailing whitespace characters from a string in-place.
- *
- * Removes trailing whitespace defined by SPACES by writing a
- * terminating NUL byte at the first trailing whitespace position.
- *
- * @param s: The writable string to trim. If NULL, return NULL.
- *
- * @return The same pointer @s, or NULL if @s is NULL.
- */
-static char *rtrim(char *s)
-{
-	if (!s)
-		return NULL;
-
-	char *p0 = s;
-
-	for (char *p = s; *p; p++) {
-		if (!strchr(SPACES, *p))
-			p0 = p + 1;
-	}
-	*p0 = '\0';
-
-	return s;
-}
-
-/**
- * @brief Trim both leading and trailing whitespace from a string.
- *
- * Uses ltrim to skip leading whitespace (returns pointer into original
- * string) and rtrim to remove trailing whitespace in-place.
- *
- * @param s: The string to trim. If NULL, returns NULL.
- *
- * @return Pointer to the trimmed string (may be interior of original),
- *         or NULL if @s is NULL.
- */
-static char *trim(char *s)
-{
-	return s ? rtrim(ltrim(s)) : NULL;
-}
-
-/**
- * @brief Strip inline C++-style comments ("// ...") from a line.
- *
- * If the substring "//" is found in @line, it is replaced by a NUL
- * terminator so the remainder is ignored.
- *
- * @param line: Line buffer to modify (in-place).
- *
- * @return Pointer to the (possibly truncated) line.
- */
-static char *trim_inline_comments(char *line)
-{
-	char *p = strstr(line, "//");
-
-	if (p)
-		*p = '\0';
-	return line;
-}
-
-/**
- * @brief Remove C-style block comments (like this comment) from
- *        a text buffer.
- *
- * Replaces all comment characters with space characters to
- * preserve offsets while removing comment content.
- *
- * @param text: The buffer to clean (modified in-place). If no
- *              match is found the text pointed to by @text is
- *              left alone.
- */
-static void mask_c_comments(char *text)
-{
-	char *p = text;
-
-	while ((p = strstr(p, "/*")) != NULL) {
-		char *end = strstr(p + 2, "*/");
-
-		if (!end)
-			break;
-		memset(p, ' ', end - p + 2);
-		p = end + 2;
-	}
-}
-
-/**
- * @brief Convert a string to uppercase in-place.
- *
- * Iterates each character of @s and transforms it to uppercase
- * using toupper().
- *
- * @param s: The string to convert (modified in-place). Must be
- *           writable.
- *
- * @return Pointer to the modified @s.
- */
-static char *to_uppercase(char *s)
-{
-	if (!s)
-		return s;
-	for (int i = 0; s[i] != '\0'; i++)
-		s[i] = toupper((unsigned char)s[i]);
-	return s;
-}
-
-/**
- * @brief Sanitize a string to form a valid C identifier.
- *
- * This function modifies the given string in place so that all characters
- * conform to the rules of a valid C variable name (identifier):
- *  - The first character must be a letter (A–Z, a–z) or underscore ('_').
- *  - Subsequent characters may be letters, digits, or underscores.
- *
- * Any character that violates these rules is replaced with an underscore ('_').
- * The string is always modified in place; no new memory is allocated.
- *
- * @param s Pointer to the NUL-terminated string to sanitize.
- *           If @p s is NULL or points to an empty string, the function does nothing.
- *
- * @note This function does not check for C keywords or identifier length limits.
- *
- * @code
- * char name[] = "123bad-name!";
- * sanitize_identifier(name);
- * // Result: "_23bad_name_"
- * @endcode
- */
-static const char *sanitize_identifier(char *s)
-{
-	if (s == NULL || *s == '\0')
-		return s;
-
-	// The first character must be a letter or underscore
-	if (!isalpha((unsigned char)s[0]) && s[0] != '_')
-		s[0] = '_';
-
-	// Remaining characters: letters, digits, underscores allowed
-	for (char *p = s + 1; *p; ++p) {
-		if (!isalnum((unsigned char)*p) && *p != '_')
-			*p = '_';
-	}
-
-	return s;
-}
-
-/**
- * @brief Duplicate a C string safely.
- *
- * Allocates memory for and returns a copy of @s including the
- * terminating NUL. Uses malloc and memcpy to copy the entire buffer.
- *
- * The POSIX strdup() has unpredictable behavior when provided
- * with a NULL pointer. This function adds a NULL check for
- * safety. Also, strdup() is a POSIX extension that may not be
- * available on all platforms. Therefore, this function uses
- * malloc() and memcpy() instead of invoking strdup().
- *
- * @param s: Source string to duplicate. If NULL, returns NULL.
- *
- * @return Newly allocated copy of @s, or NULL on allocation failure or
- *         if @s is NULL. Caller must free().
- */
-static char *safe_strdup(const char *s)
-{
-	if (!s)
-		return NULL;
-
-	size_t len = strlen(s) + 1; /* length including NUL-terminator */
-	char *new_string = (char *)malloc(len);
-
-	if (!new_string)
-		return NULL; /* Return NULL on allocation failure */
-
-	memcpy(new_string, s, len); /* Copy the string including NUL-terminator */
-
-	return new_string;
-}
-
-/**
- * @brief Duplicate up to @size characters of a C string safely.
- *
- * Copies at most @size characters from @s into a newly allocated,
- * NUL-terminated buffer. If @s is shorter than @size, copies only
- * up to the terminating NUL.
- *
- * The POSIX strndup() has unpredictable behavior when provided
- * with a NULL pointer. This function adds a NULL check for
- * safety. Also, strndup() is a POSIX extension that may not be
- * available on all platforms. Therefore, this function uses
- * malloc() and memcpy() instead of invoking strndup().
- *
- * @param s: Source string to duplicate. If NULL, returns NULL.
- * @param size: Maximum number of characters to consider from @s.
- *
- * @return Newly allocated NUL-terminated copy, or NULL on
- *         allocation failure or if @s is NULL. Caller must
- *         free().
- */
-static char *safe_strndup(const char *s, size_t size)
-{
-	if (!s)
-		return NULL;
-
-	size_t len = strnlen(s, size);
-	char *new_string = malloc(len + 1);
-
-	if (!new_string)
-		return NULL;
-
-	memcpy(new_string, s, len);
-	new_string[len] = '\0';
-
-	return new_string;
-}
-
-/**
- * @brief Test whether a string contains only decimal digits.
- *
- * Returns false for NULL or empty string.
- *
- * @param s: Null-terminated string to test.
- *
- * @return true if every character in @s is a decimal digit (0-9),
- *         false otherwise.
- */
-static bool str_is_all_numbers(const char *s)
-{
-	if (!s || *s == '\0')
-		return false;
-
-	for (; *s != '\0'; s++) {
-		if (!isdigit((unsigned char)*s))
-			return false;
-	}
-
-	return true;
-}
-
-/**
- * @brief Return pointer to filename component within a path.
- *
- * Finds the last '/' in @path and returns pointer to the next
- * character; if no '/' is found returns the original @path.
- *
- * @param path: Input path string (must be NUL-terminated).
- *
- * @return Pointer to filename portion (not newly allocated).
- */
-static const char *get_filename(const char *path)
-{
-	const char *slash = strrchr(path, '/');
-
-	return slash ? slash + 1 : path;
-}
-
-/**
- * @brief Create directories recursively (mkdir -p behavior).
- *
- * Walks the path components and creates each intermediate directory
- * with the specified @mode. If @path is ".", returns success.
- *
- * @param path: Path to create (e.g., "/tmp/a/b").
- * @param mode: Permissions bits for created directories (as for mkdir).
- *
- * @return true on success (directories created or already exist),
- *         false on error (errno is set).
- */
-static bool mkdir_p(const char *path, mode_t mode)
-{
-	bool ok = false;
-	char *tmp;
-	char *p = NULL;
-	size_t len;
-
-	if (streq(path, "."))
-		return true;
-
-	if (!path || !*path) {
-		errno = EINVAL;
-		return false;
-	}
-
-	/* Copy path to temporary buffer */
-	tmp = safe_strdup(path);
-	len = strlen(tmp);
-	if (tmp[len - 1] == '/')
-		tmp[len - 1] = '\0';  /* remove trailing slash */
-
-	for (p = tmp + 1; *p; p++) {
-		if (*p == '/') {
-			*p = '\0';
-			/* Attempt to create directory */
-			if (mkdir(tmp, mode) != 0) {
-				if (errno != EEXIST)
-					goto mkdir_out;
-			}
-			*p = '/';
-		}
-	}
-
-	/* Create final directory */
-	if (mkdir(tmp, mode) != 0) {
-		if (errno != EEXIST)
-			goto mkdir_out;
-	}
-
-	ok = true;
-
-mkdir_out:
-	free(tmp);
-	return ok;
-}
-
-/**
- * @brief Create directories to hold file specified by @fullpath
- *
- * Given a path and file name (@fullpath), create the
- * directories to hold the file. This is done by splitting the
- * file portion from @fullpath and creating the directory tree.
- *
- * @param fullpath:  Directories + file name.
- * @param mode:  Permissions bits for created directories (as for mkdir).
- *
- * @return true on success (directories created or already exist),
- *         false on error (errno is set).
- */
-static bool mkdir_fullpath(const char *fullpath, mode_t mode)
-{
-	char  saved;
-	bool  ok;
-	char  *fname = (char *)get_filename(fullpath);
-
-	/* Check whether it's just a file name w/o a path. */
-	if (fname == fullpath)
-		return true;
-
-	saved = fname[0];
-	fname[0] = '\0';  /* split file name from path */
-	ok = mkdir_p(fullpath, mode);
-	fname[0] = saved; /* restore full path */
-
-	return ok;
-}
-
-/**
- * @brief Read entire file into a newly-allocated buffer.
- *
- * Opens the file at @path and reads all bytes into a buffer that is
- * NUL-terminated. Exits the program on failure to open the file.
- *
- * @param path: Path to the file to read.
- *
- * @return Pointer to a malloc()-allocated buffer containing the file
- *         contents (NUL-terminated). Caller must free(). On error the
- *         program exits with EXIT_FAILURE.
- */
-static char *read_file(const char *path)
-{
-	long  len;
-	char *buf;
-	FILE *f = fopen(path, "rb");
-
-	if (!f) {
-		perror(path);
-		exit(EXIT_FAILURE);
-	}
-	fseek(f, 0, SEEK_END);
-	len = ftell(f);
-	rewind(f);
-	buf = malloc(len + 1);
-	len = fread(buf, 1, len, f);
-	buf[len] = '\0';
-	fclose(f);
-	return buf;
-}
-
-
-/******************************************************************************/
-
-
-/**
- * @brief Compute the length of a regex match represented by regmatch_t.
- *
- * Returns zero if the match is invalid (rm_so or rm_eo negative or
- * rm_eo < rm_so).
- *
- * @param m: Pointer to regmatch_t describing the match.
- *
- * @return Size in bytes of the match, or 0 if invalid.
- */
-static size_t regmatch_size(const regmatch_t *m)
-{
-	bool invalid = m->rm_so < 0 || m->rm_eo < 0 || m->rm_eo < m->rm_so;
-
-	return invalid ? 0 : m->rm_eo - m->rm_so;
-}
-
-/**
- * @brief Duplicate the substring matched by a regmatch_t.
- *
- * Allocates a new NUL-terminated buffer and copies the matched span
- * from @src.
- *
- * @param src: Source string used in the regexec().
- * @param m:   Pointer to regmatch_t describing the match.
- *
- * @return Newly allocated string containing the match, or NULL if the
- *         match has zero length. Caller must free().
- */
-static char *regmatch_strdup(const char *src, const regmatch_t *m)
-{
-	size_t len = regmatch_size(m);
-
-	return len ? safe_strndup(src + m->rm_so, len) : NULL;
-}
-
-/**
- * @brief Check whether a regex match contains a specific character.
- *
- * Iterates characters inside the matched span and returns true if
- * character @c appears within.
- *
- * @param src: Source string used for the match.
- * @param m:   Match information.
- * @param c:   Character to search for.
- *
- * @return true if @c present in match span, false otherwise.
- */
-static bool regmatch_contains_char(const char *src, const regmatch_t *m, char c)
-{
-	size_t len = regmatch_size(m);
-
-	if (!len)
-		return false;
-
-	const char *arr = src + m->rm_so;
-
-	for (size_t i = 0; (arr[i] != '\0') && (i < len); i++) {
-		if (arr[i] == c)
-			return true;
-	}
-	return false;
-}
-
-/**
- * @brief Test whether the matched substring begins with a given prefix.
- *
- * Compares the first bytes of the match against @s.
- *
- * @param src: Source string used for matching.
- * @param m:   Match information.
- * @param s:   Prefix to compare.
- *
- * @return true if the matched substring starts with @s, false
- *         otherwise.
- */
-static bool regmatch_startswith(const char       *src,
-				const regmatch_t *m,
-				const char       *s)
-{
-	size_t size;
-	size_t len = regmatch_size(m);
-
-	if (len == 0)
-		return false;
-
-	size = strlen(s);
-	if (len < size)
-		return false;
-
-	const char *arr = src + m->rm_so;
-
-	return !strncmp(arr, s, size);
-}
-
-
-/******************************************************************************/
-
-
-typedef struct StringList {
-	const char  **strings;  /* Pointer to an array of char pointers */
-	size_t      count;      /* Current number of strings */
-	size_t      capacity;   /* Allocated capacity for strings */
-} StringList_t;
-
-
-/**
- * @brief Initialize a StringList_t object.
- *
- * Allocates the internal array with at least @initial_capacity
- * entries (minimum STRINGLIST_INITIAL_CAPACITY). The list is
- * empty after initialization.
- *
- * @param list: Pointer to the list to initialize.
- * @param initial_capacity: Desired initial capacity (will be rounded
- *                          up to at least STRINGLIST_INITIAL_CAPACITY).
- */
-#define STRINGLIST_INITIAL_CAPACITY 8
-static void strlst_init(StringList_t *list, size_t initial_capacity)
-{
-	if (initial_capacity < STRINGLIST_INITIAL_CAPACITY)
-		initial_capacity = STRINGLIST_INITIAL_CAPACITY;
-	list->strings = (const char **)calloc(initial_capacity, sizeof(char *));
-	list->count = 0;
-	list->capacity = initial_capacity;
-}
-
-/**
- * @brief Append a string to a StringList_t.
- *
- * If list capacity is exhausted, it doubles the capacity and
- * reallocates. The input string is set either by stealing the
- * passed pointer or by duplicating it depending on @steal.
- *
- * @param list: Pointer to the string list.
- * @param string: Null-terminated string to add.
- * @param steal: If true, take ownership of @string pointer (no copy).
- */
-static void strlst_add(StringList_t *list, const char *string, bool steal)
-{
-	if (!string)
-		return; /* Do nothing is string is NULL */
-
-	if (list->count == list->capacity) {
-		/* Reallocate to double capacity */
-		list->capacity *= 2;
-		list->strings = (const char **)realloc(list->strings,
-						       list->capacity * sizeof(char *));
-		for (size_t i = list->count; i < list->capacity; i++)
-			list->strings[i] = NULL;
-	}
-
-	/* Allocate memory for the new string and copy its content */
-	list->strings[list->count++] = steal ? string : safe_strdup(string);
-}
-
-/**
- * @brief Remove all strings from the list and free them.
- *
- * Frees each stored string and resets count to zero but leaves the
- * allocated array in place so the list can be reused.
- *
- * @param list: Pointer to the string list to clear.
- */
-static void strlst_clear(StringList_t *list)
-{
-	for (size_t i = 0; i < list->count; i++) {
-		free((void *)list->strings[i]);
-		list->strings[i] = NULL;
-	}
-
-	list->count = 0;
-}
-
-/**
- * @brief Free a StringList_t and its contents.
- *
- * Frees all stored strings and the internal array and resets the list
- * fields to indicate an empty/unallocated list.
- *
- * @param list: Pointer to the list to free.
- */
-static void strlst_free(StringList_t *list)
-{
-	strlst_clear(list);
-	free(list->strings);
-	list->strings = NULL;
-	list->capacity = 0;
-}
-
-/**
- * @brief Test if the string list is empty.
- *
- * @param list: Pointer to the string list.
- *
- * @return true if list contains no elements, false otherwise.
- */
-#define STRLST_EMPTY(list) ((list)->count == 0)
-
-/**
- * @brief Iterate over a StringList_t returning next element.
- *
- * @param sl:  Pointer to the string list.
- * @param s:   Pointer that gets updated with char* at current
- *             index or NULL if end reached.
- */
-#define STRLST_FOREACH(sl, s) \
-	for (size_t __str_next = 0; \
-	({ \
-		(s) = (__str_next >= (sl)->count) ? NULL : (sl)->strings[__str_next++]; \
-		(s) != NULL; \
-	});)
-
-/**
- * @brief Check whether a list contains a given string.
- *
- * Compares strings using strcmp (streq macro).
- *
- * @param list: Pointer to the string list.
- * @param s: String to search for.
- *
- * @return true if @s exists in the list, false otherwise.
- */
-static bool strlst_contains(const StringList_t *list, const char *s)
-{
-	const char *str;
-
-	STRLST_FOREACH(list, str) {
-		if (streq(s, str))
-			return true;
-	}
-	return false;
-}
-
-/**
- * @brief Load strings from a text file into a StringList_t.
- *
- * Reads the file line-by-line. For each line, trims whitespace and
- * skips empty lines or lines starting with '#'. Remaining lines are
- * added to @list.
- *
- * @param list: Pointer to the initialized StringList_t to append to.
- * @param filename: Path to the file to read. If NULL, the
- *                  function returns immediately.
- */
-static void strlst_load(StringList_t *list, const char *filename)
-{
-	char line[LINE_MAX];
-	FILE *f;
-
-	if (!filename)
-		return;
-
-	f = fopen(filename, "r");
-	if (!f) {
-		fprintf(stderr, "Warning: could not open file '%s'\n", filename);
-		return;
-	}
-
-	while (fgets(line, sizeof(line), f)) {
-		/* Strip whitespace and comments */
-		char *p = trim(line);
-
-		if (*p == '\0' || *p == '#')
-			continue;
-		strlst_add(list, p, false);
-	}
-
-	fclose(f);
-}
-
-/**
- * @brief Check whether a struct or struct member is excluded.
- *
- * The exclusion list may contain either struct names (to exclude the
- * whole struct) or entries of the form "StructName::member" to exclude
- * individual members.
- *
- * @param excl_list: Pointer to the exclusion StringList_t.
- * @param struct_name: Name of the struct being considered.
- * @param member_name: Name of the member (or NULL to check whole struct).
- *
- * @return true if the struct or member is present in the exclusion list,
- *         false otherwise.
- */
-static bool is_excluded(const StringList_t *excl_list,
-			const char         *struct_name,
-			const char         *member_name)
-{
-	char key[LINE_MAX];
-
-	/* First, check if the whole struct is excluded */
-	for (size_t i = 0; i < excl_list->count; i++) {
-		if (streq(excl_list->strings[i], struct_name))
-			return true; /* exclude entire struct */
-	}
-
-	if (!member_name)
-		return false;
-
-	/* Second, check if StructName::member is excluded */
-	snprintf(key, sizeof(key), "%s::%s", struct_name, member_name);
-	for (size_t i = 0; i < excl_list->count; i++) {
-		if (streq(excl_list->strings[i], key))
-			return true; /* exclude member of struct */
-	}
-
-	return false;
-}
-
-/**
- * @brief Decide whether a struct name is included by the include list.
- *
- * If the include list is empty, everything is considered included.
- *
- * @param incl_list: Pointer to inclusion StringList_t.
- * @param struct_name: Name of the struct to test.
- *
- * @return true if struct is included (or include list empty), false otherwise.
- */
-static bool is_included(const StringList_t *incl_list, const char *struct_name)
-{
-	/* Note: If include list is empty, then everything is included */
-	if (STRLST_EMPTY(incl_list))
-		return true;
-
-	return strlst_contains(incl_list, struct_name);
-}
-
-
-/******************************************************************************/
-
-
-typedef struct Conf {
-	bool             verbose;
-	const char       *c_fname;	/* Generated output *.c file name */
-	const char       *h_fname;	/* Generated output *.h file name */
-	const char       *l_fname;	/* Generated ou5tput *.ld file name */
-	const char       *prefix;	/* Prefix added to each functions */
-	StringList_t     hdr_files;	/* Input header file list */
-	StringList_t     incl_list;	/* Inclusion list (read from --incl) */
-	StringList_t     excl_list;	/* Enclusion list (read from --excl) */
-	struct {
-		regex_t  re_struct;	/* regex to match struct definitions */
-		regex_t  re_char_array;	/* regex to match char array struct members */
-		regex_t  re_member;	/* regex to match all other struct members */
-	} re;				/* Precompiled regular expressions */
-} Conf_t;
-
-
-/******************************************************************************/
-/**
- * The following structures are used to save the structs and members found
- * while parsing the header files (*.h). Here's the relationship between
- * the different objects.
- *
- * +--------------------------+
- * |        StructList_t      |
- * |--------------------------|
- * | StructInfo_t *items ---> [ array of StructInfo_t ]
- * | size_t count             |
- * | size_t capacity          |
- * +--------------------------+
- *               |
- *               v
- *     +--------------------------+
- *     |       StructInfo_t       |
- *     |--------------------------|
- *     | char *name               |
- *     | Member_t *members ---> [ array of Member_t ]
- *     | size_t count             |
- *     | size_t capacity          |
- *     +--------------------------+
- *                     |
- *                     v
- *          +--------------------------+
- *          |         Member_t         |
- *          |--------------------------|
- *          | char *type               |
- *          | char *name               |
- *          | char *array_size         |
- *          | bool is_char_array       |
- *          | bool is_const            |
- *          +--------------------------+
- */
-
-typedef struct Member {
-	char          *type;         /* Type of the struct member */
-	char          *name;         /* Name of the struct member */
-	char          *array_size;   /* If member is an array, what is its [size] */
-	bool          is_char_array; /* Whether the member is an array */
-	bool          is_const;      /* Whether the member is defined as const */
-} Member_t;
-
-typedef struct StructInfo {
-	char          *name;         /* Name of the struct */
-	Member_t      *members;      /* Array of struct members (each entry is one member) */
-	size_t        count;         /* Number of entries in members */
-	size_t        capacity;      /* Allocated capacity for members */
-} StructInfo_t;
-
-typedef struct StructList {
-	StructInfo_t  *items;        /* Array of structs (each entry corresponds to one struct) */
-	size_t        count;         /* Number of entries in items */
-	size_t        capacity;      /* Allocated capacity for items */
-} StructList_t;
-
-/**
- * @brief Initialize Member_t to default empty values.
- *
- * Sets pointer fields to NULL and booleans to false.
- *
- * @param m: Pointer to Member_t to initialize.
- */
-static void member_init(Member_t *m)
-{
-	m->type = NULL;
-	m->name = NULL;
-	m->array_size = NULL;
-	m->is_char_array = false;
-	m->is_const = false;
-}
-
-/**
- * @brief Free and reset Member_t fields.
- *
- * Frees any allocated strings in @m and reinitializes it.
- *
- * @param m: Pointer to Member_t to clear.
- */
-static void member_clear(Member_t *m)
-{
-	free(m->type);
-	free(m->name);
-	free(m->array_size);
-	member_init(m);
-}
-
-
-/**
- * @brief Initialize a StructInfo_t object with default capacity.
- *
- * Allocates the members array with default capacity
- * (MEMBERS_INITIAL_CAPACITY) and sets initial field values.
- *
- * @param si: Pointer to StructInfo_t to initialize.
- */
-#define MEMBERS_INITIAL_CAPACITY 8
-static void struct_info_init(StructInfo_t *si)
-{
-	si->name = NULL;
-	si->count = 0;
-	si->capacity = MEMBERS_INITIAL_CAPACITY;
-	si->members = malloc(si->capacity * sizeof(Member_t));
-	for (size_t m = 0; m < si->capacity; m++)
-		member_init(&si->members[m]);
-}
-
-/**
- * @brief Clear the contents (members and name) of a StructInfo_t.
- *
- * Frees per-member allocations and the name string, but leaves the
- * struct ready for reuse (members array kept).
- *
- * @param si: Pointer to StructInfo_t to clear.
- */
-static void struct_info_clear(StructInfo_t *si)
-{
-	for (size_t i = 0; i < si->count; ++i)
-		member_clear(&si->members[i]);
-	si->count = 0;
-	free(si->name);
-	si->name = NULL;
-}
-
-/**
- * @brief Free all resources used by a StructInfo_t.
- *
- * Frees members and the members array, resets pointers and capacity.
- *
- * @param si: Pointer to StructInfo_t to free.
- */
-static void struct_info_free(StructInfo_t *si)
-{
-	for (size_t i = 0; i < si->capacity; ++i)
-		member_clear(&si->members[i]);
-	si->count = 0;
-	free(si->members);
-	si->members = NULL;
-
-	free(si->name);
-	si->name = NULL;
-
-	si->capacity = 0;
-}
-
-/**
- * @brief Add a member to a StructInfo_t, growing the array if needed.
- *
- * Adds a new Member_t to @si. If capacity is insufficient the members
- * array is reallocated (doubled). The new Member_t's type and name are
- * set either by stealing the passed pointers or by duplicating them
- * depending on @steal_type/@steal_name.
- *
- * @param si: Pointer to StructInfo_t to append to.
- * @param type: String describing the member type.
- * @param name: Member name string.
- * @param steal_type: If true, take ownership of @type pointer (no copy).
- * @param steal_name: If true, take ownership of @name pointer (no copy).
- *
- * @return Pointer to the newly added Member_t.
- */
-static Member_t *struct_info_member_add(StructInfo_t *si,
-					char         *type,
-					char         *name,
-					bool         steal_type,
-					bool         steal_name)
-{
-	Member_t *m;
-
-	if (si->count == si->capacity) {
-		/* Reallocate to double capacity */
-		si->capacity *= 2;
-		si->members = (Member_t *)realloc(si->members, si->capacity * sizeof(Member_t));
-		for (size_t i = si->count; i < si->capacity; i++)
-			member_init(&si->members[i]);
-	}
-	m = &si->members[si->count++];
-	m->type = steal_type ? type : safe_strdup(type);
-	m->name = steal_name ? name : safe_strdup(name);
-	return m;
-}
-
-/**
- * @brief Test whether a StructInfo_t contains no members.
- *
- * @param si: Pointer to StructInfo_t.
- *
- * @return true if si has zero members, false otherwise.
- */
-#define STRUCT_INFO_EMPTY(si) ((si)->count == 0)
-
-
-/**
- * @brief Initialize a StructList_t with default capacity.
- *
- * Allocates the items array and initializes contained StructInfo_t
- * entries.
- *
- * @param sl: Pointer to StructList_t to initialize.
- */
-static void struct_list_init(StructList_t *sl)
-{
-	sl->count = 0;
-	sl->capacity = 16;
-	sl->items = malloc(sl->capacity * sizeof(StructInfo_t));
-	for (size_t i = 0; i < sl->capacity; i++)
-		struct_info_init(&sl->items[i]);
-}
-
-
-/**
- * @brief Clear all StructInfo_t elements in a StructList_t.
- *
- * Calls struct_info_clear on each existing item and resets count to 0.
- *
- * @param sl: Pointer to StructList_t to clear.
- */
-static void struct_list_clear(StructList_t *sl)
-{
-	for (size_t i = 0; i < sl->count; ++i)
-		struct_info_clear(&sl->items[i]);
-	sl->count = 0;
-}
-
-/**
- * @brief Free all resources used by a StructList_t.
- *
- * Frees each StructInfo_t and the items array and resets list fields.
- *
- * @param sl: Pointer to StructList_t to free.
- */
-static void struct_list_free(StructList_t *sl)
-{
-	for (size_t i = 0; i < sl->capacity; ++i)
-		struct_info_free(&sl->items[i]);
-	free(sl->items);
-	sl->items = NULL;
-	sl->count = 0;
-	sl->capacity = 0;
-}
-
-/**
- * @brief Add a new StructInfo_t entry to a StructList_t.
- *
- * If the list capacity is exhausted it doubles capacity and reallocates
- * the items array. The struct name is either stolen or duplicated
- * depending on @steal.
- *
- * @param sl: Pointer to StructList_t.
- * @param struct_name: Name of the struct to add.
- * @param steal: If true, take ownership of @struct_name pointer.
- *
- * @return Pointer to the newly added StructInfo_t.
- */
-static StructInfo_t *struct_list_struct_add(StructList_t *sl,
-					    char         *struct_name,
-					    bool         steal)
-{
-	StructInfo_t *si;
-
-	if (sl->count == sl->capacity) {
-		/* Reallocate to increase capacity */
-		sl->capacity *= 2; /* Double the capacity */
-		sl->items = (StructInfo_t *)realloc(sl->items,
-						    sl->capacity * sizeof(StructInfo_t));
-		for (size_t i = sl->count; i < sl->capacity; i++)
-			struct_info_init(&sl->items[i]);
-	}
-	si = &sl->items[sl->count++];
-	si->name = steal ? struct_name : safe_strdup(struct_name);
-	return si;
-}
-
-/**
- * @brief Test if a StructList_t contains no structs.
- *
- * @param sl: Pointer to StructList_t.
- *
- * @return true if no items present, false otherwise.
- */
-#define STRUCT_LIST_EMPTY(sl) ((sl)->count == 0)
-
-/**
- * @brief Parse C structs from a header text and populate StructList_t.
- *
- * Uses compiled regexes in @conf to find struct definitions in @text,
- * extracts member declarations and populates @sl with StructInfo_t
- * entries. Honors include/exclude lists in @conf.
- *
- * The function:
- *  - Clears @sl before parsing.
- *  - Iterates all regex matches for "struct ... { ... };" as defined by
- *    conf->re.re_struct.
- *  - Removes C comments and inline comments and tokenizes the struct
- *    body by newline to parse individual member declarations.
- *  - Supports char arrays and pointer-to-char members specially.
- *
- * @param sl: Pointer to StructList_t to populate (must be initialized).
- * @param text: Null-terminated text containing header content.
- * @param conf: Pointer to configuration containing regexes and lists.
- */
-static void struct_list_parse(StructList_t *sl, const char *text, Conf_t *conf)
-{
-	regmatch_t regmatch_struct[4];
-	const char *cursor;
-	int rc;
-
-	struct_list_clear(sl);
-
-	for (cursor = text,
-	     rc = regexec(&conf->re.re_struct, cursor, 4, regmatch_struct, 0);
-	     rc == 0;
-	     cursor += regmatch_struct[0].rm_eo,
-	     rc = regexec(&conf->re.re_struct, cursor, 4, regmatch_struct, 0)) {
-		struct StructInfo  *si;
-		char  *struct_name;
-		char  *body;
-		char  *line;
-
-		struct_name = regmatch_strdup(cursor, &regmatch_struct[1]);
-
-		if (is_excluded(&conf->excl_list, struct_name, NULL) ||
-		    !is_included(&conf->incl_list, struct_name)) {
-			free(struct_name);
-			continue;
-		}
-
-		si = struct_list_struct_add(sl, struct_name, true);
-
-		body = regmatch_strdup(cursor, &regmatch_struct[2]);
-		mask_c_comments(body);
-
-		/* Split struct body into lines */
-		for (line = strtok(body, "\n"); line != NULL; line = strtok(NULL, "\n")) {
-			regmatch_t  regmatch_member[5];
-			char  *trimmed_line;
-
-			trimmed_line = trim(trim_inline_comments(line));
-
-			if (trimmed_line[0] == '\0' ||        /* empty line */
-			    !strchr(trimmed_line, ';') ||     /* skip lines without semicolon */
-			    strstr(trimmed_line, "static") || /* skip static members */
-			    strstr(trimmed_line, "struct"))   /* skip struct members */
-				continue;
-
-			/* Look for char arrays. E.g. char buffer[10] */
-			if (regexec(&conf->re.re_char_array, trimmed_line, 5,
-				    regmatch_member, 0) == 0) {
-				char *name;
-				Member_t *m;
-
-				name = regmatch_strdup(trimmed_line, &regmatch_member[2]);
-				if (is_excluded(&conf->excl_list, struct_name, name)) {
-					free(name);
-					continue;
-				}
-				m = struct_info_member_add(si, "const char *", name, false, true);
-
-				m->is_char_array = true;
-				m->is_const = regmatch_startswith(trimmed_line,
-								  &regmatch_member[1], "const");
-				m->array_size = regmatch_strdup(trimmed_line, &regmatch_member[3]);
-
-				continue;
-			}
-
-			/* All other members */
-			if (regexec(&conf->re.re_member, trimmed_line, 5,
-				    regmatch_member, 0) == 0) {
-				Member_t *m;
-				bool is_ptr;
-				char *type;
-				char *name;
-
-				name = regmatch_strdup(trimmed_line, &regmatch_member[4]);
-				if (is_excluded(&conf->excl_list, struct_name, name)) {
-					free(name);
-					continue;
-				}
-
-				is_ptr = regmatch_contains_char(trimmed_line,
-								&regmatch_member[3], '*');
-				if (is_ptr) {
-					bool is_char =
-						regmatch_startswith(trimmed_line,
-								    &regmatch_member[2], "char");
-
-					/* Skip if we have a pointer, but it's not a "char *" */
-					if (!is_char) {
-						free(name);
-						continue;
-					}
-
-					/* type is used as the getter return type */
-					type = safe_strdup("const char *");
-				} else {
-					type = regmatch_strdup(trimmed_line, &regmatch_member[2]);
-				}
-
-				m = struct_info_member_add(si, type, name, true, true);
-				m->is_const = regmatch_startswith(trimmed_line,
-								  &regmatch_member[1], "const");
-			}
-		}
-		free(body);
-
-		if (conf->verbose && !STRUCT_INFO_EMPTY(si))
-			printf("Found struct: %s (%lu members)\n", si->name, si->count);
-	}
-}
-
-/**
- * @brief Iterate over a StructList_t returning next StructInfo_t*.
- *
- * @param sl: Pointer to the struct list.
- * @param si: Pointer that gets updated with StructInfo_t* at
- *            current index or NULL if end reached.
- */
-#define STRUCT_LIST_FOREACH(sl, si) \
-	for (size_t __si_next = 0; \
-	({ \
-		(si) = (__si_next >= (sl)->count) ? NULL : &(sl)->items[__si_next++]; \
-		(si) != NULL; \
-	});)
-
-/******************************************************************************/
-
-
-/**
- * @brief Generate header (.h) declarations for accessors of one struct.
- *
- * Writes function prototypes for setters and getters for every member
- * of @si to the provided output FILE (@generated_hdr).
- *
- * @param generated_hdr: FILE* to write header declarations to.
- * @param si: Pointer to StructInfo_t describing the struct and members.
- * @param conf: Pointer to Conf_t containing args and generation options.
- */
-static void generate_hdr(FILE  *generated_hdr, StructInfo_t  *si, Conf_t *conf)
-{
-	for (size_t m = 0; m < si->count; m++) {
-		Member_t  *members = &si->members[m];
-
-		/* Setter method */
-		if (!members->is_const) { /* No setter on const members */
-			if (members->is_char_array || streq(members->type, "const char *"))
-				fprintf(generated_hdr,
-					"void %s%s_%s_set(struct %s *p, const char *%s);\n",
-					conf->prefix, si->name,
-					members->name, si->name, members->name);
-			else
-				fprintf(generated_hdr,
-					"void %s%s_%s_set(struct %s *p, %s %s);\n",
-					conf->prefix, si->name,
-					members->name, si->name, members->type, members->name);
-		}
-
-		/* Getter method */
-		fprintf(generated_hdr, "%s %s%s_%s_get(const struct %s *p);\n\n",
-			members->type, conf->prefix, si->name, members->name, si->name);
-	}
-}
-
-/**
- * @brief Generate source (.c) implementations for accessors of one struct.
- *
- * Writes setter and getter function implementations for each member in
- * @si to the provided output FILE (@generated_src). Handles special
- * cases:
- *  - dynamic "const char *" members are strdup'd and freed on set.
- *  - fixed-size char arrays use strncpy and ensure NUL termination.
- *  - other members are assigned directly.
- *
- * @param generated_src: FILE* to write implementations to.
- * @param si: Pointer to the struct description.
- * @param conf: Pointer to Conf_t containing args and generation options.
- */
-static void generate_src(FILE  *generated_src, StructInfo_t  *si, Conf_t  *conf)
-{
-	for (size_t m = 0; m < si->count; m++) {
-		Member_t  *member = &si->members[m];
-
-		/* Setter method */
-		if (!member->is_const) {
-			if (!member->is_char_array && streq(member->type, "const char *")) {
-				/* dynamic string */
-				fprintf(generated_src,
-					"void %s%s_%s_set(struct %s *p, const char *%s) {\n"
-					"    free(p->%s);\n"
-					"    p->%s = %s ? strdup(%s) : NULL;\n"
-					"}\n\n",
-					conf->prefix, si->name, member->name,
-					si->name, member->name,
-					member->name,
-					member->name, member->name, member->name);
-			} else if (member->is_char_array) {
-				/* fixed-size array */
-				if (str_is_all_numbers(member->array_size)) {
-					unsigned long sz = strtoul(member->array_size, NULL, 10);
-
-					fprintf(generated_src,
-						"void %s%s_%s_set(struct %s *p, const char *%s) {\n"
-						"    strncpy(p->%s, %s, %lu);\n"
-						"    p->%s[%lu] = '\\0';\n"
-						"}\n\n",
-						conf->prefix, si->name, member->name,
-						si->name, member->name,
-						member->name, member->name, sz,
-						member->name, sz - 1);
-				} else {
-					fprintf(generated_src,
-						"void %s%s_%s_set(struct %s *p, const char *%s) {\n"
-						"    strncpy(p->%s, %s, %s);\n"
-						"    p->%s[%s - 1] = '\\0';\n"
-						"}\n\n",
-						conf->prefix, si->name, member->name,
-						si->name, member->name,
-						member->name, member->name, member->array_size,
-						member->name, member->array_size);
-				}
-			} else { /* numeric or struct */
-				fprintf(generated_src,
-					"void %s%s_%s_set(struct %s *p, %s %s) {\n"
-					"    p->%s = %s;\n"
-					"}\n\n",
-					conf->prefix, si->name, member->name, si->name,
-					member->type, member->name,
-					member->name, member->name);
-
-			}
-		}
-
-		/* Getter method */
-		fprintf(generated_src, "%s %s%s_%s_get(const struct %s *p) {\n"
-			"    return p->%s;\n"
-			"}\n\n",
-			member->type, conf->prefix, si->name, member->name, si->name,
-			member->name);
-	}
-}
-
-/**
- * @brief Generate linker script (.ld) implementations for accessors of
- * one struct.
- *
- * Writes linker entries for each member in @si to the provided output
- * FILE (@generated_ld). Handles special
- *
- * @param generated_ld: FILE* to write implementations to.
- * @param si: Pointer to the struct description.
- * @param conf: Pointer to Conf_t containing args and generation options.
- */
-static void generate_ld(FILE  *generated_ld, StructInfo_t  *si, Conf_t  *conf)
-{
-	for (size_t m = 0; m < si->count; m++) {
-		Member_t  *member = &si->members[m];
-
-		fprintf(generated_ld,
-				"\t\t%s%s_%s_get;\n"
-				"\t\t%s%s_%s_set;\n",
-				conf->prefix, si->name, member->name,
-				conf->prefix, si->name, member->name);
-	}
-}
-
-
-/******************************************************************************/
-
-
-/**
- * @brief Print usage information for this program.
- *
- * @param prog: Program name (argv[0]) used in the usage message.
- */
-static void print_usage(const char *prog)
-{
-	printf(
-		"Usage: %s [options] <header_file>\n"
-		"Options:\n"
-		"  -c, --c-out         Name of the generated *.c file. Default: %s\n"
-		"  -h, --h-out         Name of the generated *.h file. Default: %s\n"
-		"  -l, --ld-out        Name of the generated *.ld file. Default: %s\n"
-		"  -e, --excl <file>   Exclusion list. Which member of a struct to exclude (struct::member per line). Default: do not exclude anything\n"
-		"  -i, --incl <file>   Inclusion list. Which struct to include (struct name per line). Default: include every struct found\n"
-		"  -p, --prefix <str>  Prefix for generated function names\n"
-		"  -v, --verbose       Verbose output\n"
-		"  -H, --help          Show this message\n",
-		prog,
-		OUTPUT_FNAME_DEFAULT_C,
-		OUTPUT_FNAME_DEFAULT_H,
-		OUTPUT_FNAME_DEFAULT_LD
-	);
-}
-
-/**
- * @brief Parse command line arguments and populate a Conf_t.
- *
- * Uses getopt_long to process supported options and expands file
- * wildcards using glob(). Populates args->hdr_files with matched
- * header filenames. Initializes inclusion and exclusion lists
- * from --incl and --excl options.
- *
- * @param args: Pointer to Conf_t to initialize.
- * @param argc: Argument count from main().
- * @param argv: Argument vector from main().
- *
- * @note This function exits the process on fatal errors (missing files).
- */
-static void args_parse(Conf_t *conf, int argc, char *argv[])
-{
-	const char  *opt_excl_file = NULL;
-	const char  *opt_incl_file = NULL;
-	static const char  *optstr = "o:c:h:l:e:i:p:vH";
-	static struct option  longopts[] = {
-		{ "c-out",   required_argument, NULL, 'c' },
-		{ "h-out",   required_argument, NULL, 'h' },
-		{ "ld-out",  required_argument, NULL, 'l' },
-		{ "excl",    required_argument, NULL, 'e' },
-		{ "incl",    required_argument, NULL, 'i' },
-		{ "prefix",  required_argument, NULL, 'p' },
-		{ "verbose", no_argument,       NULL, 'v' },
-		{ "help",    no_argument,       NULL, 'H' },
-		{ NULL, 0, NULL, 0 }
-	};
-
-	conf->verbose = false;
-	conf->c_fname = OUTPUT_FNAME_DEFAULT_C;
-	conf->h_fname = OUTPUT_FNAME_DEFAULT_H;
-	conf->l_fname = OUTPUT_FNAME_DEFAULT_LD;
-	conf->prefix = "";
-
-	for (int opt = getopt_long(argc, argv, optstr, longopts, NULL);
-	     opt != -1;
-	     opt = getopt_long(argc, argv, optstr, longopts, NULL)) {
-		switch (opt) {
-		case 'c': conf->c_fname = optarg; break;
-		case 'h': conf->h_fname = optarg; break;
-		case 'l': conf->l_fname = optarg; break;
-		case 'e': opt_excl_file = optarg; break;
-		case 'i': opt_incl_file = optarg; break;
-		case 'p': conf->prefix  = optarg; break;
-		case 'v': conf->verbose = true;   break;
-		case 'H': print_usage(argv[0]);   exit(EXIT_SUCCESS);
-		default:  print_usage(argv[0]);   exit(EXIT_FAILURE);
-		}
-	}
-
-	/* Remaining arguments after options are file names or wildcards */
-	if (optind >= argc) {
-		fprintf(stderr, "Please specify header file(s) to parse\n");
-		exit(EXIT_FAILURE);
-	}
-
-	strlst_init(&conf->hdr_files, 16);
-	for (int i = optind; i < argc; ++i) {
-		glob_t  glob_result = { 0 };
-		int  ret = glob(argv[i], GLOB_TILDE|GLOB_NOCHECK, NULL, &glob_result);
-
-		if (ret == 0) {
-			for (size_t j = 0; j < glob_result.gl_pathc; ++j)
-				strlst_add(&conf->hdr_files,
-					   realpath(glob_result.gl_pathv[j], NULL), true);
-		} else {
-			fprintf(stderr, "Warning: No match for %s\n", argv[i]);
-		}
-		globfree(&glob_result);
-	}
-
-	strlst_init(&conf->incl_list, 16);
-	strlst_load(&conf->incl_list, opt_incl_file);
-
-	strlst_init(&conf->excl_list, 16);
-	strlst_load(&conf->excl_list, opt_excl_file);
-}
-
-/**
- * @brief Initialize Conf_t including regex compilation and loading lists.
- *
- * Parses command-line args via args_parse and compiles the regular
- * expressions used to parse structs and members.
- *
- * @param conf: Pointer to Conf_t to initialize.
- * @param argc: Argument count from main().
- * @param argv: Argument vector from main().
- */
-static void conf_init(Conf_t *conf, int argc, char *argv[])
-{
-	args_parse(conf, argc, argv);
-
-	regcomp(&conf->re.re_struct, STRUCT_RE, REG_EXTENDED);
-	regcomp(&conf->re.re_member, MEMBER_RE, REG_EXTENDED);
-	regcomp(&conf->re.re_char_array, CHAR_ARRAY_RE, REG_EXTENDED);
-}
-
-/**
- * @brief Free resources allocated in Conf_t.
- *
- * Frees include/exclude lists, releases compiled regexes and frees
- * argument-held resources via args_free.
- *
- * @param conf: Pointer to Conf_t to free.
- */
-static void conf_free(Conf_t *conf)
-{
-	strlst_free(&conf->hdr_files);
-	strlst_free(&conf->incl_list);
-	strlst_free(&conf->excl_list);
-
-	regfree(&conf->re.re_char_array);
-	regfree(&conf->re.re_member);
-	regfree(&conf->re.re_struct);
-}
-
-/**
- * @brief Appends the contents of one file to another.
- *
- * This function copies all data from the source file stream (`srce`)
- * to the destination file stream (`dest`).
- *
- * If `NVME_HAVE_SENDFILE` is defined, the function uses the `sendfile()` system
- * call for efficient data transfer between file descriptors. Otherwise, it falls
- * back to a standard character-by-character copy using `fgetc()` and `fputc()`.
- *
- * The source file position is reset to the beginning before copying.
- * The destination file is not closed or flushed beyond the initial `fflush()`
- * performed internally.
- *
- * @param dest:  Destination file stream to which data will be appended.
- * @param srce:  Source file stream whose contents will be copied.
- *
- * @note Both file streams must be opened before calling this function.
- *       The function assumes that `dest` is writable and `srce` is readable.
- *       On systems that support `sendfile()`, both files must also have valid
- *       file descriptors.
- *
- * @warning This function does not perform any error checking.
- *          If you require robust handling of I/O errors, you should modify
- *          the implementation accordingly.
- */
-static void append_file(FILE *dest, FILE *srce)
-{
-#ifdef NVME_HAVE_SENDFILE
-	/* Quick file copy using Linux's sendfile system-call */
-	off_t  offset;
-	long   bytes_to_copy;
-
-	/* Make sure any buffered data is written to the files before
-	 * copying. This is to avoid having missing data from @srce or
-	 * data being written out of sequence in @dest.
-	 */
-	fflush(dest);
-	fflush(srce);
-
-	/* Evaluate the size of the @srce file */
-	fseek(srce, 0, SEEK_END);
-	bytes_to_copy = ftell(srce);
-	rewind(srce);
-
-	offset = 0;
-	sendfile(fileno(dest), fileno(srce), &offset, bytes_to_copy);
-#else
-	/* Copy character-by-character */
-	int  c;
-
-	rewind(srce);
-	while ((c = fgetc(srce)) != EOF)
-		fputc(c, dest);
-#endif
-}
-
-/******************************************************************************/
-
-
-/**
- * @brief Main program entry point.
- *
- * Parses CLI, reads header files, discovers structs and members, and
- * generates accessor header/source files.
- *
- * @param argc: Argument count.
- * @param argv: Argument vector.
- *
- * @return EXIT_SUCCESS on success (exits the program), or exits with
- *         failure codes on errors encountered.
- */
-int main(int argc, char *argv[])
-{
-	StructList_t  sl;
-	StringList_t  files_to_include;
-	StringList_t  forward_declares;
-	const char    *struct_to_declare;
-	const char    *include_fname;
-	const char    *in_hdr;
-	char          *guard;
-	FILE          *generated_hdr = NULL;
-	FILE          *generated_src = NULL;
-	FILE          *generated_ld = NULL;
-	FILE          *tmp_hdr_code = NULL;
-	FILE          *tmp_src_code = NULL;
-	FILE          *tmp_ld_map = NULL;
-	Conf_t        conf;
-	int           dont_care;
-
-	(void)dont_care;
-
-	conf_init(&conf, argc, argv);
-
-	struct_list_init(&sl);
-	strlst_init(&files_to_include, 0);
-	strlst_init(&forward_declares, 0);
-
-	/* Creates temporary files to hold the generated code. */
-	tmp_hdr_code = tmpfile();
-	tmp_src_code = tmpfile();
-	tmp_ld_map = tmpfile();
-
-	STRLST_FOREACH(&conf.hdr_files, in_hdr) {
-		StructInfo_t *si;
-		const char   *in_hdr_fname = get_filename(in_hdr);
-
-		if (conf.verbose)
-			printf("\nProcessing %s\n", in_hdr);
-
-		char *text = read_file(in_hdr);
-
-		struct_list_parse(&sl, text, &conf);
-		free(text);
-
-		if (STRUCT_LIST_EMPTY(&sl)) {
-			if (conf.verbose) {
-				if (STRLST_EMPTY(&conf.incl_list))
-					printf("No structs found in %s.\n",
-					       in_hdr);
-				else
-					printf("Structs in %s are not in the include list.\n",
-					       in_hdr);
-			}
-			continue;
-		}
-
-		strlst_add(&files_to_include, in_hdr_fname, false);
-
-		STRUCT_LIST_FOREACH(&sl, si) {
-			if (STRUCT_INFO_EMPTY(si))
-				continue;
-
-			strlst_add(&forward_declares, si->name, false);
-
-			/* Generate code for the header file (*.h) */
-			fprintf(tmp_hdr_code,
-				"\n"
-				"/****************************************************************************\n"
-				" * Accessors for: struct %s\n"
-				" */\n", si->name);
-			generate_hdr(tmp_hdr_code, si, &conf);
-
-			/* Generate code for the source file (*.c) */
-			fprintf(tmp_src_code,
-				"\n"
-				"/****************************************************************************\n"
-				" * Accessors for: struct %s\n"
-				" */\n", si->name);
-			generate_src(tmp_src_code, si, &conf);
-
-			/* Generate entries for the linker script (*.ld) */
-			generate_ld(tmp_ld_map, si, &conf);
-		}
-	}
-
-	struct_list_free(&sl);
-
-	/* We've collected all the data we needed. Now let's generate some files. */
-
-	/***********************************************************************
-	 * First, output the generated header file.
-	 */
-
-	/* Add a guard in the generated header file that is made of
-	 * the UPPERCASE file name's stem. In other words, if the file
-	 * name is "accessors.h" then the guard should be "_ACCESSORS_H_"
-	 */
-	dont_care = asprintf(&guard, "_%s_", get_filename(conf.h_fname));
-	sanitize_identifier(to_uppercase(guard));
-
-	mkdir_fullpath(conf.h_fname, 0755); /* create output file's directory if needed */
-
-	generated_hdr = fopen(conf.h_fname, "w");
-	fprintf(generated_hdr,
-		"%s\n"
-		"#ifndef %s\n"
-		"#define %s\n"
-		"\n"
-		"#include <stdlib.h>\n"
-		"#include <string.h>\n"
-		"#include <stdbool.h>\n"
-		"#include <stdint.h>\n"
-		"#include <platform/types.h> /* __u32, __u64, etc. */\n"
-		"\n", banner, guard, guard);
-
-	fprintf(generated_hdr, "/* Forward declarations. These are internal (opaque) structs. */\n");
-	STRLST_FOREACH(&forward_declares, struct_to_declare)
-		fprintf(generated_hdr, "struct %s;\n", struct_to_declare);
-	strlst_free(&forward_declares);
-
-	/* Copy temporary file to output */
-	append_file(generated_hdr, tmp_hdr_code);
-	fclose(tmp_hdr_code);
-	fprintf(generated_hdr, "#endif /* %s */\n", guard);
-	fclose(generated_hdr);
-	free(guard);
-
-
-	/***********************************************************************
-	 * Second, output the generated source file.
-	 */
-
-	mkdir_fullpath(conf.c_fname, 0755); /* create output file's directory if needed */
-	generated_src = fopen(conf.c_fname, "w");
-	fprintf(generated_src,
-		"%s\n"
-		"#include <stdlib.h>\n"
-		"#include <string.h>\n"
-		"#include \"%s\"\n"
-		"\n", banner, get_filename(conf.h_fname));
-
-	STRLST_FOREACH(&files_to_include, include_fname)
-		fprintf(generated_src, "#include \"%s\"\n", include_fname);
-	strlst_free(&files_to_include);
-
-	/* Copy temporary file to output */
-	append_file(generated_src, tmp_src_code);
-	fclose(tmp_src_code);
-	fclose(generated_src);
-
-	/***********************************************************************
-	 * Third, output the linker script file.
-	 */
-	mkdir_fullpath(conf.l_fname, 0755); /* create output file's directory if needed */
-	generated_ld = fopen(conf.l_fname, "w");
-	fprintf(generated_ld,
-		"\n"
-		"LIBNVME_ACCESSORS_3_0 {\n"
-		"	global:\n");
-
-	/* Copy temporary file to output */
-	append_file(generated_ld, tmp_ld_map);
-
-	fprintf(generated_ld, "};\n");
-	fclose(tmp_ld_map);
-	fclose(generated_ld);
-
-	if (conf.verbose)
-		printf("\nGenerated %s and %s\n", conf.h_fname, conf.c_fname);
-
-	conf_free(&conf);
-
-	exit(EXIT_SUCCESS);
-}
-
diff --git a/libnvme/src/nvme/generate-accessors.md b/libnvme/src/nvme/generate-accessors.md
deleted file mode 100644
index 5286a6edf7..0000000000
--- a/libnvme/src/nvme/generate-accessors.md
+++ /dev/null
@@ -1,296 +0,0 @@
-# Generate Accessors Tool
-
-This tool generates **setter and getter functions** for C structs automatically.
- It supports dynamic strings, fixed-size char arrays, const fields, and exclusion/inclusion lists.
-
-------
-
-## Compilation / Testing
-
-```bash
-make
-make test
-```
-
-------
-
-## Usage
-
-```
-./generate-accessors [options] <header-files>
-```
-
-**Options:**
-
-| Short | Long        | Argument | Description                                                  |
-| ----- | ----------- | -------- | ------------------------------------------------------------ |
-| `-h`  | `--h-out`   | `<file>` | Output: Full path (incl. directories) of the *.h file to generate. |
-| `-c`  | `--c-out`   | `<file>` | Output: Full path (incl. directories) of the *.c file to generate. |
-| `-e`  | `--excl`    | `<file>` | Exclusion list file with `struct::member` per line           |
-| `-i`  | `--incl`    | `<file>` | Inclusion list file with `struct` per line. The list of `struct` to be included in the generation. When not specified, accessors will be generated for all `struct` found in the `header-file`. |
-| `-p`  | `--prefix`  | `<str>`  | Prefix for generated function names                          |
-| `-v`  | `--verbose` | none     | Verbose output showing which `struct` is being processed     |
-| `-H`  | `--help`    | none     | Show this help message                                       |
-
-------
-
-## Examples
-
-### Single Struct Example
-
-Header file `person.h`:
-
-```
-struct person {
-    char *name;
-    int age;
-    const char *id;
-};
-```
-
-Command:
-
-```
-./generate-accessors person.h
-```
-
-Generated `accessors.h`:
-
-```
-// SPDX-License-Identifier: LGPL-2.1-or-later
-/**
- * This file is part of libnvme.
- *
- *   ____                           _           _    ____          _
- *  / ___| ___ _ __   ___ _ __ __ _| |_ ___  __| |  / ___|___   __| | ___
- * | |  _ / _ \ '_ \ / _ \ '__/ _` | __/ _ \/ _` | | |   / _ \ / _` |/ _ \
- * | |_| |  __/ | | |  __/ | | (_| | ||  __/ (_| | | |__| (_) | (_| |  __/
- *  \____|\___|_| |_|\___|_|  \__,_|\__\___|\__,_|  \____\___/ \__,_|\___|
- *
- * Auto-generated struct member accessors (setter/getter)
- */
-
-#ifndef ACCESSORS_H
-#define ACCESSORS_H
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "structs.h"
-
-/****************************************************************************
- * Accessors for: struct person
- */
-void person_name_set(struct person *p, const char *name);
-const char * person_name_get(struct person *p);
-
-void person_age_set(struct person *p, int age);
-int person_age_get(struct person *p);
-
-int person_id_get(struct person *p);
-
-#endif /* ACCESSORS_H */
-
-```
-
-Generated `accessors.c`:
-
-```
-// SPDX-License-Identifier: LGPL-2.1-or-later
-/**
- * This file is part of libnvme.
- *
- *   ____                           _           _    ____          _
- *  / ___| ___ _ __   ___ _ __ __ _| |_ ___  __| |  / ___|___   __| | ___
- * | |  _ / _ \ '_ \ / _ \ '__/ _` | __/ _ \/ _` | | |   / _ \ / _` |/ _ \
- * | |_| |  __/ | | |  __/ | | (_| | ||  __/ (_| | | |__| (_) | (_| |  __/
- *  \____|\___|_| |_|\___|_|  \__,_|\__\___|\__,_|  \____\___/ \__,_|\___|
- *
- * Auto-generated struct member accessors (setter/getter)
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include "accessors.h"
-
-/****************************************************************************
- * Accessors for: struct person
- */
-void person_name_set(struct person *p, const char *name) {
-    free(p->name);
-    p->name = name ? strdup(name) : NULL;
-}
-
-const char * person_name_get(struct person *p) {
-    return p->name;
-}
-
-void person_age_set(struct person *p, int age) {
-    p->age = age;
-}
-
-int person_age_get(struct person *p) {
-    return p->age;
-}
-
-int person_id_get(struct person *p) {
-    return p->id;
-}
-```
-
-------
-
-### Multi-Struct Example
-
-Header file `example_structs.h`:
-
-```
-struct person {
-    char *name;
-    int age;
-    const char *id;
-};
-
-struct car {
-    char *model;
-    int year;
-    const char *vin;
-};
-```
-
-Command:
-
-```
-./generate-accessors --prefix my_ example_structs.h
-```
-
-Generated `accessors.h`:
-
-```
-// SPDX-License-Identifier: LGPL-2.1-or-later
-/**
- * This file is part of libnvme.
- *
- *   ____                           _           _    ____          _
- *  / ___| ___ _ __   ___ _ __ __ _| |_ ___  __| |  / ___|___   __| | ___
- * | |  _ / _ \ '_ \ / _ \ '__/ _` | __/ _ \/ _` | | |   / _ \ / _` |/ _ \
- * | |_| |  __/ | | |  __/ | | (_| | ||  __/ (_| | | |__| (_) | (_| |  __/
- *  \____|\___|_| |_|\___|_|  \__,_|\__\___|\__,_|  \____\___/ \__,_|\___|
- *
- * Auto-generated struct member accessors (setter/getter)
- */
-
-#ifndef ACCESSORS_H
-#define ACCESSORS_H
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "example_structs.h"
-
-/****************************************************************************
- * Accessors for: struct person
- */
-void my_person_name_set(struct person *p, const char *name);
-const char * my_person_name_get(struct person *p);
-
-void my_person_age_set(struct person *p, int age);
-int my_person_age_get(struct person *p);
-
-const char * my_person_id_get(struct person *p);
-
-
-/****************************************************************************
- * Accessors for: struct car
- */
-void my_car_model_set(struct car *p, const char *model);
-const char * my_car_model_get(struct car *p);
-
-void my_car_year_set(struct car *p, int year);
-int my_car_year_get(struct car *p);
-
-const char * my_car_vin_get(struct car *p);
-
-#endif /* ACCESSORS_H */
-
-```
-
-Generated `accessors.c`:
-
-```
-// SPDX-License-Identifier: LGPL-2.1-or-later
-/**
- * This file is part of libnvme.
- *
- *   ____                           _           _    ____          _
- *  / ___| ___ _ __   ___ _ __ __ _| |_ ___  __| |  / ___|___   __| | ___
- * | |  _ / _ \ '_ \ / _ \ '__/ _` | __/ _ \/ _` | | |   / _ \ / _` |/ _ \
- * | |_| |  __/ | | |  __/ | | (_| | ||  __/ (_| | | |__| (_) | (_| |  __/
- *  \____|\___|_| |_|\___|_|  \__,_|\__\___|\__,_|  \____\___/ \__,_|\___|
- *
- * Auto-generated struct member accessors (setter/getter)
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include "accessors.h"
-
-/****************************************************************************
- * Accessors for: struct person
- */
-void my_person_name_set(struct person *p, const char *name) {
-    free(p->name);
-    p->name = name ? strdup(name) : NULL;
-}
-
-const char * my_person_name_get(struct person *p) {
-    return p->name;
-}
-
-void my_person_age_set(struct person *p, int age) {
-    p->age = age;
-}
-
-int my_person_age_get(struct person *p) {
-    return p->age;
-}
-
-const char * my_person_id_get(struct person *p) {
-    return p->id;
-}
-
-/****************************************************************************
- * Accessors for: struct car
- */
-void my_car_model_set(struct car *p, const char *model) {
-    free(p->model);
-    p->model = model ? strdup(model) : NULL;
-}
-
-const char * my_car_model_get(struct car *p) {
-    return p->model;
-}
-
-void my_car_year_set(struct car *p, int year) {
-    p->year = year;
-}
-
-int my_car_year_get(struct car *p) {
-    return p->year;
-}
-
-const char * my_car_vin_get(struct car *p) {
-    return p->vin;
-}
-```
-
-------
-
-### Notes
-
-1. **Dynamic strings** (`char *`) are NULL-safe.
-2. **Const fields** generate **getter-only functions**.
-3. Numeric fields and other types have normal setters/getters.
-4. The `--prefix` option adds a custom prefix to all generated functions.
-5. The exclusion list (`--excl`) prevents generating accessors for specific `struct:member` pairs.
-7. The inclusion list (`--incl`) limits generation to only the listed `struct` names.
\ No newline at end of file
diff --git a/libnvme/src/nvme/ioctl.c b/libnvme/src/nvme/ioctl.c
index 1710ba287f..915b88eb79 100644
--- a/libnvme/src/nvme/ioctl.c
+++ b/libnvme/src/nvme/ioctl.c
@@ -8,21 +8,18 @@
  */
 #include <errno.h>
 #include <fcntl.h>
-#ifdef CONFIG_LIBURING
-#include <liburing.h>
-#endif
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
-#include <inttypes.h>
 
 #include <ccan/build_assert/build_assert.h>
-#include <ccan/minmax/minmax.h>
 #include <ccan/endian/endian.h>
+#include <ccan/minmax/minmax.h>
 
 #include <libnvme.h>
 
 #include "private.h"
+#include "compiler_attributes.h"
 
 #ifndef _WIN32
 static int nvme_verify_chr(struct nvme_transport_handle *hdl)
@@ -38,7 +35,7 @@ static int nvme_verify_chr(struct nvme_transport_handle *hdl)
 	return 0;
 }
 
-int nvme_subsystem_reset(struct nvme_transport_handle *hdl)
+__public int nvme_reset_subsystem(struct nvme_transport_handle *hdl)
 {
 	int ret;
 
@@ -52,7 +49,7 @@ int nvme_subsystem_reset(struct nvme_transport_handle *hdl)
 	return ret;
 }
 
-int nvme_ctrl_reset(struct nvme_transport_handle *hdl)
+__public int nvme_reset_ctrl(struct nvme_transport_handle *hdl)
 {
 	int ret;
 
@@ -66,7 +63,7 @@ int nvme_ctrl_reset(struct nvme_transport_handle *hdl)
 	return ret;
 }
 
-int nvme_ns_rescan(struct nvme_transport_handle *hdl)
+__public int nvme_rescan_ns(struct nvme_transport_handle *hdl)
 {
 	int ret;
 
@@ -80,7 +77,7 @@ int nvme_ns_rescan(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;
 
@@ -173,7 +170,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)
@@ -181,7 +178,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) {
@@ -201,339 +198,4 @@ int nvme_submit_admin_passthru(struct nvme_transport_handle *hdl,
 
 	return -ENOTSUP;
 }
-#endif
-
-static bool force_4k;
-
-__attribute__((constructor))
-static void nvme_init_env(void)
-{
-	char *val;
-
-	val = getenv("LIBNVME_FORCE_4K");
-	if (!val)
-		return;
-	if (!strcmp(val, "1") ||
-	    !strcasecmp(val, "true") ||
-	    !strncasecmp(val, "enable", 6))
-		force_4k = true;
-}
-
-#ifdef CONFIG_LIBURING
-enum {
-	IO_URING_NOT_AVAILABLE,
-	IO_URING_AVAILABLE,
-} io_uring_kernel_support = IO_URING_NOT_AVAILABLE;
-
-/*
- * gcc specific attribute, call automatically on the library loading.
- * if IORING_OP_URING_CMD is not supported, fallback to ioctl interface.
- *
- * The uring API expects the command of type struct nvme_passthru_cmd64.
- */
-__attribute__((constructor))
-static void nvme_uring_cmd_probe()
-{
-	struct io_uring_probe *probe = io_uring_get_probe();
-
-	if (!probe)
-		return;
-
-	if (!io_uring_opcode_supported(probe, IORING_OP_URING_CMD))
-		return;
-
-	io_uring_kernel_support = IO_URING_AVAILABLE;
-}
-
-static int nvme_uring_cmd_setup(struct io_uring *ring)
-{
-	if (io_uring_queue_init(NVME_URING_ENTRIES, ring,
-				   IORING_SETUP_SQE128 | IORING_SETUP_CQE32))
-		return -errno;
-	return 0;
-}
-
-static void nvme_uring_cmd_exit(struct io_uring *ring)
-{
-	io_uring_queue_exit(ring);
-}
-
-static int nvme_uring_cmd_admin_passthru_async(struct nvme_transport_handle *hdl,
-		struct io_uring *ring, struct nvme_passthru_cmd *cmd)
-{
-	struct io_uring_sqe *sqe;
-	int ret;
-
-	sqe = io_uring_get_sqe(ring);
-	if (!sqe)
-		return -1;
-
-	memcpy(&sqe->cmd, cmd, sizeof(*cmd));
-
-	sqe->fd = hdl->fd;
-	sqe->opcode = IORING_OP_URING_CMD;
-	sqe->cmd_op = NVME_URING_CMD_ADMIN;
-
-	ret = io_uring_submit(ring);
-	if (ret < 0)
-		return -errno;
-
-	return 0;
-}
-
-static int nvme_uring_cmd_wait_complete(struct io_uring *ring, int n)
-{
-	struct io_uring_cqe *cqe;
-	int ret, i;
-
-	for (i = 0; i < n; i++) {
-		ret = io_uring_wait_cqe(ring, &cqe);
-		if (ret < 0)
-			return -errno;
-		io_uring_cqe_seen(ring, cqe);
-	}
-
-	return 0;
-}
-
-static bool nvme_uring_is_usable(struct nvme_transport_handle *hdl)
-{
-	struct stat st;
-
-	if (io_uring_kernel_support != IO_URING_AVAILABLE ||
-	    hdl->type != NVME_TRANSPORT_HANDLE_TYPE_DIRECT ||
-	    nvme_fstat(hdl->fd, &st) || !S_ISCHR(st.st_mode))
-		return false;
-
-	return true;
-}
-#endif /* CONFIG_LIBURING */
-
-int nvme_get_log(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd, bool rae,
-		__u32 xfer_len)
-{
-	__u64 offset = 0, xfer, data_len = cmd->data_len;
-	__u64 start = (__u64)cmd->cdw13 << 32 | cmd->cdw12;
-	__u64 lpo;
-	void *ptr = (void *)(uintptr_t)cmd->addr;
-	int ret;
-	bool _rae;
-	__u32 numd;
-	__u16 numdu, numdl;
-	__u32 cdw10 = cmd->cdw10 & (NVME_VAL(LOG_CDW10_LID) |
-				    NVME_VAL(LOG_CDW10_LSP));
-	__u32 cdw11 = cmd->cdw11 & NVME_VAL(LOG_CDW11_LSI);
-#ifdef CONFIG_LIBURING
-	bool use_uring = nvme_uring_is_usable(hdl);
-	struct io_uring ring;
-	int n = 0;
-
-	if (use_uring) {
-		ret = nvme_uring_cmd_setup(&ring);
-		if (ret)
-			return ret;
-	}
-#endif /* CONFIG_LIBURING */
-
-	if (force_4k)
-		xfer_len = NVME_LOG_PAGE_PDU_SIZE;
-
-	/*
-	 * 4k is the smallest possible transfer unit, so restricting to 4k
-	 * avoids having to check the MDTS value of the controller.
-	 */
-	do {
-		if (!force_4k) {
-			xfer = data_len - offset;
-			if (xfer > xfer_len)
-				xfer  = xfer_len;
-		} else {
-			xfer = NVME_LOG_PAGE_PDU_SIZE;
-		}
-
-		/*
-		 * Always retain regardless of the RAE parameter until the very
-		 * last portion of this log page so the data remains latched
-		 * during the fetch sequence.
-		 */
-		lpo = start + offset;
-		numd = (xfer >> 2) - 1;
-		numdu = numd >> 16;
-		numdl = numd & 0xffff;
-		_rae = offset + xfer < data_len || rae;
-
-		cmd->cdw10 = cdw10 |
-			NVME_SET(!!_rae, LOG_CDW10_RAE) |
-			NVME_SET(numdl, LOG_CDW10_NUMDL);
-		cmd->cdw11 = cdw11 |
-			NVME_SET(numdu, LOG_CDW11_NUMDU);
-		cmd->cdw12 = lpo & 0xffffffff;
-		cmd->cdw13 = lpo >> 32;
-		cmd->data_len = xfer;
-		cmd->addr = (__u64)(uintptr_t)ptr;
-
-#ifdef CONFIG_LIBURING
-		if (use_uring) {
-			if (n >= NVME_URING_ENTRIES) {
-				ret = nvme_uring_cmd_wait_complete(&ring, n);
-				if (ret)
-					goto uring_exit;
-				n = 0;
-			}
-			n += 1;
-			ret = nvme_uring_cmd_admin_passthru_async(hdl,
-				&ring, cmd);
-			if (ret)
-				goto uring_exit;
-		} else {
-			ret = nvme_submit_admin_passthru(hdl, cmd);
-			if (ret)
-				return ret;
-		}
-#else /* CONFIG_LIBURING */
-		ret = nvme_submit_admin_passthru(hdl, cmd);
-#endif /* CONFIG_LIBURING */
-		if (ret)
-			return ret;
-
-		offset += xfer;
-		ptr += xfer;
-	} while (offset < data_len);
-
-#ifdef CONFIG_LIBURING
-	if (use_uring) {
-		ret = nvme_uring_cmd_wait_complete(&ring, n);
-uring_exit:
-		nvme_uring_cmd_exit(&ring);
-		if (ret)
-			return ret;
-	}
-#endif /* CONFIG_LIBURING */
-
-	return 0;
-}
-
-static int read_ana_chunk(struct nvme_transport_handle *hdl, enum nvme_log_ana_lsp lsp, bool rae,
-			  __u8 *log, __u8 **read, __u8 *to_read, __u8 *log_end)
-{
-	struct nvme_passthru_cmd cmd;
-
-	if (to_read > log_end)
-		return -ENOSPC;
-
-	while (*read < to_read) {
-		__u32 len = min_t(__u32, log_end - *read, NVME_LOG_PAGE_PDU_SIZE);
-		int ret;
-
-		nvme_init_get_log_ana(&cmd, lsp, *read - log, *read, len);
-		ret = nvme_get_log(hdl, &cmd, rae, NVME_LOG_PAGE_PDU_SIZE);
-		if (ret)
-			return ret;
-
-		*read += len;
-	}
-	return 0;
-}
-
-static int try_read_ana(struct nvme_transport_handle *hdl, enum nvme_log_ana_lsp lsp, bool rae,
-			struct nvme_ana_log *log, __u8 *log_end,
-			__u8 *read, __u8 **to_read, bool *may_retry)
-{
-	__u16 ngrps = le16_to_cpu(log->ngrps);
-
-	while (ngrps--) {
-		__u8 *group = *to_read;
-		int ret;
-		__le32 nnsids;
-
-		*to_read += sizeof(*log->descs);
-		ret = read_ana_chunk(hdl, lsp, rae,
-				     (__u8 *)log, &read, *to_read, log_end);
-		if (ret) {
-			/*
-			 * If the provided buffer isn't long enough,
-			 * the log page may have changed while reading it
-			 * and the computed length was inaccurate.
-			 * Have the caller check chgcnt and retry.
-			 */
-			*may_retry = ret == -ENOSPC;
-			return ret;
-		}
-
-		/*
-		 * struct nvme_ana_group_desc has 8-byte alignment
-		 * but the group pointer is only 4-byte aligned.
-		 * Don't dereference the misaligned pointer.
-		 */
-		memcpy(&nnsids,
-		       group + offsetof(struct nvme_ana_group_desc, nnsids),
-		       sizeof(nnsids));
-		*to_read += le32_to_cpu(nnsids) * sizeof(__le32);
-		ret = read_ana_chunk(hdl, lsp, rae,
-				     (__u8 *)log, &read, *to_read, log_end);
-		if (ret) {
-			*may_retry = ret == -ENOSPC;
-			return ret;
-		}
-	}
-
-	*may_retry = true;
-	return 0;
-}
-
-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)
-{
-	const enum nvme_log_ana_lsp lsp =
-		rgo ? NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY : 0;
-	/* Get Log Page can only fetch multiples of dwords */
-	__u8 * const log_end = (__u8 *)log + (*len & -4);
-	__u8 *read = (__u8 *)log;
-	__u8 *to_read;
-	int ret;
-
-	if (!retries)
-		return -EINVAL;
-
-	to_read = (__u8 *)log->descs;
-	ret = read_ana_chunk(hdl, lsp, rae,
-			     (__u8 *)log, &read, to_read, log_end);
-	if (ret)
-		return ret;
-
-	do {
-		bool may_retry = false;
-		int saved_ret;
-		int saved_errno;
-		__le64 chgcnt;
-
-		saved_ret = try_read_ana(hdl, lsp, rae, log, log_end,
-					 read, &to_read, &may_retry);
-		/*
-		 * If the log page was read with multiple Get Log Page commands,
-		 * chgcnt must be checked afterwards to ensure atomicity
-		 */
-		*len = to_read - (__u8 *)log;
-		if (*len <= NVME_LOG_PAGE_PDU_SIZE || !may_retry)
-			return saved_ret;
-
-		saved_errno = errno;
-		chgcnt = log->chgcnt;
-		read = (__u8 *)log;
-		to_read = (__u8 *)log->descs;
-		ret = read_ana_chunk(hdl, lsp, rae,
-				     (__u8 *)log, &read, to_read, log_end);
-		if (ret)
-			return ret;
-
-		if (log->chgcnt == chgcnt) {
-			/* Log hasn't changed; return try_read_ana() result */
-			errno = saved_errno;
-			return saved_ret;
-		}
-	} while (--retries);
-
-	return -EAGAIN;
-}
+#endif /* !_WIN32 */
\ No newline at end of file
diff --git a/libnvme/src/nvme/ioctl.h b/libnvme/src/nvme/ioctl.h
index 7c002d1852..197c94cd4b 100644
--- a/libnvme/src/nvme/ioctl.h
+++ b/libnvme/src/nvme/ioctl.h
@@ -26,11 +26,6 @@
  */
 #define NVME_LOG_PAGE_PDU_SIZE 4096
 
-/*
- * should not exceed CAP.MQES, 16 is rational for most ssd
- */
-#define NVME_URING_ENTRIES 16
-
 /**
  * nvme_submit_admin_passthru() - Submit an nvme passthrough admin command
  * @hdl:	Transport handle
@@ -58,7 +53,7 @@ int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
 		struct nvme_passthru_cmd *cmd);
 
 /**
- * nvme_subsystem_reset() - Initiate a subsystem reset
+ * nvme_reset_subsystem() - Initiate a subsystem reset
  * @hdl:	Transport handle
  *
  * This should only be sent to controller handles, not to namespaces.
@@ -66,27 +61,27 @@ int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
  * Return: Zero if a subsystem reset was initiated or -1 with errno set
  * otherwise.
  */
-int nvme_subsystem_reset(struct nvme_transport_handle *hdl);
+int nvme_reset_subsystem(struct nvme_transport_handle *hdl);
 
 /**
- * nvme_ctrl_reset() - Initiate a controller reset
+ * nvme_reset_ctrl() - Initiate a controller reset
  * @hdl:	Transport handle
  *
  * This should only be sent to controller handles, not to namespaces.
  *
  * Return: 0 if a reset was initiated or -1 with errno set otherwise.
  */
-int nvme_ctrl_reset(struct nvme_transport_handle *hdl);
+int nvme_reset_ctrl(struct nvme_transport_handle *hdl);
 
 /**
- * nvme_ns_rescan() - Initiate a controller rescan
+ * nvme_rescan_ns() - Initiate a controller rescan
  * @hdl:	Transport handle
  *
  * This should only be sent to controller handles, not to namespaces.
  *
  * Return: 0 if a rescan was initiated or -1 with errno set otherwise.
  */
-int nvme_ns_rescan(struct nvme_transport_handle *hdl);
+int nvme_rescan_ns(struct nvme_transport_handle *hdl);
 
 /**
  * nvme_get_nsid() - Retrieve the NSID from a namespace file descriptor
diff --git a/libnvme/src/nvme/json.c b/libnvme/src/nvme/json.c
index 84d0b94d6c..329c6e72ca 100644
--- a/libnvme/src/nvme/json.c
+++ b/libnvme/src/nvme/json.c
@@ -6,9 +6,9 @@
  * Authors: Hannes Reinecke <hare@suse.de>
  */
 
+#include <fcntl.h>
 #include <string.h>
 #include <unistd.h>
-#include <fcntl.h>
 
 #include <json.h>
 
@@ -60,10 +60,10 @@ static void json_update_attributes(nvme_ctrl_t c,
 		JSON_UPDATE_BOOL_OPTION(cfg, key_str,
 					concat, val_obj);
 		if (!strcmp("persistent", key_str) &&
-		    !nvme_ctrl_is_persistent(c))
+		    !nvme_ctrl_get_persistent(c))
 			nvme_ctrl_set_persistent(c, true);
 		if (!strcmp("discovery", key_str) &&
-		    !nvme_ctrl_is_discovery_ctrl(c))
+		    !nvme_ctrl_get_discovery_ctrl(c))
 			nvme_ctrl_set_discovery_ctrl(c, true);
 		if (!strcmp("keyring", key_str))
 			nvme_ctrl_set_keyring(c,
@@ -112,7 +112,7 @@ static void json_parse_port(nvme_subsystem_t s, struct json_object *port_obj)
 		nvme_ctrl_set_dhchap_host_key(c, json_object_get_string(attr_obj));
 	attr_obj = json_object_object_get(port_obj, "dhchap_ctrl_key");
 	if (attr_obj)
-		nvme_ctrl_set_dhchap_key(c, json_object_get_string(attr_obj));
+		nvme_ctrl_set_dhchap_ctrl_key(c, json_object_get_string(attr_obj));
 	attr_obj = json_object_object_get(port_obj, "keyring");
 	if (attr_obj)
 		nvme_ctrl_set_keyring(c, json_object_get_string(attr_obj));
@@ -175,7 +175,7 @@ static void json_parse_host(struct nvme_global_ctx *ctx, struct json_object *hos
 	h = nvme_lookup_host(ctx, hostnqn, hostid);
 	attr_obj = json_object_object_get(host_obj, "dhchap_key");
 	if (attr_obj)
-		nvme_host_set_dhchap_key(h, json_object_get_string(attr_obj));
+		nvme_host_set_dhchap_host_key(h, json_object_get_string(attr_obj));
 	attr_obj = json_object_object_get(host_obj, "hostsymname");
 	if (attr_obj)
 		nvme_host_set_hostsymname(h, json_object_get_string(attr_obj));
@@ -308,7 +308,7 @@ static void json_update_port(struct json_object *ctrl_array, nvme_ctrl_t c)
 	if (value)
 		json_object_object_add(port_obj, "dhchap_key",
 				       json_object_new_string(value));
-	value = nvme_ctrl_get_dhchap_key(c);
+	value = nvme_ctrl_get_dhchap_ctrl_key(c);
 	if (value)
 		json_object_object_add(port_obj, "dhchap_ctrl_key",
 				       json_object_new_string(value));
@@ -342,10 +342,10 @@ static void json_update_port(struct json_object *ctrl_array, nvme_ctrl_t c)
 	JSON_BOOL_OPTION(cfg, port_obj, hdr_digest);
 	JSON_BOOL_OPTION(cfg, port_obj, data_digest);
 	JSON_BOOL_OPTION(cfg, port_obj, concat);
-	if (nvme_ctrl_is_persistent(c))
+	if (nvme_ctrl_get_persistent(c))
 		json_object_object_add(port_obj, "persistent",
 				       json_object_new_boolean(true));
-	if (nvme_ctrl_is_discovery_ctrl(c))
+	if (nvme_ctrl_get_discovery_ctrl(c))
 		json_object_object_add(port_obj, "discovery",
 				       json_object_new_boolean(true));
 
@@ -356,7 +356,7 @@ static void json_update_subsys(struct json_object *subsys_array,
 			       nvme_subsystem_t s)
 {
 	nvme_ctrl_t c;
-	const char *subsysnqn = nvme_subsystem_get_nqn(s), *app;
+	const char *subsysnqn = nvme_subsystem_get_subsysnqn(s), *app;
 	struct json_object *subsys_obj = json_object_new_object();
 	struct json_object *port_array;
 
@@ -405,7 +405,7 @@ int json_update_config(struct nvme_global_ctx *ctx, int fd)
 		if (hostid)
 			json_object_object_add(host_obj, "hostid",
 					       json_object_new_string(hostid));
-		dhchap_key = nvme_host_get_dhchap_key(h);
+		dhchap_key = nvme_host_get_dhchap_host_key(h);
 		if (dhchap_key)
 			json_object_object_add(host_obj, "dhchap_key",
 					       json_object_new_string(dhchap_key));
@@ -475,7 +475,7 @@ static void json_dump_ctrl(struct json_object *ctrl_array, nvme_ctrl_t c)
 	if (value)
 		json_object_object_add(ctrl_obj, "dhchap_key",
 				       json_object_new_string(value));
-	value = nvme_ctrl_get_dhchap_key(c);
+	value = nvme_ctrl_get_dhchap_ctrl_key(c);
 	if (value)
 		json_object_object_add(ctrl_obj, "dhchap_ctrl_key",
 				       json_object_new_string(value));
@@ -512,10 +512,10 @@ static void json_dump_ctrl(struct json_object *ctrl_array, nvme_ctrl_t c)
 					       json_object_new_string(value));
 	}
 	JSON_BOOL_OPTION(cfg, ctrl_obj, concat);
-	if (nvme_ctrl_is_persistent(c))
+	if (nvme_ctrl_get_persistent(c))
 		json_object_object_add(ctrl_obj, "persistent",
 				       json_object_new_boolean(true));
-	if (nvme_ctrl_is_discovery_ctrl(c))
+	if (nvme_ctrl_get_discovery_ctrl(c))
 		json_object_object_add(ctrl_obj, "discovery",
 				       json_object_new_boolean(true));
 	json_object_array_add(ctrl_array, ctrl_obj);
@@ -602,7 +602,7 @@ static void json_dump_subsys(struct json_object *subsys_array,
 	json_object_object_add(subsys_obj, "name",
 			       json_object_new_string(nvme_subsystem_get_name(s)));
 	json_object_object_add(subsys_obj, "nqn",
-			       json_object_new_string(nvme_subsystem_get_nqn(s)));
+			       json_object_new_string(nvme_subsystem_get_subsysnqn(s)));
 
 	ns_array = json_object_new_array();
 	if (!json_dump_subsys_multipath(s, ns_array))
@@ -635,7 +635,7 @@ int json_dump_tree(struct nvme_global_ctx *ctx)
 		if (hostid)
 			json_object_object_add(host_obj, "hostid",
 					       json_object_new_string(hostid));
-		dhchap_key = nvme_host_get_dhchap_key(h);
+		dhchap_key = nvme_host_get_dhchap_host_key(h);
 		if (dhchap_key)
 			json_object_object_add(host_obj, "dhchap_key",
 					       json_object_new_string(dhchap_key));
diff --git a/libnvme/src/nvme/lib.c b/libnvme/src/nvme/lib.c
index 714b70ef44..49a0d4d2a4 100644
--- a/libnvme/src/nvme/lib.c
+++ b/libnvme/src/nvme/lib.c
@@ -7,14 +7,15 @@
  *	    Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
  */
 
+#include <fcntl.h>
+#include <libgen.h>
+#include <strings.h>
+
 #include <libnvme.h>
 
 #include "cleanup.h"
 #include "private.h"
-
-#include <libgen.h>
-#include <strings.h>
-#include <fcntl.h>
+#include "compiler_attributes.h"
 
 static bool nvme_mi_probe_enabled_default(void)
 {
@@ -30,7 +31,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;
@@ -60,7 +61,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;
@@ -78,20 +79,21 @@ void nvme_free_global_ctx(struct nvme_global_ctx *ctx)
 		nvme_mi_close(ep);
 	free(ctx->config_file);
 	free(ctx->application);
+	nvme_close_uring(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))
 {
@@ -100,7 +102,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))
@@ -110,7 +112,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))
 {
@@ -154,6 +156,11 @@ static int __nvme_transport_handle_open_direct(
 	if (c) {
 		if (!S_ISCHR(hdl->stat.st_mode))
 			return -EINVAL;
+		ret = __nvme_transport_handle_open_uring(hdl);
+		if (ret && ret != -ENOTSUP) {
+			close(hdl->fd);
+			return ret;
+		}
 	} else if (!S_ISBLK(hdl->stat.st_mode)) {
 		return -EINVAL;
 	}
@@ -196,7 +203,7 @@ struct nvme_transport_handle *__nvme_create_transport_handle(
 }
 
 #ifndef _WIN32
-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;
@@ -238,7 +245,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;
@@ -259,32 +266,32 @@ void nvme_close(struct nvme_transport_handle *hdl)
 }
 #endif /* !_WIN32 */
 
-nvme_fd_t nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl)
+__public nvme_fd_t 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/lib.h b/libnvme/src/nvme/lib.h
index 784cd647eb..92b426331d 100644
--- a/libnvme/src/nvme/lib.h
+++ b/libnvme/src/nvme/lib.h
@@ -8,7 +8,6 @@
  */
 #pragma once
 
-#include <stdio.h>
 #include <stdbool.h>
 
 #include "platform/includes.h"
diff --git a/libnvme/src/nvme/linux.c b/libnvme/src/nvme/linux.c
index 6dfaf10d43..f8913e7ea8 100644
--- a/libnvme/src/nvme/linux.c
+++ b/libnvme/src/nvme/linux.c
@@ -7,21 +7,23 @@
  * 	    Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
  */
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #include <errno.h>
-
+#include <fcntl.h>
 #ifndef _GNU_SOURCE
 #include <libgen.h>
 #endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
 
+#include <sys/ioctl.h>
 #include <sys/param.h>
 #include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
 
-#include <sys/ioctl.h>
+#ifndef _GNU_SOURCE
+#include <libgen.h>
+#endif
 
 #ifdef CONFIG_OPENSSL
 #include <openssl/evp.h>
@@ -45,6 +47,12 @@
 #include "base64.h"
 #include "cleanup.h"
 #include "private.h"
+#include "compiler_attributes.h"
+
+#define NVMF_HOSTID_SIZE	37
+
+#define NVMF_HOSTNQN_FILE	SYSCONFDIR "/nvme/hostnqn"
+#define NVMF_HOSTID_FILE	SYSCONFDIR "/nvme/hostid"
 
 static int __nvme_set_attr(const char *path, const char *value)
 {
@@ -102,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;
@@ -114,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);
 }
@@ -140,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)
@@ -585,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)
@@ -833,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,
@@ -871,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)
@@ -909,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;
@@ -924,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;
@@ -943,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;
@@ -954,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;
 
@@ -969,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;
@@ -988,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)
 {
@@ -1048,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;
@@ -1116,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,
@@ -1139,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,
@@ -1162,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)
 {
@@ -1288,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; "
@@ -1296,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; "
@@ -1311,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; "
@@ -1326,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)
 {
@@ -1335,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; "
@@ -1343,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,
@@ -1355,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,
@@ -1367,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)
 {
@@ -1386,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)
@@ -1408,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)
@@ -1458,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;
@@ -1472,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)
@@ -1541,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;
@@ -1559,3 +1567,241 @@ int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encoded_key,
 	*keyp = psk;
 	return 0;
 }
+
+static int uuid_from_device_tree(char *system_uuid)
+{
+	_cleanup_fd_ int f = -1;
+	ssize_t len;
+
+	f = open(nvme_uuid_ibm_filename(), O_RDONLY);
+	if (f < 0)
+		return -ENXIO;
+
+	memset(system_uuid, 0, NVME_UUID_LEN_STRING);
+	len = read(f, system_uuid, NVME_UUID_LEN_STRING - 1);
+	if (len < 0)
+		return -ENXIO;
+
+	return strlen(system_uuid) ? 0 : -ENXIO;
+}
+
+/*
+ * See System Management BIOS (SMBIOS) Reference Specification
+ * https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.2.0.pdf
+ */
+#define DMI_SYSTEM_INFORMATION	1
+
+static bool is_dmi_uuid_valid(const char *buf, size_t len)
+{
+	int i;
+
+	/* UUID bytes are from byte 8 to 23 */
+	if (len < 24)
+		return false;
+
+	/* Test it's a invalid UUID with all zeros */
+	for (i = 8; i < 24; i++) {
+		if (buf[i])
+			break;
+	}
+	if (i == 24)
+		return false;
+
+	return true;
+}
+
+static int uuid_from_dmi_entries(char *system_uuid)
+{
+	_cleanup_dir_ DIR *d = NULL;
+	const char *entries_dir = nvme_dmi_entries_dir();
+	int f;
+	struct dirent *de;
+	char buf[512] = {0};
+
+	system_uuid[0] = '\0';
+	d = opendir(entries_dir);
+	if (!d)
+		return -ENXIO;
+	while ((de = readdir(d))) {
+		char filename[PATH_MAX];
+		int len, type;
+
+		if (de->d_name[0] == '.')
+			continue;
+		sprintf(filename, "%s/%s/type", entries_dir, de->d_name);
+		f = open(filename, O_RDONLY);
+		if (f < 0)
+			continue;
+		len = read(f, buf, 512);
+		close(f);
+		if (len <= 0)
+			continue;
+		if (sscanf(buf, "%d", &type) != 1)
+			continue;
+		if (type != DMI_SYSTEM_INFORMATION)
+			continue;
+		sprintf(filename, "%s/%s/raw", entries_dir, de->d_name);
+		f = open(filename, O_RDONLY);
+		if (f < 0)
+			continue;
+		len = read(f, buf, 512);
+		close(f);
+		if (len <= 0)
+			continue;
+
+		if (!is_dmi_uuid_valid(buf, len))
+			continue;
+
+		/* Sigh. https://en.wikipedia.org/wiki/Overengineering */
+		/* DMTF SMBIOS 3.0 Section 7.2.1 System UUID */
+		sprintf(system_uuid,
+			"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-"
+			"%02x%02x%02x%02x%02x%02x",
+			(uint8_t)buf[8 + 3], (uint8_t)buf[8 + 2],
+			(uint8_t)buf[8 + 1], (uint8_t)buf[8 + 0],
+			(uint8_t)buf[8 + 5], (uint8_t)buf[8 + 4],
+			(uint8_t)buf[8 + 7], (uint8_t)buf[8 + 6],
+			(uint8_t)buf[8 + 8], (uint8_t)buf[8 + 9],
+			(uint8_t)buf[8 + 10], (uint8_t)buf[8 + 11],
+			(uint8_t)buf[8 + 12], (uint8_t)buf[8 + 13],
+			(uint8_t)buf[8 + 14], (uint8_t)buf[8 + 15]);
+		break;
+	}
+	return strlen(system_uuid) ? 0 : -ENXIO;
+}
+
+#define PATH_DMI_PROD_UUID  "/sys/class/dmi/id/product_uuid"
+
+/**
+ * uuid_from_product_uuid() - Get system UUID from product_uuid
+ * @system_uuid: Where to save the system UUID.
+ *
+ * Return: 0 on success, -ENXIO otherwise.
+ */
+static int uuid_from_product_uuid(char *system_uuid)
+{
+	_cleanup_file_ FILE *stream = NULL;
+	ssize_t nread;
+	_cleanup_free_ char *line = NULL;
+	size_t len = 0;
+
+	stream = fopen(PATH_DMI_PROD_UUID, "re");
+	if (!stream)
+		return -ENXIO;
+	system_uuid[0] = '\0';
+
+	nread = getline(&line, &len, stream);
+	if (nread != NVME_UUID_LEN_STRING)
+		return -ENXIO;
+
+	/* The kernel is handling the byte swapping according DMTF
+	 * SMBIOS 3.0 Section 7.2.1 System UUID */
+
+	memcpy(system_uuid, line, NVME_UUID_LEN_STRING - 1);
+	system_uuid[NVME_UUID_LEN_STRING - 1] = '\0';
+
+	return 0;
+}
+
+/**
+ * uuid_from_dmi() - read system UUID
+ * @system_uuid: buffer for the UUID
+ *
+ * The system UUID can be read from two different locations:
+ *
+ *     1) /sys/class/dmi/id/product_uuid
+ *     2) /sys/firmware/dmi/entries
+ *
+ * Note that the second location is not present on Debian-based systems.
+ *
+ * Return: 0 on success, negative errno otherwise.
+ */
+static int uuid_from_dmi(char *system_uuid)
+{
+	int ret = uuid_from_product_uuid(system_uuid);
+	if (ret != 0)
+		ret = uuid_from_dmi_entries(system_uuid);
+	return ret;
+}
+
+__public char *nvme_generate_hostid(void)
+{
+	int ret;
+	char uuid_str[NVME_UUID_LEN_STRING];
+	unsigned char uuid[NVME_UUID_LEN];
+
+	ret = uuid_from_dmi(uuid_str);
+	if (ret < 0)
+		ret = uuid_from_device_tree(uuid_str);
+	if (ret < 0) {
+		if (nvme_random_uuid(uuid) < 0)
+			memset(uuid, 0, NVME_UUID_LEN);
+		nvme_uuid_to_string(uuid, uuid_str);
+	}
+
+	return strdup(uuid_str);
+}
+
+__public char *nvme_generate_hostnqn_from_hostid(char *hostid)
+{
+	char *hid = NULL;
+	char *hostnqn;
+	int ret;
+
+	if (!hostid)
+		hostid = hid = nvme_generate_hostid();
+
+	ret = asprintf(&hostnqn, "nqn.2014-08.org.nvmexpress:uuid:%s", hostid);
+	free(hid);
+
+	return (ret < 0) ? NULL : hostnqn;
+}
+
+__public char *nvme_generate_hostnqn(void)
+{
+	return nvme_generate_hostnqn_from_hostid(NULL);
+}
+
+static char *nvmf_read_file(const char *f, int len)
+{
+	char buf[len];
+	_cleanup_fd_ int fd = -1;
+	int ret;
+
+	fd = open(f, O_RDONLY);
+	if (fd < 0)
+		return NULL;
+
+	memset(buf, 0, len);
+	ret = read(fd, buf, len - 1);
+
+	if (ret < 0 || !strlen(buf))
+		return NULL;
+	return strndup(buf, strcspn(buf, "\n"));
+}
+
+__public char *nvme_read_hostnqn(void)
+{
+	char *hostnqn = getenv("LIBNVME_HOSTNQN");
+
+	if (hostnqn) {
+		if (!strcmp(hostnqn, ""))
+			return NULL;
+		return strdup(hostnqn);
+	}
+
+	return nvmf_read_file(NVMF_HOSTNQN_FILE, NVMF_NQN_SIZE);
+}
+
+__public char *nvme_read_hostid(void)
+{
+	char *hostid = getenv("LIBNVME_HOSTID");
+
+	if (hostid) {
+		if (!strcmp(hostid, ""))
+			return NULL;
+		return strdup(hostid);
+	}
+
+	return nvmf_read_file(NVMF_HOSTID_FILE, NVMF_HOSTID_SIZE);
+}
diff --git a/libnvme/src/nvme/linux.h b/libnvme/src/nvme/linux.h
index 9070cbcda7..2816d4bef8 100644
--- a/libnvme/src/nvme/linux.h
+++ b/libnvme/src/nvme/linux.h
@@ -8,8 +8,8 @@
  */
 #pragma once
 
-#include <stddef.h>
 #include <stdbool.h>
+#include <stddef.h>
 
 #include <nvme/lib-types.h>
 
@@ -393,3 +393,55 @@ int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encoded_key,
 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 **key);
+
+/**
+ * nvme_generate_hostnqn() - Generate a machine specific host nqn
+ * Returns: An nvm namespace qualified name string based on the machine
+ * identifier, or NULL if not successful.
+ */
+char *nvme_generate_hostnqn(void);
+
+/**
+ * nvme_generate_hostnqn_from_hostid() - Generate a host nqn from
+ * host identifier
+ * @hostid:		Host identifier
+ *
+ * If @hostid is NULL, the function generates it based on the machine
+ * identifier.
+ *
+ * Return: On success, an NVMe Qualified Name for host identification. This
+ * name is based on the given host identifier. On failure, NULL.
+ */
+char *nvme_generate_hostnqn_from_hostid(char *hostid);
+
+/**
+ * nvme_generate_hostid() - Generate a machine specific host identifier
+ *
+ * Return: On success, an identifier string based on the machine identifier to
+ * be used as NVMe Host Identifier, or NULL on failure.
+ */
+char *nvme_generate_hostid(void);
+
+/**
+ * nvme_read_hostnqn() - Reads the host nvm qualified name from the config
+ *			      default location
+ *
+ * Retrieve the qualified name from the config file located in $SYSCONFDIR/nvme.
+ * $SYSCONFDIR is usually /etc.
+ *
+ * Return: The host nqn, or NULL if unsuccessful. If found, the caller
+ * is responsible to free the string.
+ */
+char *nvme_read_hostnqn(void);
+
+/**
+ * nvme_read_hostid() - Reads the host identifier from the config default
+ *			     location
+ *
+ * Retrieve the host idenditifer from the config file located in
+ * $SYSCONFDIR/nvme/. $SYSCONFDIR is usually /etc.
+ *
+ * Return: The host identifier, or NULL if unsuccessful. If found, the caller
+ *	   is responsible to free the string.
+ */
+char *nvme_read_hostid(void);
diff --git a/libnvme/src/nvme/log.c b/libnvme/src/nvme/log.c
index ab2473f316..aafe3894b4 100644
--- a/libnvme/src/nvme/log.c
+++ b/libnvme/src/nvme/log.c
@@ -8,18 +8,18 @@
  * This file implements basic logging functionality.
  */
 
-#include <sys/types.h>
-#include <stdio.h>
 #include <stdarg.h>
 #include <stdbool.h>
-#include "platform/includes.h"
 #include <time.h>
 
+#include "platform/includes.h"
+
 #include <libnvme.h>
 
 #include "cleanup.h"
 #define LOG_FUNCNAME 1
 #include "private.h"
+#include "compiler_attributes.h"
 
 #ifndef LOG_CLOCK
 #define LOG_CLOCK CLOCK_MONOTONIC
@@ -83,7 +83,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 +91,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/meson.build b/libnvme/src/nvme/meson.build
deleted file mode 100644
index bb88787037..0000000000
--- a/libnvme/src/nvme/meson.build
+++ /dev/null
@@ -1,78 +0,0 @@
-# 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>
-#
-# Run generate-accessors to generate the setter/getter functions.
-
-if is_windows
-    # Skip for now on Windows.  Accessor generation needs to be ported.
-    accessors_dep = dependency('', required: false)
-else
-    generated_h = 'accessors.h'
-    generated_c = 'accessors.c'
-    generated_ld = 'accessors.ld'
-
-    # List of header files to parse for structs
-    headers_to_scan = [
-        '../nvme/private.h',
-    ]
-
-    # Build the code generator tool
-    generate_accessors = executable(
-        'generate-accessors',
-        'generate-accessors.c',
-        c_args: ['-D_GNU_SOURCE'],
-        dependencies: [
-            config_dep,
-        ],
-        native: true,
-    )
-
-    # Generate accessors code
-    accessors_ch_custom_tgt = custom_target(
-        'accessors[.c.h.ld]',
-        input: files(headers_to_scan),
-        output: [
-            generated_h,
-            generated_c,
-            generated_ld,
-        ],
-        command: [
-            generate_accessors,
-            '--h-out', '@OUTPUT0@',
-            '--c-out', '@OUTPUT1@',
-            '--ld-out', '@OUTPUT2@',
-            '--incl', join_paths(meson.current_source_dir(), 'structs-to-include.txt'),
-            '@INPUT@',
-        ],
-        build_by_default: true,
-        install: true,
-        install_dir: [
-            get_option('includedir') / 'nvme',
-            false,
-            false,
-        ],
-        install_mode: 'rw-r--r--',
-    )
-
-    tgt_accessors_h = accessors_ch_custom_tgt[0]
-    tgt_accessors_c = accessors_ch_custom_tgt[1]
-    tgt_accessors_ld = accessors_ch_custom_tgt[2]
-
-    accessors_dep = declare_dependency(
-        sources: [
-            tgt_accessors_c,
-            tgt_accessors_h,
-        ],
-        include_directories: '.',
-    )
-
-    if meson.version().version_compare('>=1.4.0')
-        accessors_ld_full_path = tgt_accessors_ld.full_path()
-    else
-        accessors_ld_full_path = meson.current_build_dir() / generated_ld
-    endif
-endif
diff --git a/libnvme/src/nvme/mi-mctp.c b/libnvme/src/nvme/mi-mctp.c
index 65e8ddf624..56ab2910f8 100644
--- a/libnvme/src/nvme/mi-mctp.c
+++ b/libnvme/src/nvme/mi-mctp.c
@@ -7,10 +7,11 @@
  */
 
 #include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <fcntl.h>
 
 #include "platform/includes.h"
 
@@ -34,6 +35,7 @@
 #include <libnvme-mi.h>
 
 #include "private.h"
+#include "compiler_attributes.h"
 
 
 #if !defined(AF_MCTP)
@@ -669,7 +671,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;
@@ -939,7 +941,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;
@@ -1033,7 +1035,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 effb703701..9897c655aa 100644
--- a/libnvme/src/nvme/mi.c
+++ b/libnvme/src/nvme/mi.c
@@ -7,20 +7,20 @@
  */
 
 #include <errno.h>
-#include <stdlib.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <time.h>
 #include <unistd.h>
 
 #include <ccan/array_size/array_size.h>
-#include <ccan/minmax/minmax.h>
 #include <ccan/endian/endian.h>
+#include <ccan/minmax/minmax.h>
 
 #include <libnvme.h>
 #include <libnvme-mi.h>
 
 #include "private.h"
+#include "compiler_attributes.h"
 
 #define NUM_ENABLES    (256u)
 
@@ -297,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;
@@ -315,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;
 }
@@ -325,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;
 
@@ -343,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;
@@ -421,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)
@@ -569,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;
 
@@ -722,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,
@@ -888,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;
@@ -960,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,
@@ -1010,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;
@@ -1035,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;
@@ -1055,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;
@@ -1072,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;
@@ -1092,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;
@@ -1168,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;
@@ -1184,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;
 
@@ -1268,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;
 
@@ -1284,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;
@@ -1314,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;
 }
@@ -1358,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";
 
@@ -1526,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;
@@ -1635,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)
 {
@@ -1709,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)
@@ -1750,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;
@@ -1768,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 ||
@@ -1805,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 3db401dc53..b3fd851cf5 100644
--- a/libnvme/src/nvme/nbft.c
+++ b/libnvme/src/nvme/nbft.c
@@ -16,6 +16,7 @@
 #include <libnvme.h>
 
 #include "private.h"
+#include "compiler_attributes.h"
 
 #ifndef MIN
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
@@ -712,7 +713,7 @@ static int parse_raw_nbft(struct nvme_global_ctx *ctx, struct nbft_info *nbft)
 	return 0;
 }
 
-void nvme_nbft_free(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;
@@ -738,7 +739,7 @@ void nvme_nbft_free(struct nvme_global_ctx *ctx, struct nbft_info *nbft)
 	free(nbft);
 }
 
-int nvme_nbft_read(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;
@@ -802,7 +803,7 @@ int nvme_nbft_read(struct nvme_global_ctx *ctx, struct nbft_info **nbft,
 
 	if (parse_raw_nbft(ctx, *nbft)) {
 		nvme_msg(ctx, LOG_ERR, "Failed to parse %s\n", filename);
-		nvme_nbft_free(ctx, *nbft);
+		nvme_free_nbft(ctx, *nbft);
 		return -EINVAL;
 	}
 	return 0;
diff --git a/libnvme/src/nvme/nbft.h b/libnvme/src/nvme/nbft.h
index f0b1db5de1..7e2ff4c15f 100644
--- a/libnvme/src/nvme/nbft.h
+++ b/libnvme/src/nvme/nbft.h
@@ -9,9 +9,9 @@
 #pragma once
 
 #include <stdbool.h>
-#include <sys/types.h>
 
 #include <platform/types.h>
+#include <sys/types.h>
 
 #include <nvme/lib-types.h>
 
@@ -1234,23 +1234,34 @@ struct nbft_info {
 };
 
 /**
- * nvme_nbft_read() - Read and parse contents of an ACPI NBFT table
+ * nvme_read_nbft() - Read and parse contents of an ACPI NBFT table
  *
  * @ctx:      struct nvme_global_ctx object
  * @nbft:     Parsed NBFT table data.
  * @filename: Filename of the raw NBFT table to read.
  *
  * Read and parse the specified NBFT file into a struct nbft_info.
- * Free with nvme_nbft_free().
+ * Free with nvme_free_nbft().
  *
  * Return: 0 on success, errno otherwise.
  */
-int nvme_nbft_read(struct nvme_global_ctx *ctx, struct nbft_info **nbft,
+int nvme_read_nbft(struct nvme_global_ctx *ctx, struct nbft_info **nbft,
 		const char *filename);
 
 /**
- * nvme_nbft_free() - Free the struct nbft_info and its contents
+ * nvme_free_nbft() - Free the struct nbft_info and its contents
  * @ctx: struct nvme_global_ctx object
  * @nbft: Parsed NBFT table data.
  */
-void nvme_nbft_free(struct nvme_global_ctx *ctx, struct nbft_info *nbft);
+void nvme_free_nbft(struct nvme_global_ctx *ctx, struct nbft_info *nbft);
+
+/**
+ * struct nbft_file_entry - Linked list entry for NBFT files
+ * @next: Pointer to next entry
+ * @nbft: Pointer to NBFT info structure
+ */
+struct nbft_file_entry {
+	struct nbft_file_entry *next;
+	struct nbft_info *nbft;
+};
+
diff --git a/libnvme/src/nvme/no-json.c b/libnvme/src/nvme/no-json.c
index 0dc36cf694..1060c071c1 100644
--- a/libnvme/src/nvme/no-json.c
+++ b/libnvme/src/nvme/no-json.c
@@ -6,16 +6,16 @@
  * Authors: Daniel Wagner <dwagner@suse.de>
  */
 
-#include <libnvme.h>
-
 #include <errno.h>
 
+#include <libnvme.h>
+
 int json_read_config(struct nvme_global_ctx *ctx, const char *config_file)
 {
 	return -ENOTSUP;
 }
 
-int json_update_config(struct nvme_global_ctx *ctx, const char *config_file)
+int json_update_config(struct nvme_global_ctx *ctx, int fd)
 {
 	return -ENOTSUP;
 }
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index e19936182c..b7a3663d3c 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -7,8 +7,9 @@
  */
 #pragma once
 
+#include <platform/includes.h>
+
 #include <ccan/list/list.h>
-#include "platform/includes.h"
 
 #include <nvme/fabrics.h>
 #include <nvme/mi.h>
@@ -110,6 +111,7 @@ struct nvme_transport_handle {
 	struct stat stat;
 	bool ioctl_admin64;
 	bool ioctl_io64;
+	bool uring_enabled;
 
 	/* mi */
 	struct nvme_mi_ep *ep;
@@ -119,7 +121,7 @@ struct nvme_transport_handle {
 	struct nvme_log *log;
 };
 
-struct nvme_path {
+struct nvme_path { /*!generate-accessors*/
 	struct list_node entry;
 	struct list_node nentry;
 
@@ -131,7 +133,7 @@ struct nvme_path {
 	char *ana_state;
 	char *numa_nodes;
 	int grpid;
-	int queue_depth;
+	int queue_depth; //!accessors:none
 };
 
 struct nvme_ns_head {
@@ -141,7 +143,7 @@ struct nvme_ns_head {
 	char *sysfs_dir;
 };
 
-struct nvme_ns {
+struct nvme_ns { /*!generate-accessors*/
 	struct list_node entry;
 
 	struct nvme_subsystem *s;
@@ -152,7 +154,7 @@ struct nvme_ns {
 	struct nvme_transport_handle *hdl;
 	__u32 nsid;
 	char *name;
-	char *generic_name;
+	char *generic_name; //!accessors:none
 	char *sysfs_dir;
 
 	int lba_shift;
@@ -167,7 +169,7 @@ struct nvme_ns {
 	enum nvme_csi csi;
 };
 
-struct nvme_ctrl {
+struct nvme_ctrl { /*!generate-accessors*/
 	struct list_node entry;
 	struct list_head paths;
 	struct list_head namespaces;
@@ -175,31 +177,31 @@ struct nvme_ctrl {
 
 	struct nvme_global_ctx *ctx;
 	struct nvme_transport_handle *hdl;
-	char *name;
-	char *sysfs_dir;
-	char *address;
-	char *firmware;
-	char *model;
-	char *state;
-	char *numa_node;
-	char *queue_count;
-	char *serial;
-	char *sqsize;
-	char *transport;
-	char *subsysnqn;
-	char *traddr;
-	char *trsvcid;
-	char *dhchap_key;
+	char *name; //!accessors:readonly
+	char *sysfs_dir; //!accessors:readonly
+	char *address; //!accessors:none
+	char *firmware; //!accessors:readonly
+	char *model; //!accessors:readonly
+	char *state; //!accessors:none
+	char *numa_node; //!accessors:readonly
+	char *queue_count; //!accessors:readonly
+	char *serial; //!accessors:readonly
+	char *sqsize; //!accessors:readonly
+	char *transport; //!accessors:readonly
+	char *subsysnqn; //!accessors:readonly
+	char *traddr; //!accessors:readonly
+	char *trsvcid; //!accessors:readonly
+	char *dhchap_host_key;
 	char *dhchap_ctrl_key;
 	char *keyring;
 	char *tls_key_identity;
 	char *tls_key;
-	char *cntrltype;
-	char *cntlid;
-	char *dctype;
-	char *phy_slot;
-	char *host_traddr;
-	char *host_iface;
+	char *cntrltype; //!accessors:readonly
+	char *cntlid; //!accessors:readonly
+	char *dctype; //!accessors:readonly
+	char *phy_slot; //!accessors:readonly
+	char *host_traddr; //!accessors:readonly
+	char *host_iface; //!accessors:readonly
 	bool discovery_ctrl;
 	bool unique_discovery_ctrl;
 	bool discovered;
@@ -207,38 +209,38 @@ struct nvme_ctrl {
 	struct nvme_fabrics_config cfg;
 };
 
-struct nvme_subsystem {
+struct nvme_subsystem { /*!generate-accessors*/
 	struct list_node entry;
 	struct list_head ctrls;
 	struct list_head namespaces;
 	struct nvme_host *h;
 
-	char *name;
-	char *sysfs_dir;
-	char *subsysnqn;
-	char *model;
-	char *serial;
-	char *firmware;
-	char *subsystype;
+	char *name; /*!accessors:readonly*/
+	char *sysfs_dir; /*!accessors:readonly*/
+	char *subsysnqn; /*!accessors:readonly*/
+	char *model; /*!accessors:readonly*/
+	char *serial; /*!accessors:readonly*/
+	char *firmware; /*!accessors:readonly*/
+	char *subsystype; /*!accessors:readonly*/
 	char *application;
 	char *iopolicy;
 };
 
-struct nvme_host {
+struct nvme_host { /*!generate-accessors*/
 	struct list_node entry;
 	struct list_head subsystems;
 	struct nvme_global_ctx *ctx;
 
-	char *hostnqn;
-	char *hostid;
-	char *dhchap_key;
+	char *hostnqn; /*!accessors:readonly*/
+	char *hostid; /*!accessors:readonly*/
+	char *dhchap_host_key;
 	char *hostsymname;
-	bool pdc_enabled;
+	bool pdc_enabled; //!accessors:none
 	bool pdc_enabled_valid; /* set if pdc_enabled doesn't have an undefined
 				 * value */
 };
 
-struct nvme_fabric_options {
+struct nvme_fabric_options { /*!generate-accessors*/
 	bool cntlid;
 	bool concat;
 	bool ctrl_loss_tmo;
@@ -271,6 +273,12 @@ struct nvme_fabric_options {
 	bool trsvcid;
 };
 
+enum nvme_io_uring_state {
+	NVME_IO_URING_STATE_UNKNOWN = 0,
+	NVME_IO_URING_STATE_NOT_AVAILABLE,
+	NVME_IO_URING_STATE_AVAILABLE,
+};
+
 struct nvme_global_ctx {
 	char *config_file;
 	char *application;
@@ -283,51 +291,12 @@ struct nvme_global_ctx {
 	bool dry_run;
 	struct nvme_fabric_options *options;
 	struct ifaddrs *ifaddrs_cache; /* init with nvme_getifaddrs() */
-};
-
-struct nvmf_discovery_ctx {
-	/* defaults */
-	int default_max_discovery_retries;
-	int default_keep_alive_timeout;
-
-	void (*discovery_log)(struct nvmf_discovery_ctx *dctx,
-			bool connect,
-			struct nvmf_discovery_log *log,
-			uint64_t numrec, void *user_data);
-	void (*already_connected)(struct nvme_host *host,
-			struct nvmf_disc_log_entry *entry,
-			void *user_data);
-	bool (*decide_retry)(struct nvmf_discovery_ctx *dctx, int err,
-			void *user_data);
-	void (*connected)(struct nvmf_discovery_ctx *dctx, struct nvme_ctrl *c,
-			void *user_data);
-	int (*parser_init)(struct nvmf_discovery_ctx *dctx,
-			void *user_data);
-	void (*parser_cleanup)(struct nvmf_discovery_ctx *dctx,
-			void *user_data);
-	int (*parser_next_line)(struct nvmf_discovery_ctx *dctx,
-			void *user_data);
 
-	/* connfiguration */
-	bool persistent;
-	const char *device;
-	const char *subsysnqn;
-	const char *transport;
-	const char *traddr;
-	const char *host_traddr;
-	const char *host_iface;
-	const char *trsvcid;
-	const char *hostnqn;
-	const char *hostid;
-	const char *hostkey;
-	const char *ctrlkey;
-	const char *keyring;
-	const char *tls_key;
-	const char *tls_key_identity;
-	struct nvme_fabrics_config *cfg;
-	struct nvme_fabrics_config *defcfg;
-
-	void *user_data;
+	enum nvme_io_uring_state uring_state;
+#ifdef CONFIG_LIBURING
+	int ring_cmds;
+	struct io_uring *ring;
+#endif
 };
 
 struct nvmf_context {
@@ -384,15 +353,6 @@ struct nvmf_context {
 	void *user_data;
 };
 
-struct fabric_args {
-	const char *subsysnqn;
-	const char *transport;
-	const char *traddr;
-	const char *trsvcid;
-	const char *host_traddr;
-	const char *host_iface;
-};
-
 int nvme_set_attr(const char *dir, const char *attr, const char *value);
 
 int json_read_config(struct nvme_global_ctx *ctx, const char *config_file);
@@ -775,3 +735,40 @@ void nvme_ns_release_transport_handle(nvme_ns_t n);
  */
 int nvme_mi_admin_admin_passthru(struct nvme_transport_handle *hdl,
 		struct nvme_passthru_cmd *cmd);
+
+#ifdef CONFIG_LIBURING
+int nvme_open_uring(struct nvme_global_ctx *ctx);
+void nvme_close_uring(struct nvme_global_ctx *ctx);
+int __nvme_transport_handle_open_uring(struct nvme_transport_handle *hdl);
+int nvme_submit_admin_passthru_async(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd);
+int nvme_wait_complete_passthru(struct nvme_transport_handle *hdl);
+#else
+static inline int
+nvme_open_uring(struct nvme_global_ctx *ctx)
+{
+	return -ENOTSUP;
+}
+static inline void
+nvme_close_uring(struct nvme_global_ctx *ctx)
+{
+}
+static inline int
+__nvme_transport_handle_open_uring(struct nvme_transport_handle *hdl)
+{
+	hdl->ctx->uring_state = NVME_IO_URING_STATE_NOT_AVAILABLE;
+	return -ENOTSUP;
+}
+static inline int
+nvme_submit_admin_passthru_async(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
+{
+	return -ENOTSUP;
+}
+static inline int
+nvme_wait_complete_passthru(struct nvme_transport_handle *hdl)
+{
+	return -ENOTSUP;
+}
+#endif
+
diff --git a/libnvme/src/nvme/structs-to-include.txt b/libnvme/src/nvme/structs-to-include.txt
deleted file mode 100644
index 5167503b8c..0000000000
--- a/libnvme/src/nvme/structs-to-include.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-# SPDX-License-Identifier: LGPL-2.1-or-later
-
-nvme_path
-nvme_ns
-nvme_ctrl
-nvme_subsystem
-nvme_host
-nvme_fabric_options
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index 2c3b135dde..c0ab2fb9b1 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -8,12 +8,12 @@
  */
 #include <dirent.h>
 #include <errno.h>
+#include <fcntl.h>
+#include <libgen.h>
 #include <stdint.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <fcntl.h>
-#include <libgen.h>
 
 #include "platform/includes.h"
 
@@ -25,6 +25,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
@@ -114,7 +115,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)
 {
@@ -140,9 +141,9 @@ int nvme_host_get_ids(struct nvme_global_ctx *ctx,
 
 	/* /etc/nvme/hostid and/or /etc/nvme/hostnqn */
 	if (!hid)
-		hid = nvmf_hostid_from_file();
+		hid = nvme_read_hostid();
 	if (!hnqn)
-		hnqn = nvmf_hostnqn_from_file();
+		hnqn = nvme_read_hostnqn();
 
 	/* incomplete configuration, thus derive hostid from hostnqn */
 	if (!hid && hnqn)
@@ -153,7 +154,7 @@ int nvme_host_get_ids(struct nvme_global_ctx *ctx,
 	 * fails generate one
 	 */
 	if (!hid) {
-		hid = nvmf_hostid_generate();
+		hid = nvme_generate_hostid();
 		if (!hid)
 			return -ENOMEM;
 
@@ -163,7 +164,7 @@ int nvme_host_get_ids(struct nvme_global_ctx *ctx,
 
 	/* incomplete configuration, thus derive hostnqn from hostid */
 	if (!hnqn) {
-		hnqn = nvmf_hostnqn_generate_from_hostid(hid);
+		hnqn = nvme_generate_hostnqn_from_hostid(hid);
 		if (!hnqn)
 			return -ENOMEM;
 	}
@@ -184,7 +185,7 @@ int nvme_host_get_ids(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-int nvme_host_get(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;
@@ -268,7 +269,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;
@@ -319,7 +320,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;
 
@@ -341,22 +342,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;
@@ -365,88 +366,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;
 }
 
-const char *nvme_host_get_hostnqn(nvme_host_t h)
-{
-	return h->hostnqn;
-}
-
-const char *nvme_host_get_hostid(nvme_host_t h)
-{
-	return h->hostid;
-}
-
-const char *nvme_host_get_hostsymname(nvme_host_t h)
-{
-	return h->hostsymname;
-}
-
-void nvme_host_set_hostsymname(nvme_host_t h, const char *hostsymname)
-{
-	free(h->hostsymname);
-	h->hostsymname = NULL;
-
-	if (hostsymname)
-		h->hostsymname = strdup(hostsymname);
-}
-
-const char *nvme_host_get_dhchap_key(nvme_host_t h)
-{
-	return h->dhchap_key;
-}
-
-void nvme_host_set_dhchap_key(nvme_host_t h, const char *key)
-{
-	free(h->dhchap_key);
-	h->dhchap_key = NULL;
-
-	if (key)
-		h->dhchap_key = strdup(key);
-}
-
-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;
 
@@ -463,91 +426,37 @@ void nvme_root_release_fds(struct nvme_global_ctx *ctx)
 		nvme_host_release_fds(h);
 }
 
-const char *nvme_subsystem_get_nqn(nvme_subsystem_t s)
-{
-	return s->subsysnqn;
-}
-
-const char *nvme_subsystem_get_sysfs_dir(nvme_subsystem_t s)
-{
-	return s->sysfs_dir;
-}
-
-const char *nvme_subsystem_get_name(nvme_subsystem_t s)
-{
-	return s->name;
-}
-
-const char *nvme_subsystem_get_type(nvme_subsystem_t s)
-{
-	return s->subsystype;
-}
-
-const char *nvme_subsystem_get_application(nvme_subsystem_t s)
-{
-	return s->application;
-}
-
-void nvme_subsystem_set_application(nvme_subsystem_t s, const char *a)
-{
-	free(s->application);
-	s->application = NULL;
-
-	if (a)
-		s->application = strdup(a);
-}
-
-const char *nvme_subsystem_get_iopolicy(nvme_subsystem_t s)
-{
-	return s->iopolicy;
-}
-
-const char *nvme_subsystem_get_model(nvme_subsystem_t s)
-{
-	return s->model;
-}
-
-const char *nvme_subsystem_get_serial(nvme_subsystem_t s)
-{
-	return s->serial;
-}
-
-const char *nvme_subsystem_get_fw_rev(nvme_subsystem_t s)
-{
-	return s->firmware;
-}
-
-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;
 }
@@ -572,7 +481,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);
 }
@@ -601,7 +510,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;
@@ -616,7 +525,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)
 {
 }
 
@@ -665,7 +574,7 @@ struct nvme_subsystem *nvme_lookup_subsystem(struct nvme_host *h,
 	return nvme_alloc_subsystem(h, name, subsysnqn);
 }
 
-int nvme_subsystem_get(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)
 {
@@ -689,12 +598,12 @@ void __nvme_free_host(struct nvme_host *h)
 		__nvme_free_subsystem(s);
 	free(h->hostnqn);
 	free(h->hostid);
-	free(h->dhchap_key);
+	free(h->dhchap_host_key);
 	nvme_host_set_hostsymname(h, NULL);
 	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;
 
@@ -703,7 +612,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);
 }
@@ -852,7 +761,7 @@ static int nvme_scan_subsystem(struct nvme_global_ctx *ctx, const char *name)
 		 */
 		nvme_msg(ctx, LOG_DEBUG, "creating detached subsystem '%s'\n",
 			 name);
-		ret = nvme_host_get(ctx, NULL, NULL, &h);
+		ret = nvme_get_host(ctx, NULL, NULL, &h);
 		if (ret)
 			return ret;
 		s = nvme_alloc_subsystem(h, name, subsysnqn);
@@ -869,27 +778,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;
 }
 
-const char *nvme_path_get_sysfs_dir(nvme_path_t p)
-{
-	return p->sysfs_dir;
-}
-
-const char *nvme_path_get_name(nvme_path_t p)
-{
-	return p->name;
-}
-
-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;
 
@@ -901,16 +800,6 @@ int nvme_path_get_queue_depth(nvme_path_t p)
 	return p->queue_depth;
 }
 
-const char *nvme_path_get_ana_state(nvme_path_t p)
-{
-	return p->ana_state;
-}
-
-const char *nvme_path_get_numa_nodes(nvme_path_t p)
-{
-	return p->numa_nodes;
-}
-
 void nvme_free_path(struct nvme_path *p)
 {
 	list_del_init(&p->entry);
@@ -969,7 +858,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;
@@ -983,7 +872,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;
@@ -992,32 +881,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;
 }
 
-const char *nvme_ctrl_get_name(nvme_ctrl_t c)
-{
-	return c->name;
-}
-
-const char *nvme_ctrl_get_sysfs_dir(nvme_ctrl_t c)
-{
-	return c->sysfs_dir;
-}
-
-const char *nvme_ctrl_get_subsysnqn(nvme_ctrl_t c)
-{
-	return c->s ? c->s->subsysnqn : c->subsysnqn;
-}
-
-const char *nvme_ctrl_get_address(nvme_ctrl_t c)
-{
-	return c->address ? c->address : "";
-}
 
-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;
@@ -1043,22 +913,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_phy_slot(nvme_ctrl_t c)
-{
-	return c->phy_slot ? c->phy_slot : "";
-}
-
-const char *nvme_ctrl_get_firmware(nvme_ctrl_t c)
-{
-	return c->firmware;
-}
-
-const char *nvme_ctrl_get_model(nvme_ctrl_t c)
-{
-	return c->model;
-}
-
-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;
 
@@ -1067,172 +922,12 @@ const char *nvme_ctrl_get_state(nvme_ctrl_t c)
 	return c->state;
 }
 
-const char *nvme_ctrl_get_numa_node(nvme_ctrl_t c)
-{
-	return c->numa_node;
-}
-
-const char *nvme_ctrl_get_queue_count(nvme_ctrl_t c)
-{
-	return c->queue_count;
-}
-
-const char *nvme_ctrl_get_serial(nvme_ctrl_t c)
-{
-	return c->serial;
-}
-
-const char *nvme_ctrl_get_sqsize(nvme_ctrl_t c)
-{
-	return c->sqsize;
-}
-
-const char *nvme_ctrl_get_transport(nvme_ctrl_t c)
-{
-	return c->transport;
-}
-
-const char *nvme_ctrl_get_traddr(nvme_ctrl_t c)
-{
-	return c->traddr;
-}
-
-const char *nvme_ctrl_get_trsvcid(nvme_ctrl_t c)
-{
-	return c->trsvcid;
-}
-
-const char *nvme_ctrl_get_host_traddr(nvme_ctrl_t c)
-{
-	return c->host_traddr;
-}
-
-const char *nvme_ctrl_get_host_iface(nvme_ctrl_t c)
-{
-	return c->host_iface;
-}
-
-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;
 }
 
-const char *nvme_ctrl_get_dhchap_host_key(nvme_ctrl_t c)
-{
-	return c->dhchap_key;
-}
-
-const char *nvme_ctrl_get_cntlid(nvme_ctrl_t c)
-{
-	return c->cntlid;
-}
-
-void nvme_ctrl_set_dhchap_host_key(nvme_ctrl_t c, const char *key)
-{
-	free(c->dhchap_key);
-	c->dhchap_key = NULL;
-
-	if (key)
-		c->dhchap_key = strdup(key);
-}
-
-const char *nvme_ctrl_get_dhchap_key(nvme_ctrl_t c)
-{
-	return c->dhchap_ctrl_key;
-}
-
-void nvme_ctrl_set_dhchap_key(nvme_ctrl_t c, const char *key)
-{
-	free(c->dhchap_ctrl_key);
-	c->dhchap_ctrl_key = NULL;
-
-	if (key)
-		c->dhchap_ctrl_key = strdup(key);
-}
-
-const char *nvme_ctrl_get_keyring(nvme_ctrl_t c)
-{
-	return c->keyring;
-}
-
-void nvme_ctrl_set_keyring(nvme_ctrl_t c, const char *keyring)
-{
-	free(c->keyring);
-	c->keyring = NULL;
-
-	if (keyring)
-		c->keyring = strdup(keyring);
-}
-
-const char *nvme_ctrl_get_tls_key_identity(nvme_ctrl_t c)
-{
-	return c->tls_key_identity;
-}
-
-void nvme_ctrl_set_tls_key_identity(nvme_ctrl_t c, const char *identity)
-{
-	free(c->tls_key_identity);
-	c->tls_key_identity = NULL;
-
-	if (identity)
-		c->tls_key_identity = strdup(identity);
-}
-
-const char *nvme_ctrl_get_tls_key(nvme_ctrl_t c)
-{
-	return c->tls_key;
-}
-
-void nvme_ctrl_set_tls_key(nvme_ctrl_t c, const char *key)
-{
-	free(c->tls_key);
-	c->tls_key = NULL;
-
-	if (key)
-		c->tls_key = strdup(key);
-}
-
-void nvme_ctrl_set_discovered(nvme_ctrl_t c, bool discovered)
-{
-	c->discovered = discovered;
-}
-
-bool nvme_ctrl_is_discovered(nvme_ctrl_t c)
-{
-	return c->discovered;
-}
-
-void nvme_ctrl_set_persistent(nvme_ctrl_t c, bool persistent)
-{
-	c->persistent = persistent;
-}
-
-bool nvme_ctrl_is_persistent(nvme_ctrl_t c)
-{
-	return c->persistent;
-}
-
-void nvme_ctrl_set_discovery_ctrl(nvme_ctrl_t c, bool discovery)
-{
-	c->discovery_ctrl = discovery;
-}
-
-bool nvme_ctrl_is_discovery_ctrl(nvme_ctrl_t c)
-{
-	return c->discovery_ctrl;
-}
-
-void nvme_ctrl_set_unique_discovery_ctrl(nvme_ctrl_t c, bool unique)
-{
-	c->unique_discovery_ctrl = unique;
-}
-
-bool nvme_ctrl_is_unique_discovery_ctrl(nvme_ctrl_t c)
-{
-	return c->unique_discovery_ctrl;
-}
-
-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;
@@ -1241,22 +936,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;
 }
@@ -1275,7 +970,7 @@ void nvme_deconfigure_ctrl(nvme_ctrl_t c)
 	FREE_CTRL_ATTR(c->queue_count);
 	FREE_CTRL_ATTR(c->serial);
 	FREE_CTRL_ATTR(c->sqsize);
-	FREE_CTRL_ATTR(c->dhchap_key);
+	FREE_CTRL_ATTR(c->dhchap_host_key);
 	FREE_CTRL_ATTR(c->dhchap_ctrl_key);
 	FREE_CTRL_ATTR(c->keyring);
 	FREE_CTRL_ATTR(c->tls_key_identity);
@@ -1287,7 +982,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;
@@ -1304,7 +999,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;
@@ -1334,7 +1029,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);
 }
@@ -1356,7 +1051,14 @@ static bool traddr_is_hostname(const char *transport, const char *traddr)
 	return true;
 }
 
-int nvme_create_ctrl(struct nvme_global_ctx *ctx,
+__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;
+}
+
+__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,
@@ -1613,7 +1315,7 @@ static bool _tcp_match_ctrl(struct nvme_ctrl *c, struct candidate_args *candidat
 	if (!candidate->addreq(c->traddr, candidate->traddr))
 		return false;
 
-	if (candidate->well_known_nqn && !nvme_ctrl_is_discovery_ctrl(c))
+	if (candidate->well_known_nqn && !nvme_ctrl_get_discovery_ctrl(c))
 		return false;
 
 	if (candidate->subsysnqn && !streq0(c->subsysnqn, candidate->subsysnqn))
@@ -1659,7 +1361,7 @@ static bool _match_ctrl(struct nvme_ctrl *c, struct candidate_args *candidate)
 	    !streq0(c->trsvcid, candidate->trsvcid))
 		return false;
 
-	if (candidate->well_known_nqn && !nvme_ctrl_is_discovery_ctrl(c))
+	if (candidate->well_known_nqn && !nvme_ctrl_get_discovery_ctrl(c))
 		return false;
 
 	if (candidate->subsysnqn && !streq0(c->subsysnqn, candidate->subsysnqn))
@@ -1756,7 +1458,7 @@ nvme_ctrl_t __nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport,
 	return matching_c;
 }
 
-bool nvme_ctrl_config_match(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)
@@ -1888,8 +1590,7 @@ static int nvme_ctrl_lookup_subsystem_name(struct nvme_global_ctx *ctx,
 }
 
 static int nvme_ctrl_lookup_phy_slot(struct nvme_global_ctx *ctx,
-				     const char *address,
-				     char **slotp)
+				     nvme_ctrl_t c)
 {
 	const char *slots_sysfs_dir = nvme_slots_sysfs_dir();
 	_cleanup_free_ char *target_addr = NULL;
@@ -1898,7 +1599,7 @@ static int nvme_ctrl_lookup_phy_slot(struct nvme_global_ctx *ctx,
 	char *slot;
 	int ret;
 
-	if (!address)
+	if (!c->address)
 		return -EINVAL;
 
 	slots_dir = opendir(slots_sysfs_dir);
@@ -1908,7 +1609,7 @@ static int nvme_ctrl_lookup_phy_slot(struct nvme_global_ctx *ctx,
 		return -errno;
 	}
 
-	target_addr = strndup(address, 10);
+	target_addr = strndup(c->address, 10);
 	while ((entry = readdir(slots_dir))) {
 		if (entry->d_type == DT_DIR &&
 		    strncmp(entry->d_name, ".", 1) != 0 &&
@@ -1932,7 +1633,7 @@ static int nvme_ctrl_lookup_phy_slot(struct nvme_global_ctx *ctx,
 			if (!slot)
 				return -ENOMEM;
 
-			*slotp = slot;
+			c->phy_slot = slot;
 			return 0;
 		}
 	}
@@ -1950,7 +1651,7 @@ static void nvme_read_sysfs_dhchap(struct nvme_global_ctx *ctx, nvme_ctrl_t c)
 	}
 	if (host_key) {
 		nvme_ctrl_set_dhchap_host_key(c, NULL);
-		c->dhchap_key = host_key;
+		c->dhchap_host_key = host_key;
 	}
 
 	ctrl_key = nvme_get_ctrl_attr(c, "dhchap_ctrl_secret");
@@ -1959,7 +1660,7 @@ static void nvme_read_sysfs_dhchap(struct nvme_global_ctx *ctx, nvme_ctrl_t c)
 		ctrl_key = NULL;
 	}
 	if (ctrl_key) {
-		nvme_ctrl_set_dhchap_key(c, NULL);
+		nvme_ctrl_set_dhchap_ctrl_key(c, NULL);
 		c->dhchap_ctrl_key = ctrl_key;
 	}
 }
@@ -2045,14 +1746,14 @@ static int nvme_reconfigure_ctrl(struct nvme_global_ctx *ctx, nvme_ctrl_t c, con
 	c->cntrltype = nvme_get_ctrl_attr(c, "cntrltype");
 	c->cntlid = nvme_get_ctrl_attr(c, "cntlid");
 	c->dctype = nvme_get_ctrl_attr(c, "dctype");
-	nvme_ctrl_lookup_phy_slot(ctx, c->address, &c->phy_slot);
+	nvme_ctrl_lookup_phy_slot(ctx, c);
 	nvme_read_sysfs_dhchap(ctx, c);
 	nvme_read_sysfs_tls(ctx, c);
 
 	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;
@@ -2193,7 +1894,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;
@@ -2212,14 +1913,14 @@ int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name,
 
 	hostnqn = nvme_get_attr(path, "hostnqn");
 	hostid = nvme_get_attr(path, "hostid");
-	ret = nvme_host_get(ctx, hostnqn, hostid, &h);
+	ret = nvme_get_host(ctx, hostnqn, hostid, &h);
 	if (ret)
 		return ret;
 
 	host_key = nvme_get_attr(path, "dhchap_secret");
 	if (host_key && strcmp(host_key, "none")) {
-		free(h->dhchap_key);
-		h->dhchap_key = host_key;
+		free(h->dhchap_host_key);
+		h->dhchap_host_key = host_key;
 		host_key = NULL;
 	}
 	free(host_key);
@@ -2260,7 +1961,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)
@@ -2314,97 +2015,62 @@ 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;
 }
 
-int nvme_ns_get_nsid(nvme_ns_t n)
-{
-	return n->nsid;
-}
-
-const char *nvme_ns_get_sysfs_dir(nvme_ns_t n)
-{
-	return n->sysfs_dir;
-}
-
 const char *nvme_ns_head_get_sysfs_dir(nvme_ns_head_t head)
 {
 	return head->sysfs_dir;
 }
 
-const char *nvme_ns_get_name(nvme_ns_t n)
-{
-	return n->name;
-}
-
-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;
 }
 
-int nvme_ns_get_lba_size(nvme_ns_t n)
-{
-	return n->lba_size;
-}
-
-int nvme_ns_get_meta_size(nvme_ns_t n)
-{
-	return n->meta_size;
-}
-
-uint64_t nvme_ns_get_lba_count(nvme_ns_t n)
-{
-	return n->lba_count;
-}
-
-uint64_t nvme_ns_get_lba_util(nvme_ns_t n)
-{
-	return n->lba_util;
-}
-
-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;
@@ -2432,7 +2098,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;
@@ -2453,7 +2119,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;
@@ -2474,7 +2140,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;
@@ -2494,7 +2160,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;
@@ -2515,7 +2181,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;
@@ -2536,7 +2202,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;
@@ -2557,16 +2223,18 @@ 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;
 	int err;
 
 	err = nvme_ns_get_transport_handle(n, &hdl);
 	if (err)
 		return err;
 
-	return nvme_flush(hdl, nvme_ns_get_nsid(n));
+	nvme_init_flush(&cmd, nvme_ns_get_nsid(n));
+	return nvme_submit_io_passthru(hdl, &cmd);
 }
 
 static int nvme_strtou64(const char *str, void *res)
@@ -2846,7 +2514,7 @@ static int __nvme_scan_namespace(struct nvme_global_ctx *ctx,
 {
 	_cleanup_free_ char *blkdev = NULL;
 	_cleanup_free_ char *path = NULL;
-	struct nvme_ns *n;
+	struct nvme_ns *n = NULL;
 	int ret;
 
 	blkdev = nvme_ns_generic_to_blkdev(name);
@@ -2868,7 +2536,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);
@@ -2993,7 +2661,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/tree.h b/libnvme/src/nvme/tree.h
index dfc6f386ba..07b75677cd 100644
--- a/libnvme/src/nvme/tree.h
+++ b/libnvme/src/nvme/tree.h
@@ -91,21 +91,6 @@ nvme_host_t nvme_next_host(struct nvme_global_ctx *ctx, nvme_host_t h);
  */
 struct nvme_global_ctx *nvme_host_get_global_ctx(nvme_host_t h);
 
-/**
- * nvme_host_get_dhchap_key() - Return host key
- * @h:	Host for which the key should be returned
- *
- * Return: DH-HMAC-CHAP host key or NULL if not set
- */
-const char *nvme_host_get_dhchap_key(nvme_host_t h);
-
-/**
- * nvme_host_set_dhchap_key() - set host key
- * @h:		Host for which the key should be set
- * @key:	DH-HMAC-CHAP Key to set or NULL to clear existing key
- */
-void nvme_host_set_dhchap_key(nvme_host_t h, const char *key);
-
 /**
  * nvme_host_set_pdc_enabled() - Set Persistent Discovery Controller flag
  * @h:		Host for which the falg should be set
@@ -129,7 +114,7 @@ void nvme_host_set_pdc_enabled(nvme_host_t h, bool enabled);
 bool nvme_host_is_pdc_enabled(nvme_host_t h, bool fallback);
 
 /**
- * nvme_host_get() - Returns a host object
+ * nvme_get_host() - Returns a host object
  * @ctx:	struct nvme_global_ctx object
  * @hostnqn:	Host NQN (optional)
  * @hostid:	Host ID (optional)
@@ -140,7 +125,7 @@ bool nvme_host_is_pdc_enabled(nvme_host_t h, bool fallback);
  *
  * Return: 0 on success or negative error code otherwise
  */
-int nvme_host_get(struct nvme_global_ctx *ctx, const char *hostnqn,
+int nvme_get_host(struct nvme_global_ctx *ctx, const char *hostnqn,
 		const char *hostid, nvme_host_t *h);
 
 /**
@@ -196,7 +181,7 @@ nvme_subsystem_t nvme_first_subsystem(nvme_host_t h);
 nvme_subsystem_t nvme_next_subsystem(nvme_host_t h, nvme_subsystem_t s);
 
 /**
- * nvme_subsystem_get() - Returns nvme_subsystem_t object
+ * nvme_get_subsystem() - Returns nvme_subsystem_t object
  * @ctx:	struct nvme_global_ctx object
  * @h:		&nvme_host_t object
  * @name:	Name of the subsystem (may be NULL)
@@ -207,7 +192,7 @@ nvme_subsystem_t nvme_next_subsystem(nvme_host_t h, nvme_subsystem_t s);
  * and @subsysnqn or create one if not found.
  *
  */
-int nvme_subsystem_get(struct nvme_global_ctx *ctx,
+int nvme_get_subsystem(struct nvme_global_ctx *ctx,
 		struct nvme_host *h, const char *name,
 		const char *subsysnqn, struct nvme_subsystem **s);
 
@@ -296,7 +281,7 @@ nvme_path_t nvme_namespace_first_path(nvme_ns_t ns);
 nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p);
 
 /**
- * nvme_ctrl_config_match() - Check if ctrl @c matches config params
+ * nvme_ctrl_match_config() - Check if ctrl @c matches config params
  * @c:			An existing controller instance
  * @transport:		Transport name
  * @traddr:		Transport address
@@ -311,7 +296,7 @@ nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p);
  *
  * Return: true if there's a match, false otherwise.
  */
-bool nvme_ctrl_config_match(struct nvme_ctrl *c, const char *transport,
+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);
@@ -502,46 +487,6 @@ nvme_ns_t nvme_subsystem_next_ns(nvme_subsystem_t s, nvme_ns_t n);
 	for (p = nvme_namespace_first_path(n); p != NULL;	\
 		p = nvme_namespace_next_path(n, p))
 
-/**
- * nvme_ns_get_nsid() - NSID of a namespace
- * @n:	Namespace instance
- *
- * Return: NSID of @n
- */
-int nvme_ns_get_nsid(nvme_ns_t n);
-
-/**
- * nvme_ns_get_lba_size() - LBA size of a namespace
- * @n:	Namespace instance
- *
- * Return: LBA size of @n
- */
-int nvme_ns_get_lba_size(nvme_ns_t n);
-
-/**
- * nvme_ns_get_meta_size() - Metadata size of a namespace
- * @n:	Namespace instance
- *
- * Return: Metadata size of @n
- */
-int nvme_ns_get_meta_size(nvme_ns_t n);
-
-/**
- * nvme_ns_get_lba_count() - LBA count of a namespace
- * @n:	Namespace instance
- *
- * Return: LBA count of @n
- */
-uint64_t nvme_ns_get_lba_count(nvme_ns_t n);
-
-/**
- * nvme_ns_get_lba_util() - LBA utilization of a namespace
- * @n:	Namespace instance
- *
- * Return: LBA utilization of @n
- */
-uint64_t nvme_ns_get_lba_util(nvme_ns_t n);
-
 /**
  * nvme_ns_get_csi() - Command set identifier of a namespace
  * @n:	Namespace instance
@@ -575,22 +520,6 @@ const uint8_t *nvme_ns_get_nguid(nvme_ns_t n);
  */
 void nvme_ns_get_uuid(nvme_ns_t n, unsigned char out[NVME_UUID_LEN]);
 
-/**
- * nvme_ns_get_sysfs_dir() - sysfs directory of a namespace
- * @n:	Namespace instance
- *
- * Return: sysfs directory name of @n
- */
-const char *nvme_ns_get_sysfs_dir(nvme_ns_t n);
-
-/**
- * nvme_ns_get_name() - sysfs name of a namespace
- * @n:	Namespace instance
- *
- * Return: sysfs name of @n
- */
-const char *nvme_ns_get_name(nvme_ns_t n);
-
 /**
  * nvme_ns_get_generic_name() - Returns name of generic namespace chardev.
  * @n:	Namespace instance
@@ -742,38 +671,6 @@ int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns);
  */
 int nvme_ns_identify_descs(nvme_ns_t n, struct nvme_ns_id_desc *descs);
 
-/**
- * nvme_path_get_name() - sysfs name of an &nvme_path_t object
- * @p:	&nvme_path_t object
- *
- * Return: sysfs name of @p
- */
-const char *nvme_path_get_name(nvme_path_t p);
-
-/**
- * nvme_path_get_sysfs_dir() - sysfs directory of an nvme_path_t object
- * @p:	&nvme_path_t object
- *
- * Return: sysfs directory of @p
- */
-const char *nvme_path_get_sysfs_dir(nvme_path_t p);
-
-/**
- * nvme_path_get_ana_state() - ANA state of an nvme_path_t object
- * @p:	&nvme_path_t object
- *
- * Return: ANA (Asynchronous Namespace Access) state of @p
- */
-const char *nvme_path_get_ana_state(nvme_path_t p);
-
-/**
- * nvme_path_get_numa_nodes() - NUMA nodes of an nvme_path_t object
- * @p : &nvme_path_t object
- *
- * Return: NUMA nodes associated to @p
- */
-const char *nvme_path_get_numa_nodes(nvme_path_t p);
-
 /**
  * nvme_path_get_queue_depth() - Queue depth of an nvme_path_t object
  * @p: &nvme_path_t object
@@ -819,31 +716,6 @@ struct nvme_transport_handle *nvme_ctrl_get_transport_handle(nvme_ctrl_t c);
  */
 void nvme_ctrl_release_transport_handle(nvme_ctrl_t c);
 
-/**
- * nvme_ctrl_get_name() - sysfs name of a controller
- * @c:	Controller instance
- *
- * Return: sysfs name of @c
- */
-const char *nvme_ctrl_get_name(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_sysfs_dir() - sysfs directory of a controller
- * @c:	Controller instance
- *
- * Return: sysfs directory name of @c
- */
-const char *nvme_ctrl_get_sysfs_dir(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_address() - Address string of a controller
- * @c:	Controller instance
- *
- * Return: NVMe-over-Fabrics address string of @c or empty string
- * of no address is present.
- */
-const char *nvme_ctrl_get_address(nvme_ctrl_t c);
-
 /**
  * nvme_ctrl_get_src_addr() - Extract src_addr from the c->address string
  * @c:	Controller instance
@@ -854,31 +726,6 @@ const char *nvme_ctrl_get_address(nvme_ctrl_t c);
  */
 char *nvme_ctrl_get_src_addr(nvme_ctrl_t c, char *src_addr, size_t src_addr_len);
 
-/**
- * nvme_ctrl_get_phy_slot() - PCI physical slot number of a controller
- * @c:	Controller instance
- *
- * Return: PCI physical slot number of @c or empty string if slot
- * number is not present.
- */
-const char *nvme_ctrl_get_phy_slot(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_firmware() - Firmware string of a controller
- * @c:	Controller instance
- *
- * Return: Firmware string of @c
- */
-const char *nvme_ctrl_get_firmware(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_model() - Model of a controller
- * @c:	Controller instance
- *
- * Return: Model string of @c
- */
-const char *nvme_ctrl_get_model(nvme_ctrl_t c);
-
 /**
  * nvme_ctrl_get_state() - Running state of a controller
  * @c:	Controller instance
@@ -887,54 +734,6 @@ const char *nvme_ctrl_get_model(nvme_ctrl_t c);
  */
 const char *nvme_ctrl_get_state(nvme_ctrl_t c);
 
-/**
- * nvme_ctrl_get_numa_node() - NUMA node of a controller
- * @c:	Controller instance
- *
- * Return: String indicating the NUMA node
- */
-const char *nvme_ctrl_get_numa_node(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_queue_count() - Queue count of a controller
- * @c:	Controller instance
- *
- * Return: Queue count of @c
- */
-const char *nvme_ctrl_get_queue_count(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_serial() - Serial number of a controller
- * @c:	Controller instance
- *
- * Return: Serial number string of @c
- */
-const char *nvme_ctrl_get_serial(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_sqsize() - SQ size of a controller
- * @c:	Controller instance
- *
- * Return: SQ size (as string) of @c
- */
-const char *nvme_ctrl_get_sqsize(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_transport() - Transport type of a controller
- * @c:	Controller instance
- *
- * Return: Transport type of @c
- */
-const char *nvme_ctrl_get_transport(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_subsysnqn() - Subsystem NQN of a controller
- * @c:	Controller instance
- *
- * Return: Subsystem NQN of @c
- */
-const char *nvme_ctrl_get_subsysnqn(nvme_ctrl_t c);
-
 /**
  * nvme_ctrl_get_subsystem() - Parent subsystem of a controller
  * @c:	Controller instance
@@ -943,69 +742,6 @@ const char *nvme_ctrl_get_subsysnqn(nvme_ctrl_t c);
  */
 nvme_subsystem_t nvme_ctrl_get_subsystem(nvme_ctrl_t c);
 
-/**
- * nvme_ctrl_get_traddr() - Transport address of a controller
- * @c:	Controller instance
- *
- * Return: Transport address of @c
- */
-const char *nvme_ctrl_get_traddr(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_trsvcid() - Transport service identifier of a controller
- * @c:	Controller instance
- *
- * Return: Transport service identifier of @c (if present)
- */
-const char *nvme_ctrl_get_trsvcid(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_host_traddr() - Host transport address of a controller
- * @c:	Controller instance
- *
- * Return: Host transport address of @c (if present)
- */
-const char *nvme_ctrl_get_host_traddr(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_host_iface() - Host interface name of a controller
- * @c:	Controller instance
- *
- * Return: Host interface name of @c (if present)
- */
-const char *nvme_ctrl_get_host_iface(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_get_dhchap_host_key() - Return host key
- * @c:	Controller to be checked
- *
- * Return: DH-HMAC-CHAP host key or NULL if not set
- */
-const char *nvme_ctrl_get_dhchap_host_key(nvme_ctrl_t c);
-
-/**
- *  nvme_ctrl_get_cntlid() - Controller id
- *  @c:	Controller to be checked
- *
- *  Return : Controller id of @c
- */
-const char *nvme_ctrl_get_cntlid(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_set_dhchap_host_key() - Set host key
- * @c:		Host for which the key should be set
- * @key:	DH-HMAC-CHAP Key to set or NULL to clear existing key
- */
-void nvme_ctrl_set_dhchap_host_key(nvme_ctrl_t c, const char *key);
-
-/**
- * nvme_ctrl_get_dhchap_key() - Return controller key
- * @c:	Controller for which the key should be set
- *
- * Return: DH-HMAC-CHAP controller key or NULL if not set
- */
-const char *nvme_ctrl_get_dhchap_key(nvme_ctrl_t c);
-
 /**
  * nvme_ns_head_get_sysfs_dir() - sysfs dir of namespave head
  * @head: namespace head instance
@@ -1014,58 +750,6 @@ const char *nvme_ctrl_get_dhchap_key(nvme_ctrl_t c);
  */
 const char *nvme_ns_head_get_sysfs_dir(nvme_ns_head_t head);
 
-/**
- * nvme_ctrl_set_dhchap_key() - Set controller key
- * @c:		Controller for which the key should be set
- * @key:	DH-HMAC-CHAP Key to set or NULL to clear existing key
- */
-void nvme_ctrl_set_dhchap_key(nvme_ctrl_t c, const char *key);
-
-/**
- * nvme_ctrl_get_keyring() - Return keyring
- * @c:	Controller to be used for the lookup
- *
- * Return: Keyring or NULL if not set
- */
-const char *nvme_ctrl_get_keyring(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_set_keyring() - Set keyring
- * @c:		Controller for which the keyring should be set
- * @keyring:	Keyring name
- */
-void nvme_ctrl_set_keyring(nvme_ctrl_t c, const char *keyring);
-
-/**
- * nvme_ctrl_get_tls_key_identity() - Return Derive TLS Identity
- * @c:		Controller to be used for the lookup
- *
- * Return: Derive TLS Identity or NULL if not set
- */
-const char *nvme_ctrl_get_tls_key_identity(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_set_tls_key_identity() - Set Derive TLS Identity
- * @c:		Controller for which the key should be set
- * @identity:	Derive TLS identity or NULL to clear existing key
- */
-void nvme_ctrl_set_tls_key_identity(nvme_ctrl_t c, const char *identity);
-
-/**
- * nvme_ctrl_get_tls_key() - Return Derive TLS PSK
- * @c:		Controller to be used for the lookup
- *
- * Return: Key in PSK interchange format or NULL if not set
- */
-const char *nvme_ctrl_get_tls_key(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_set_tls_key() - Set Derive TLS PSK
- * @c:		Controller for which the key should be set
- * @key:	Key in interchange format or NULL to clear existing key
- */
-void nvme_ctrl_set_tls_key(nvme_ctrl_t c, const char *key);
-
 /**
  * nvme_ctrl_get_config() - Fabrics configuration of a controller
  * @c:	Controller instance
@@ -1074,81 +758,6 @@ void nvme_ctrl_set_tls_key(nvme_ctrl_t c, const char *key);
  */
 struct nvme_fabrics_config *nvme_ctrl_get_config(nvme_ctrl_t c);
 
-/**
- * nvme_ctrl_set_discovered() - Set the 'discovered' flag
- * @c:		nvme_ctrl_t object
- * @discovered:	Value of the 'discovered' flag
- *
- * Set the 'discovered' flag of @c to @discovered
- */
-void nvme_ctrl_set_discovered(nvme_ctrl_t c, bool discovered);
-
-/**
- * nvme_ctrl_is_discovered() - Returns the value of the 'discovered' flag
- * @c:	Controller instance
- *
- * Return: Value of the 'discovered' flag of @c
- */
-bool nvme_ctrl_is_discovered(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_set_persistent() - Set the 'persistent' flag
- * @c:		Controller instance
- * @persistent:	value of the 'persistent' flag
- *
- * Set the 'persistent' flag of @c to @persistent
- */
-void nvme_ctrl_set_persistent(nvme_ctrl_t c, bool persistent);
-
-/**
- * nvme_ctrl_is_persistent() - Returns the value of the 'persistent' flag
- * @c:	Controller instance
- *
- * Return: Value of the 'persistent' flag of @c
- */
-bool nvme_ctrl_is_persistent(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_set_discovery_ctrl() - Set the 'discovery_ctrl' flag
- * @c:		Controller to be modified
- * @discovery:	value of the discovery_ctrl flag
- *
- * Sets the 'discovery_ctrl' flag in @c to specify whether
- * @c connects to a discovery subsystem.
- *
- */
-void nvme_ctrl_set_discovery_ctrl(nvme_ctrl_t c, bool discovery);
-
-/**
- * nvme_ctrl_is_discovery_ctrl() - Check the 'discovery_ctrl' flag
- * @c:	Controller to be checked
- *
- * Returns the value of the 'discovery_ctrl' flag which specifies whether
- * @c connects to a discovery subsystem.
- *
- * Return: Value of the 'discover_ctrl' flag
- */
-bool nvme_ctrl_is_discovery_ctrl(nvme_ctrl_t c);
-
-/**
- * nvme_ctrl_set_unique_discovery_ctrl() - Set the 'unique_discovery_ctrl' flag
- * @c:		Controller to be modified
- * @unique:	value of the unique_disc_ctrl flag
- *
- * Sets the 'unique_discovery_ctrl' flag in @c to specify wheter
- * @c is a unique discovery controller
- *
- */
-void nvme_ctrl_set_unique_discovery_ctrl(nvme_ctrl_t c, bool unique);
-
-/**
- * nvme_ctrl_is_unique_discovery_ctrl() - Check the 'unique_discovery_ctrl' flag
- * @c:		Controller to be checked
- *
- * Return: Value of the 'unique_discovery_ctrl' flag
- */
-bool nvme_ctrl_is_unique_discovery_ctrl(nvme_ctrl_t c);
-
 /**
  * nvme_ctrl_identify() - Issues an 'identify controller' command
  * @c:	Controller instance
@@ -1211,89 +820,6 @@ void nvme_free_ctrl(struct nvme_ctrl *c);
  */
 void nvme_unlink_ctrl(struct nvme_ctrl *c);
 
-/**
- * nvme_subsystem_get_nqn() - Retrieve NQN from subsystem
- * @s:	nvme_subsystem_t object
- *
- * Return: NQN of subsystem
- */
-const char *nvme_subsystem_get_nqn(nvme_subsystem_t s);
-
-/**
- * nvme_subsystem_get_sysfs_dir() - sysfs directory of an nvme_subsystem_t object
- * @s:	nvme_subsystem_t object
- *
- * Return: sysfs directory name of @s
- */
-const char *nvme_subsystem_get_sysfs_dir(nvme_subsystem_t s);
-
-/**
- * nvme_subsystem_get_name() - sysfs name of an nvme_subsystem_t object
- * @s:	nvme_subsystem_t object
- *
- * Return: sysfs name of @s
- */
-const char *nvme_subsystem_get_name(nvme_subsystem_t s);
-
-/**
- * nvme_subsystem_get_type() - Returns the type of a subsystem
- * @s:	nvme_subsystem_t object
- *
- * Returns the subsystem type of @s.
- *
- * Return: 'nvm' or 'discovery'
- */
-const char *nvme_subsystem_get_type(nvme_subsystem_t s);
-
-/**
- * nvme_subsystem_get_application() - Return the application string
- * @s:	nvme_subsystem_t object
- *
- * Return: Managing application string or NULL if not set.
- */
-const char *nvme_subsystem_get_application(nvme_subsystem_t s);
-
-/**
- * nvme_subsystem_set_application() - Set the application string
- * @s:	nvme_subsystem_t object
- * @a:  application string
- *
- * Sets the managing application string for @s.
- */
-void nvme_subsystem_set_application(nvme_subsystem_t s, const char *a);
-
-/**
- * nvme_subsystem_get_iopolicy() - Return the IO policy of subsytem
- * @s:	nvme_subsystem_t object
- *
- * Return: IO policy used by current subsystem
- */
-const char *nvme_subsystem_get_iopolicy(nvme_subsystem_t s);
-
-/**
- * nvme_subsystem_get_model() - Return the model of subsystem
- * @s:	nvme_subsystem_t object
- *
- * Return: Model of the current subsystem
- */
-const char *nvme_subsystem_get_model(nvme_subsystem_t s);
-
-/**
- * nvme_subsystem_get_serial() - Return the serial number of subsystem
- * @s:	nvme_subsystem_t object
- *
- * Return: Serial number of the current subsystem
- */
-const char *nvme_subsystem_get_serial(nvme_subsystem_t s);
-
-/**
- * nvme_subsystem_get_fw_rev() - Return the firmware rev of subsystem
- * @s:	nvme_subsystem_t object
- *
- * Return: Firmware revision of the current subsystem
- */
-const char *nvme_subsystem_get_fw_rev(nvme_subsystem_t s);
-
 /**
  * nvme_scan_topology() - Scan NVMe topology and apply filter
  * @ctx:    struct nvme_global_ctx object
@@ -1307,22 +833,6 @@ const char *nvme_subsystem_get_fw_rev(nvme_subsystem_t s);
  */
 int nvme_scan_topology(struct nvme_global_ctx *ctx, nvme_scan_filter_t f, void *f_args);
 
-/**
- * nvme_host_get_hostnqn() - Host NQN of an nvme_host_t object
- * @h:	nvme_host_t object
- *
- * Return: Host NQN of @h
- */
-const char *nvme_host_get_hostnqn(nvme_host_t h);
-
-/**
- * nvme_host_get_hostid() - Host ID of an nvme_host_t object
- * @h:	nvme_host_t object
- *
- * Return: Host ID of @h
- */
-const char *nvme_host_get_hostid(nvme_host_t h);
-
 /**
  * nvme_host_release_fds() - Close all opened file descriptors under host
  * @h:	nvme_host_t object
@@ -1464,19 +974,3 @@ char *nvme_get_path_attr(nvme_path_t p, const char *attr);
  */
 int nvme_scan_namespace(struct nvme_global_ctx *ctx, const char *name,
 		nvme_ns_t *ns);
-
-/**
- * nvme_host_get_hostsymname() - Get the host's symbolic name
- * @h:	Host for which the symbolic name should be returned.
- *
- * Return: The symbolic name or NULL if a symbolic name hasn't been
- * configure.
- */
-const char *nvme_host_get_hostsymname(nvme_host_t h);
-
-/**
- * nvme_host_set_hostsymname() - Set the host's symbolic name
- * @h:			Host for which the symbolic name should be set.
- * @hostsymname:	Symbolic name
- */
-void nvme_host_set_hostsymname(nvme_host_t h, const char *hostsymname);
diff --git a/libnvme/src/nvme/types.h b/libnvme/src/nvme/types.h
index 17d90d2660..56cbaba4d7 100644
--- a/libnvme/src/nvme/types.h
+++ b/libnvme/src/nvme/types.h
@@ -1373,11 +1373,24 @@ struct nvme_id_psd {
  *	       of a single Endurance Group.
  * @tmpthha:   Temperature Threshold Hysteresis Attributes
  * @rsvd385:   Reserved
- * @cqt:       Command Quiesce Time (CQT). his field indicates the expected
+ * @cqt:       Command Quiesce Time (CQT). This field indicates the expected
  *	       worst-case time in 1 millisecond units for the controller to
  *	       quiesce all outstanding commands after a Keep Alive Timeout or
  *	       other communication loss.
- * @rsvd388:   Reserved
+ * @cdpa:      Configurable Device Personality Attributes: This field
+ *         indicates the Configurable Device Personality feature attributes
+ *         the controller supports.
+ * @mup:       Maximum Unlimited Power: This field specifies the maximum
+ *         power for power state 0 that results from removal of a power
+ *         limit (i.e., the maximum power is not limited).
+ * @ipmsr:     Interval Power Measurement Sample Rate: This field
+ *         indicates the maximum interval between power measurement
+ *         samples used to collect interval power measurements.
+ * @msmt:      Maximum Stop Measurement Time: This field indicates the
+ *         maximum stop measurement time allowed to be specified in the
+ *         SMT field for a Set Features command specifying the Power
+ *         Measurement feature.
+ * @rsvd396:   Reserved
  * @sqes:      Submission Queue Entry Size, see &enum nvme_id_ctrl_sqes.
  * @cqes:      Completion Queue Entry Size, see &enum nvme_id_ctrl_cqes.
  * @maxcmd:    Maximum Outstanding Commands indicates the maximum number of
@@ -1485,7 +1498,11 @@ struct nvme_id_psd {
  * @dctype:    Discovery Controller Type (DCTYPE). This field indicates what
  *	       type of Discovery controller the controller is (see enum
  *	       nvme_id_ctrl_dctype)
- * @rsvd1807:  Reserved
+ * @ccrl:      Cross-Controller Reset Limit: This field indicates the limit
+ *         on the number of simultaneous in-progress Cross-Controller Reset
+ *         operations this controller is able to cause to be initiated that
+ *         are supported.
+ * @rsvd1808:  Reserved
  * @psd:       Power State Descriptors, see &struct nvme_id_psd.
  * @vs:	       Vendor Specific
  */
@@ -1564,7 +1581,11 @@ struct nvme_id_ctrl {
 	__u8			tmpthha;
 	__u8			rsvd385;
 	__le16			cqt;
-	__u8			rsvd388[124];
+	__le16			cdpa;
+	__le16			mup;
+	__le16			ipmsr;
+	__le16			msmt;
+	__u8			rsvd396[116];
 	__u8			sqes;
 	__u8			cqes;
 	__le16			maxcmd;
@@ -1609,7 +1630,8 @@ struct nvme_id_ctrl {
 	__u8			msdbd;
 	__le16			ofcs;
 	__u8			dctype;
-	__u8			rsvd1807[241];
+	__u8			ccrl;
+	__u8			rsvd1808[240];
 
 	struct nvme_id_psd	psd[32];
 	__u8			vs[1024];
@@ -2278,6 +2300,33 @@ enum nvme_id_ctrl_kpioc {
 	NVME_CTRL_KPIOC_KPIOSC_MASK	= 0x1,
 };
 
+/**
+ * enum nvme_id_ctrl_cdpa - Configurable Device Personality Attributes
+ * @NVME_CTRL_CDPA_HMAC_SHA_384:    If set, then the controller supports
+ *					the HMAC-SHA-384 standard.
+ */
+enum nvme_id_ctrl_cdpa {
+	NVME_CTRL_CDPA_HMAC_SHA_384		= 1 << 0,
+};
+
+/**
+ * enum nvme_id_ctrl_ipmsr - Interval Power Measurement Sample Rate
+ * @NVME_CTRL_IPMSR_SRS_SHIFT:	Shift amount to get the Sample Rate
+ *		Scale from the &struct nvme_id_ctrl.ipmsr field.
+ * @NVME_CTRL_IPMSR_SRV_SHIFT:	Shift amount to get the Sample Rate
+ *		Value from the &struct nvme_id_ctrl.ipmsr field.
+ * @NVME_CTRL_IPMSR_SRS_MASK:	Mask to get the Sample Rate Scale
+ *		from the &struct nvme_id_ctrl.ipmsr field.
+ * @NVME_CTRL_IPMSR_SRV_MASK:	Mask to get the Sample Rate Value
+ *		from the &struct nvme_id_ctrl.ipmsr field.
+ */
+enum nvme_id_ctrl_ipmsr {
+	NVME_CTRL_IPMSR_SRS_SHIFT	= 8,
+	NVME_CTRL_IPMSR_SRV_SHIFT	= 0,
+	NVME_CTRL_IPMSR_SRS_MASK	= 0x00FF,
+	NVME_CTRL_IPMSR_SRV_MASK	= 0x00FF,
+};
+
 /**
  * enum nvme_id_ctrl_sqes - Defines the required and maximum Submission Queue
  *			    entry size when using the NVM Command Set.
diff --git a/libnvme/src/nvme/uring.c b/libnvme/src/nvme/uring.c
new file mode 100644
index 0000000000..7eb4bfa2ba
--- /dev/null
+++ b/libnvme/src/nvme/uring.c
@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2020 Western Digital Corporation or its affiliates.
+ *
+ * Authors: Keith Busch <keith.busch@wdc.com>
+ *	    Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
+ *	    Daniel Wagner <dwagner@suse.de>
+ */
+#include <liburing.h>
+
+#include <libnvme.h>
+
+#include "private.h"
+
+/*
+ * should not exceed CAP.MQES, 16 is rational for most ssd
+ */
+#define NVME_URING_ENTRIES 16
+
+int nvme_open_uring(struct nvme_global_ctx *ctx)
+{
+	struct io_uring_probe *probe;
+	struct io_uring *ring;
+
+	probe = io_uring_get_probe();
+	if (!probe)
+		return -ENOTSUP;
+
+	if (!io_uring_opcode_supported(probe, IORING_OP_URING_CMD))
+		return -ENOTSUP;
+
+	ring = calloc(1, sizeof(*ring));
+	if (!ring)
+		return -ENOMEM;
+
+	if (io_uring_queue_init(NVME_URING_ENTRIES, ring,
+			IORING_SETUP_SQE128 | IORING_SETUP_CQE32)) {
+		free(ring);
+		return -errno;
+	}
+
+	ctx->ring = ring;
+	return 0;
+}
+
+void nvme_close_uring(struct nvme_global_ctx *ctx)
+{
+	if (!ctx->ring)
+		return;
+
+	io_uring_queue_exit(ctx->ring);
+	free(ctx->ring);
+}
+
+int __nvme_transport_handle_open_uring(struct nvme_transport_handle *hdl)
+{
+	int err;
+
+	switch (hdl->ctx->uring_state) {
+	case NVME_IO_URING_STATE_NOT_AVAILABLE:
+		return -ENOTSUP;
+	case NVME_IO_URING_STATE_AVAILABLE:
+		goto uring_enabled;
+	case NVME_IO_URING_STATE_UNKNOWN:
+		break;
+	}
+
+	err = nvme_open_uring(hdl->ctx);
+	if (err)
+		return err;
+
+uring_enabled:
+	hdl->uring_enabled = true;
+
+	return 0;
+}
+
+static int nvme_submit_uring_cmd(struct io_uring *ring, int fd,
+		struct nvme_passthru_cmd *cmd)
+{
+	struct io_uring_sqe *sqe;
+	int ret;
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe)
+		return -1;
+
+	memcpy(&sqe->cmd, cmd, sizeof(*cmd));
+
+	sqe->fd = fd;
+	sqe->opcode = IORING_OP_URING_CMD;
+	sqe->cmd_op = NVME_URING_CMD_ADMIN;
+
+	ret = io_uring_submit(ring);
+	if (ret < 0)
+		return -errno;
+
+	return 0;
+}
+
+int nvme_wait_complete_passthru(struct nvme_transport_handle *hdl)
+{
+	struct io_uring_cqe *cqe;
+	struct io_uring *ring;
+	int err;
+
+	ring = hdl->ctx->ring;
+
+	for (int i = 0; i < hdl->ctx->ring_cmds; i++) {
+		err = io_uring_wait_cqe(ring, &cqe);
+		if (err < 0)
+			return -errno;
+		io_uring_cqe_seen(ring, cqe);
+	}
+
+	hdl->ctx->ring_cmds = 0;
+	return 0;
+}
+
+int nvme_submit_admin_passthru_async(struct nvme_transport_handle *hdl,
+		 struct nvme_passthru_cmd *cmd)
+{
+	int err;
+
+	if (hdl->ctx->ring_cmds >= NVME_URING_ENTRIES) {
+		err = nvme_wait_complete_passthru(hdl);
+		if (err)
+			return err;
+	}
+
+	err = nvme_submit_uring_cmd(hdl->ctx->ring, hdl->fd, cmd);
+	if (err)
+		return err;
+
+	hdl->ctx->ring_cmds += 1;
+	return 0;
+}
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index b816d31636..160bb611f2 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -7,26 +7,26 @@
  * 	    Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
  */
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdbool.h>
-#include <string.h>
 #include <errno.h>
-#include <malloc.h>
-
-#include <sys/stat.h>
 #include <fcntl.h>
+#include <malloc.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
 
 #include "platform/includes.h"
 
-#include <ccan/minmax/minmax.h>
 #include <ccan/endian/endian.h>
+#include <ccan/minmax/minmax.h>
 
 #include <libnvme.h>
 
 #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
@@ -171,7 +171,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;
 
@@ -370,7 +370,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;
@@ -434,14 +434,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);
@@ -702,13 +702,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:
@@ -720,7 +720,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,
@@ -732,7 +732,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;
 
@@ -746,7 +746,7 @@ int nvme_uuid_from_string(const char *str, unsigned char uuid[NVME_UUID_LEN])
 
 }
 
-int nvme_uuid_random(unsigned char uuid[NVME_UUID_LEN])
+__public int nvme_random_uuid(unsigned char uuid[NVME_UUID_LEN])
 {
 	int ret;
 
@@ -766,7 +766,8 @@ int nvme_uuid_random(unsigned char uuid[NVME_UUID_LEN])
 	return 0;
 }
 
-int nvme_uuid_find(struct nvme_id_uuid_list *uuid_list, const unsigned char uuid[NVME_UUID_LEN])
+__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/src/nvme/util.h b/libnvme/src/nvme/util.h
index 0a9e2625e2..eb75a133bb 100644
--- a/libnvme/src/nvme/util.h
+++ b/libnvme/src/nvme/util.h
@@ -199,7 +199,7 @@ int nvme_uuid_to_string(unsigned char uuid[NVME_UUID_LEN], char *str);
 int nvme_uuid_from_string(const char *str, unsigned char uuid[NVME_UUID_LEN]);
 
 /**
- * nvme_uuid_random - Generate random UUID
+ * nvme_random_uuid - Generate random UUID
  * @uuid:       Generated random UUID
  *
  * Generate random number according
@@ -207,16 +207,18 @@ int nvme_uuid_from_string(const char *str, unsigned char uuid[NVME_UUID_LEN]);
  *
  * Return: Returns error code if generating of random number fails.
  */
-int nvme_uuid_random(unsigned char uuid[NVME_UUID_LEN]);
+int nvme_random_uuid(unsigned char uuid[NVME_UUID_LEN]);
 
 /**
- * nvme_uuid_find - Find UUID position on UUID list
+ * nvme_find_uuid - Find UUID position on UUID list
  * @uuid_list:	UUID list returned by identify UUID
  * @uuid:	Binary encoded input UUID
  *
- * Return: The array position where given UUID is present, or -1 on failure with errno set.
+ * Return: The array position where given UUID is present, or -1 on failure
+ *  with errno set.
  */
-int nvme_uuid_find(struct nvme_id_uuid_list *uuid_list, const unsigned char uuid[NVME_UUID_LEN]);
+int nvme_find_uuid(struct nvme_id_uuid_list *uuid_list,
+		const unsigned char uuid[NVME_UUID_LEN]);
 
 /**
  * nvme_basename - Return the final path component (the one after the last '/')
diff --git a/libnvme/test/config/config-dump.c b/libnvme/test/config/config-dump.c
index 1adc3348a1..0c68195d62 100644
--- a/libnvme/test/config/config-dump.c
+++ b/libnvme/test/config/config-dump.c
@@ -4,11 +4,11 @@
  * Copyright (c) 2024 Daniel Wagner, SUSE LLC
  */
 
-#include <string.h>
+#include <errno.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
-#include <errno.h>
 
 #include <libnvme.h>
 
diff --git a/libnvme/test/config/hostnqn-order.c b/libnvme/test/config/hostnqn-order.c
index 52d1ae4166..7500b96675 100644
--- a/libnvme/test/config/hostnqn-order.c
+++ b/libnvme/test/config/hostnqn-order.c
@@ -4,10 +4,10 @@
  * Copyright (c) 2024 Daniel Wagner, SUSE LLC
  */
 
-#include <string.h>
+#include <errno.h>
 #include <stdbool.h>
 #include <stdlib.h>
-#include <errno.h>
+#include <string.h>
 
 #include <libnvme.h>
 
diff --git a/libnvme/test/config/psk-json.c b/libnvme/test/config/psk-json.c
index 35fc67ee4a..b83ebfb32a 100644
--- a/libnvme/test/config/psk-json.c
+++ b/libnvme/test/config/psk-json.c
@@ -4,16 +4,17 @@
  * Copyright (c) 2024 Daniel Wagner, SUSE LLC
  */
 
-#include "nvme/linux.h"
-#include "nvme/tree.h"
-#include <string.h>
+#include <errno.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
-#include <errno.h>
 
 #include <libnvme.h>
 
+#include "nvme/linux.h"
+#include "nvme/tree.h"
+
 static bool import_export_key(struct nvme_global_ctx *ctx, nvme_ctrl_t c)
 {
 	unsigned char version, hmac, *key;
diff --git a/libnvme/test/cpp.cc b/libnvme/test/cpp.cc
index 309359cee1..6cd0778bea 100644
--- a/libnvme/test/cpp.cc
+++ b/libnvme/test/cpp.cc
@@ -34,12 +34,12 @@ int main()
 	nvme_for_each_host(ctx, h) {
 		nvme_for_each_subsystem(h, s) {
 			std::cout <<  nvme_subsystem_get_name(s)
-				  << " - NQN=" << nvme_subsystem_get_nqn(s)
+				  << " - NQN=" << nvme_subsystem_get_subsysnqn(s)
 				  << "\n";
 			nvme_subsystem_for_each_ctrl(s, c) {
 				std::cout << " `- " << nvme_ctrl_get_name(c)
 					  << " " << nvme_ctrl_get_transport(c)
-					  << " " << nvme_ctrl_get_address(c)
+					  << " " << nvme_ctrl_get_traddr(c)
 					  << " " << nvme_ctrl_get_state(c)
 					  << "\n";
 				nvme_ctrl_for_each_ns(c, n) {
diff --git a/libnvme/test/hkdf_add1.c b/libnvme/test/hkdf_add1.c
index ceb0ac9df1..1c89995452 100644
--- a/libnvme/test/hkdf_add1.c
+++ b/libnvme/test/hkdf_add1.c
@@ -6,13 +6,14 @@
  * Authors: Daniel Wagner <wagi@kernel.org>
  */
 
+#include <stdio.h>
+#include <string.h>
+
 #include <openssl/core_names.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
 #include <openssl/kdf.h>
 #include <openssl/params.h>
-#include <stdio.h>
-#include <string.h>
 
 #define SHA256_LEN 32
 
diff --git a/libnvme/test/ioctl/meson.build b/libnvme/test/ioctl/meson.build
index 4e0f80cebe..7aec1f3810 100644
--- a/libnvme/test/ioctl/meson.build
+++ b/libnvme/test/ioctl/meson.build
@@ -52,17 +52,19 @@ ana = executable(
 )
 test('libnvme - ana', ana, env: mock_ioctl_env)
 
-discovery = executable(
-    'test-discovery',
-    'discovery.c',
-    dependencies: [
-        config_dep,
-        ccan_dep,
-        libnvme_dep,
-    ],
-    link_with: mock_ioctl,
-)
-test('libnvme - discovery', discovery, env: mock_ioctl_env)
+if want_fabrics
+    discovery = executable(
+        'test-discovery',
+        'discovery.c',
+        dependencies: [
+            config_dep,
+            ccan_dep,
+            libnvme_dep,
+        ],
+        link_with: mock_ioctl,
+    )
+    test('libnvme - discovery', discovery, env: mock_ioctl_env)
+endif
 
 features = executable(
     'test-features',
diff --git a/libnvme/test/ioctl/misc.c b/libnvme/test/ioctl/misc.c
index 84daeb94f9..b6dc618dd3 100644
--- a/libnvme/test/ioctl/misc.c
+++ b/libnvme/test/ioctl/misc.c
@@ -1,15 +1,17 @@
 // SPDX-License-Identifier: LGPL-2.1-or-later
 
+#include <inttypes.h>
+#include <string.h>
+
 #include <libnvme.h>
 
 #include "mock.h"
 #include "util.h"
 
-#include <string.h>
-#include <inttypes.h>
-
+#define TEST_FD 0xFD
 #define TEST_NSID 0x12345678
 #define TEST_CSI NVME_CSI_KV
+#define TEST_COPY_NR 0x12
 
 static struct nvme_transport_handle *test_hdl;
 
@@ -741,11 +743,12 @@ static void test_flush(void)
 		.opcode = nvme_cmd_flush,
 		.nsid = TEST_NSID,
 	};
-
+	struct nvme_passthru_cmd cmd;
 	int err;
 
 	set_mock_io_cmds(&mock_io_cmd, 1);
-	err = nvme_flush(test_hdl, TEST_NSID);
+	nvme_init_flush(&cmd, TEST_NSID);
+	err = nvme_submit_io_passthru(test_hdl, &cmd);
 	end_mock_cmds();
 	check(err == 0, "returned error %d", err);
 }
@@ -979,12 +982,25 @@ static void test_dsm(void)
 
 static void test_copy(void)
 {
-	__u16 nr = 0x12, cev = 0, dspec = 0;
+	__u16 nr = TEST_COPY_NR, cev = 0, dspec = 0;
 	int copy_size = sizeof(struct nvme_copy_range) * nr, err;
 	bool prinfor = false, prinfow = false, stcw = false,
 		stcr = false, fua = false, lr = false;
 	__u8 cetype = 0, dtype = 0, desfmt = 0xf;
 	__u64 sdlba = 0xfffff;
+	__u16 nlbs[TEST_COPY_NR] = { 0xa, 0xb, 0xc };
+	__u64 slbas[TEST_COPY_NR] = { 0x1000, 0x20000000, 0x300040000000 };
+	__u32 short_pi[TEST_COPY_NR] = { 0x1000, 0x20000000, 0x40000000 };
+	__u32 elbatms[TEST_COPY_NR] = { 0x1ff, 0x3ff, 0x3ff };
+	__u32 elbats[TEST_COPY_NR] = { 0x111, 0x222, 0x333 };
+	__u8 expected_data[sizeof(struct nvme_copy_range) * TEST_COPY_NR] = {
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10, 0, 0, 0, 0, 0, 0,
+		0xa, 0, 0, 0, 0, 0, 0, 0, 0, 0x10, 0, 0, 0x11, 1, 0xff, 1,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x20, 0, 0, 0, 0,
+		0xb, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x20, 0x22, 2, 0xff, 3,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x40, 0, 0x30, 0, 0,
+		0xc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x40, 0x33, 3, 0xff, 3
+	};
 
 	_cleanup_free_ struct nvme_copy_range *copy = NULL;
 
@@ -1002,11 +1018,12 @@ static void test_copy(void)
 			 ((prinfow & 0xf) << 26) |
 			 ((fua & 0x1) << 30) | ((lr & 0x1) << 31),
 		.data_len = nr * sizeof(struct nvme_copy_range),
-		.in_data = copy,
+		.in_data = expected_data,
 	};
 	struct nvme_passthru_cmd cmd;
 
 	set_mock_io_cmds(&mock_io_cmd, 1);
+	nvme_init_copy_range(copy, nlbs, slbas, short_pi, elbatms, elbats, nr);
 	nvme_init_copy(&cmd, TEST_NSID, sdlba, nr, desfmt,
 		prinfor, prinfow, cetype, dtype, stcw, stcr,
 		fua, lr, cev, dspec, (void *)copy);
diff --git a/libnvme/test/ioctl/mock.c b/libnvme/test/ioctl/mock.c
index 87ee63ffa2..07b7ab002d 100644
--- a/libnvme/test/ioctl/mock.c
+++ b/libnvme/test/ioctl/mock.c
@@ -1,11 +1,12 @@
 // SPDX-License-Identifier: LGPL-2.1-or-later
 
+#include <dlfcn.h>
 #include <errno.h>
 #include <inttypes.h>
 #include <stdarg.h>
 #include <string.h>
+
 #include <sys/ioctl.h>
-#include <dlfcn.h>
 
 #include <libnvme.h>
 
diff --git a/libnvme/test/ioctl/zns.c b/libnvme/test/ioctl/zns.c
index 57d6aa0d6e..b5cf859f96 100644
--- a/libnvme/test/ioctl/zns.c
+++ b/libnvme/test/ioctl/zns.c
@@ -1,12 +1,13 @@
 // SPDX-License-Identifier: LGPL-2.1-or-later
 
+#include <inttypes.h>
+
 #include <libnvme.h>
 
 #include "mock.h"
 #include "util.h"
 
-#include <inttypes.h>
-
+#define TEST_FD 0xFD
 #define TEST_NSID 0x12345678
 #define TEST_SLBA 0xffffffff12345678
 
diff --git a/libnvme/test/meson.build b/libnvme/test/meson.build
index c83a3e2bd6..fee8715ab1 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
@@ -104,17 +116,19 @@ uuid = executable(
 test('libnvme - uuid', uuid)
 
 if not is_windows
-    uriparser = executable(
-        'test-uriparser',
-        ['uriparser.c'],
-        dependencies: [
-            config_dep,
-            ccan_dep,
-            libnvme_dep,
-        ],
-    )
+    if want_fabrics
+        uriparser = executable(
+            'test-uriparser',
+            ['uriparser.c'],
+            dependencies: [
+                config_dep,
+                ccan_dep,
+                libnvme_dep,
+            ],
+        )
 
-    test('libnvme - uriparser', uriparser)
+        test('libnvme - uriparser', uriparser)
+    endif
 
     if conf.get('HAVE_NETDB')
         mock_ifaddrs = library(
@@ -165,7 +179,9 @@ if not is_windows
     test('libnvme - psk', psk)
 
     subdir('ioctl')
-    subdir('nbft')
+    if want_fabrics
+        subdir('nbft')
+    endif
 
     if json_c_dep.found()
         subdir('sysfs')
diff --git a/libnvme/test/mi-mctp.c b/libnvme/test/mi-mctp.c
index 87d8bb69e0..c666b0119d 100644
--- a/libnvme/test/mi-mctp.c
+++ b/libnvme/test/mi-mctp.c
@@ -8,12 +8,19 @@
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include <sys/socket.h>
+
 #include <sys/ioctl.h>
+#include <sys/socket.h>
+
+#if HAVE_LINUX_MCTP_H
+#include <linux/mctp.h>
+#else
+#include "nvme/mi-mctp-compat.h"
+#endif
 
 #include <ccan/array_size/array_size.h>
 #include <ccan/endian/endian.h>
@@ -25,12 +32,6 @@
 
 #include "utils.h"
 
-#if HAVE_LINUX_MCTP_H
-#include <linux/mctp.h>
-#else
-#include "nvme/mi-mctp-compat.h"
-#endif
-
 /* 4096 byte max MCTP message, plus space for header data */
 #define MAX_BUFSIZ 8192
 
diff --git a/libnvme/test/mi.c b/libnvme/test/mi.c
index 918200317d..3a890bc716 100644
--- a/libnvme/test/mi.c
+++ b/libnvme/test/mi.c
@@ -6,8 +6,8 @@
 
 #undef NDEBUG
 #include <assert.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <unistd.h>
 
 #include <ccan/array_size/array_size.h>
diff --git a/libnvme/test/mock-ifaddrs.c b/libnvme/test/mock-ifaddrs.c
index 87a2e500df..ea3f32bb2d 100644
--- a/libnvme/test/mock-ifaddrs.c
+++ b/libnvme/test/mock-ifaddrs.c
@@ -3,15 +3,16 @@
  * This file is part of libnvme.
  * Copyright (c) 2023 Martin Belanger, Dell Technologies Inc.
  */
-#include <sys/types.h>
 #include <ifaddrs.h>
-#include <stdlib.h>
-#include <stdint.h>
 #include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
-#include <netinet/in.h>
-#include <net/if.h>
+
 #include <arpa/inet.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <sys/types.h>
 
 struct ifaddrs_storage {
 	struct ifaddrs ifa;
diff --git a/libnvme/test/nbft/nbft-dump.c b/libnvme/test/nbft/nbft-dump.c
index 23b8c213a3..2b14bf5869 100644
--- a/libnvme/test/nbft/nbft-dump.c
+++ b/libnvme/test/nbft/nbft-dump.c
@@ -4,11 +4,11 @@
  * Copyright (c) 2023 Red Hat Inc.
  */
 
-#include <stdlib.h>
+#include <inttypes.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include <inttypes.h>
 
 #include <libnvme.h>
 
@@ -118,7 +118,7 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
-	if (nvme_nbft_read(ctx, &table, argv[1]) != 0) {
+	if (nvme_read_nbft(ctx, &table, argv[1]) != 0) {
 		fprintf(stderr, "Error parsing the NBFT table %s: %m\n",
 			argv[1]);
 		nvme_free_global_ctx(ctx);
@@ -127,7 +127,7 @@ int main(int argc, char **argv)
 
 	print_nbft(table);
 
-	nvme_nbft_free(ctx, table);
+	nvme_free_nbft(ctx, table);
 	nvme_free_global_ctx(ctx);
 	return 0;
 }
diff --git a/libnvme/test/psk.c b/libnvme/test/psk.c
index 125a7cc9a3..7dd810f38a 100644
--- a/libnvme/test/psk.c
+++ b/libnvme/test/psk.c
@@ -4,9 +4,9 @@
  * Copyright (c) 2024 Daniel Wagner, SUSE Software Solutions
  */
 
-#include <string.h>
-#include <stdlib.h>
 #include <errno.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include <ccan/array_size/array_size.h>
 
diff --git a/libnvme/test/register.c b/libnvme/test/register.c
index 1fb692b83c..72d04752e7 100644
--- a/libnvme/test/register.c
+++ b/libnvme/test/register.c
@@ -15,16 +15,17 @@
 
 #include <fcntl.h>
 #include <inttypes.h>
-#include <libnvme.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdint.h>
 #include <unistd.h>
 
 #include <sys/mman.h>
 
 #include <ccan/endian/endian.h>
 
+#include <libnvme.h>
+
 static inline uint32_t nvme_mmio_read32(volatile void *addr)
 {
         uint32_t *p = (__le32 *)addr;
diff --git a/libnvme/test/test-util.c b/libnvme/test/test-util.c
index c7b661ee35..997d72d13e 100644
--- a/libnvme/test/test-util.c
+++ b/libnvme/test/test-util.c
@@ -14,10 +14,10 @@
  * the libnvme.so.
  */
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdbool.h>
 #include <netdb.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 #include <libnvme.h>
diff --git a/libnvme/test/test.c b/libnvme/test/test.c
index 96d9272035..cefa97d360 100644
--- a/libnvme/test/test.c
+++ b/libnvme/test/test.c
@@ -15,26 +15,25 @@
  * program exists successfully; an ungraceful exit means a bug exists
  * somewhere.
  */
-#include <libnvme.h>
-
-#include "nvme/private.h"
-
+#include <inttypes.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdbool.h>
-#include <inttypes.h>
-#include <libnvme.h>
 
 #include <ccan/endian/endian.h>
 
+#include <libnvme.h>
+
+#include "nvme/private.h"
+
 static bool nvme_match_subsysnqn_filter(nvme_subsystem_t s,
 		nvme_ctrl_t c, nvme_ns_t ns, void *f_args)
 {
 	char *nqn_match = f_args;
 
 	if (s)
-		return strcmp(nvme_subsystem_get_nqn(s), nqn_match) == 0;
+		return strcmp(nvme_subsystem_get_subsysnqn(s), nqn_match) == 0;
 	return true;
 }
 
@@ -406,11 +405,11 @@ int main(int argc, char **argv)
 	nvme_for_each_host(ctx, h) {
 		nvme_for_each_subsystem(h, s) {
 			printf("%s - NQN=%s\n", nvme_subsystem_get_name(s),
-			       nvme_subsystem_get_nqn(s));
+			       nvme_subsystem_get_subsysnqn(s));
 			nvme_subsystem_for_each_ctrl(s, c) {
 				printf("  %s %s %s %s\n", nvme_ctrl_get_name(c),
 				       nvme_ctrl_get_transport(c),
-				       nvme_ctrl_get_address(c),
+				       nvme_ctrl_get_traddr(c),
 				       nvme_ctrl_get_state(c));
 			}
 		}
@@ -424,7 +423,7 @@ int main(int argc, char **argv)
 	if (!nvme_scan_ctrl(ctx, ctrl, &c)) {
 		printf("%s %s %s %s\n", nvme_ctrl_get_name(c),
 			nvme_ctrl_get_transport(c),
-			nvme_ctrl_get_address(c),
+			nvme_ctrl_get_traddr(c),
 			nvme_ctrl_get_state(c));
 		nvme_free_ctrl(c);
 	}
@@ -434,12 +433,12 @@ int main(int argc, char **argv)
 	nvme_for_each_host(ctx, h) {
 		nvme_for_each_subsystem(h, s) {
 			printf("%s - NQN=%s\n", nvme_subsystem_get_name(s),
-			       nvme_subsystem_get_nqn(s));
+			       nvme_subsystem_get_subsysnqn(s));
 			nvme_subsystem_for_each_ctrl(s, c) {
 				printf(" `- %s %s %s %s\n",
 				       nvme_ctrl_get_name(c),
 				       nvme_ctrl_get_transport(c),
-				       nvme_ctrl_get_address(c),
+				       nvme_ctrl_get_traddr(c),
 				       nvme_ctrl_get_state(c));
 
 				nvme_ctrl_for_each_ns(c, n) {
diff --git a/libnvme/test/tree.c b/libnvme/test/tree.c
index a0ad0a5ad7..076c10c485 100644
--- a/libnvme/test/tree.c
+++ b/libnvme/test/tree.c
@@ -5,9 +5,9 @@
  */
 
 #include <assert.h>
-#include <string.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <string.h>
 #include <arpa/inet.h>
 
 #include <ccan/array_size/array_size.h>
@@ -131,14 +131,14 @@ static struct nvme_global_ctx *create_tree()
 
 	ctx = nvme_create_global_ctx(stdout, LOG_DEBUG);
 	assert(ctx);
-	nvme_host_get(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
+	nvme_get_host(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
 	assert(h);
 
 	printf("  ctrls created:\n");
 	for (int i = 0; i < ARRAY_SIZE(test_data); i++) {
 		struct test_data *d = &test_data[i];
 
-		assert(!nvme_subsystem_get(ctx, h, d->subsysname,
+		assert(!nvme_get_subsystem(ctx, h, d->subsysname,
 			d->subsysnqn, &d->s));
 		assert(d->s);
 		d->c = nvme_lookup_ctrl(d->s, d->transport, d->traddr,
@@ -236,7 +236,7 @@ static bool ctrl_lookups(struct nvme_global_ctx *ctx)
 	bool pass = true;
 
 	h = nvme_first_host(ctx);
-	nvme_subsystem_get(ctx, h, DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, &s);
+	nvme_get_subsystem(ctx, h, DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, &s);
 
 	printf("  lookup controller:\n");
 	for (int i = 0; i < ARRAY_SIZE(test_data); i++) {
@@ -288,10 +288,10 @@ static bool test_src_addr()
 	ctx = nvme_create_global_ctx(stdout, LOG_DEBUG);
 	assert(ctx);
 
-	nvme_host_get(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
+	nvme_get_host(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
 	assert(h);
 
-	nvme_subsystem_get(ctx, h, DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, &s);
+	nvme_get_subsystem(ctx, h, DEFAULT_SUBSYSNAME, DEFAULT_SUBSYSNQN, &s);
 	assert(s);
 
 	c = nvme_lookup_ctrl(s, "tcp", "192.168.56.1", NULL, NULL, "8009", NULL);
@@ -464,10 +464,10 @@ static bool ctrl_match(const char *tag,
 	ctx = nvme_create_global_ctx(stdout, LOG_INFO);
 	assert(ctx);
 
-	nvme_host_get(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
+	nvme_get_host(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
 	assert(h);
 
-	assert(!nvme_subsystem_get(ctx, h, DEFAULT_SUBSYSNAME,
+	assert(!nvme_get_subsystem(ctx, h, DEFAULT_SUBSYSNAME,
 		 reference->subsysnqn ?
 			reference->subsysnqn : DEFAULT_SUBSYSNQN,
 		&s));
@@ -1080,10 +1080,10 @@ static bool ctrl_config_match(const char *tag,
 	ctx = nvme_create_global_ctx(stdout, LOG_INFO);
 	assert(ctx);
 
-	nvme_host_get(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
+	nvme_get_host(ctx, DEFAULT_HOSTNQN, DEFAULT_HOSTID, &h);
 	assert(h);
 
-	assert(!nvme_subsystem_get(ctx, h, DEFAULT_SUBSYSNAME,
+	assert(!nvme_get_subsystem(ctx, h, DEFAULT_SUBSYSNAME,
 		reference->subsysnqn ?
 			reference->subsysnqn : DEFAULT_SUBSYSNQN,
 		&s));
@@ -1098,9 +1098,10 @@ static bool ctrl_config_match(const char *tag,
 		reference_ctrl->address = (char *)reference->address;
 	}
 
-	match = nvme_ctrl_config_match(reference_ctrl, candidate->transport, candidate->traddr,
-				       candidate->trsvcid, candidate->subsysnqn,
-				       candidate->host_traddr, candidate->host_iface);
+	match = nvme_ctrl_match_config(reference_ctrl,
+			candidate->transport, candidate->traddr,
+			candidate->trsvcid, candidate->subsysnqn,
+			candidate->host_traddr, candidate->host_iface);
 
 	if (should_match) {
 		if (!match) {
diff --git a/libnvme/test/uriparser.c b/libnvme/test/uriparser.c
index ae3bd87e96..9d5723b965 100644
--- a/libnvme/test/uriparser.c
+++ b/libnvme/test/uriparser.c
@@ -5,9 +5,9 @@
  */
 
 #include <assert.h>
-#include <string.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include <ccan/array_size/array_size.h>
 
diff --git a/libnvme/test/uuid.c b/libnvme/test/uuid.c
index 9146453193..3b557969c4 100644
--- a/libnvme/test/uuid.c
+++ b/libnvme/test/uuid.c
@@ -4,8 +4,8 @@
  * Copyright (c) 2022 Daniel Wagner, SUSE Software Solutions
  */
 
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include <ccan/array_size/array_size.h>
 
@@ -85,9 +85,9 @@ static void random_uuid_test(void)
 	unsigned char uuid1[NVME_UUID_LEN], uuid2[NVME_UUID_LEN];
 	char str1[NVME_UUID_LEN_STRING], str2[NVME_UUID_LEN_STRING];
 
-	if (nvme_uuid_random(uuid1) || nvme_uuid_random(uuid2)) {
+	if (nvme_random_uuid(uuid1) || nvme_random_uuid(uuid2)) {
 		test_rc = 1;
-		printf("ERROR: nvme_uuid_random() failed\n");
+		printf("ERROR: nvme_random_uuid() failed\n");
 		return;
 	}
 
diff --git a/libnvme/test/zns.c b/libnvme/test/zns.c
index 82d81a5e7f..79051a10fc 100644
--- a/libnvme/test/zns.c
+++ b/libnvme/test/zns.c
@@ -9,19 +9,18 @@
 /*
  * Search out for ZNS type namespaces, and if found, report their properties.
  */
-#include <libnvme.h>
-
-#include "nvme/private.h"
-
-#include <stdio.h>
-#include <string.h>
+#include <inttypes.h>
 #include <stdbool.h>
+#include <stdio.h>
 #include <stdlib.h>
-#include <libnvme.h>
-#include <inttypes.h>
+#include <string.h>
 
 #include <ccan/endian/endian.h>
 
+#include <libnvme.h>
+
+#include "nvme/private.h"
+
 static void show_zns_properties(nvme_ns_t n)
 {
 	struct nvme_transport_handle *hdl;
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.md b/libnvme/tools/generator/generate-accessors.md
new file mode 100644
index 0000000000..42702d9a12
--- /dev/null
+++ b/libnvme/tools/generator/generate-accessors.md
@@ -0,0 +1,271 @@
+# Generate Accessors Tool
+
+This tool generates **setter and getter functions** for C structs automatically. It supports dynamic strings, fixed-size char arrays, and `const` fields, with control over which structs and members participate via **in-source annotations**.
+
+------
+
+## Usage
+
+```
+python3 generate-accessors.py [options] <header-files>
+```
+
+**Options:**
+
+| Short | Long       | Argument | Description                                              |
+| ----- | ---------- | -------- | -------------------------------------------------------- |
+| `-h`  | `--h-out`  | `<file>` | Full path of the `*.h` file to generate. Default: `accessors.h` |
+| `-c`  | `--c-out`  | `<file>` | Full path of the `*.c` file to generate. Default: `accessors.c` |
+| `-l`  | `--ld-out` | `<file>` | Full path of the `*.ld` file to generate. Default: `accessors.ld` |
+| `-p`  | `--prefix` | `<str>`  | Prefix prepended to every generated function name        |
+| `-v`  | `--verbose`| none     | Verbose output showing which structs are being processed |
+| `-H`  | `--help`   | none     | Show this help message                                   |
+
+------
+
+## Annotations
+
+Struct inclusion and member behaviour are controlled by **annotations written as comments directly in the header file**. Both `/* */` (block) and `//` (line) comment styles are supported for every annotation.
+
+### Struct inclusion — `generate-accessors`
+
+Place the annotation on the same line as the struct's opening brace to opt that struct in to code generation:
+
+```c
+struct nvme_ctrl { /*!generate-accessors*/
+    ...
+};
+```
+
+```c
+struct nvme_ctrl { //!generate-accessors
+    ...
+};
+```
+
+Only structs carrying this annotation will have accessors generated. All other structs in the header are ignored.
+
+### Member exclusion — `accessors:none`
+
+Place the annotation on a member's declaration line to suppress accessor generation for that member entirely (no setter, no getter):
+
+```c
+struct nvme_ctrl { /*!generate-accessors*/
+    char *name;
+    char *state;      //!accessors:none
+    char *subsysnqn;  /*!accessors:none*/
+};
+```
+
+### Read-only members — `accessors:readonly`
+
+Place the annotation on a member's declaration line to generate only a getter (no setter). This has the same effect as declaring the member `const`, but without changing the type in the struct:
+
+```c
+struct nvme_ctrl { /*!generate-accessors*/
+    char *name;
+    char *firmware;   //!accessors:readonly
+    char *model;      /*!accessors:readonly*/
+};
+```
+
+Members declared with the `const` qualifier are also automatically read-only.
+
+### Annotation summary
+
+| Annotation                  | Where        | Effect                          |
+| --------------------------- | ------------ | ------------------------------- |
+| `/*!generate-accessors*/`   | struct brace | Include this struct             |
+| `//!generate-accessors`     | struct brace | Include this struct             |
+| `/*!accessors:none*/`       | member line  | Skip this member entirely       |
+| `//!accessors:none`         | member line  | Skip this member entirely       |
+| `/*!accessors:readonly*/`   | member line  | Generate getter only            |
+| `//!accessors:readonly`     | member line  | Generate getter only            |
+| `const` qualifier on member | member type  | Generate getter only (built-in) |
+
+------
+
+## Example
+
+### Header file (`person.h`)
+
+```c
+struct person { /*!generate-accessors*/
+    char *name;
+    int age;
+    const char *id;       /* const → getter only, no annotation needed */
+    char *secret;         //!accessors:none
+    char *role;           //!accessors:readonly
+};
+
+struct car { /*!generate-accessors*/
+    char *model;
+    int year;
+    const char *vin;
+};
+```
+
+### Command
+
+```
+python3 generate-accessors.py person.h
+```
+
+### Generated `accessors.h`
+
+```c
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/* ... banner ... */
+
+#ifndef _ACCESSORS_H_
+#define _ACCESSORS_H_
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <linux/types.h> /* __u32, __u64, etc. */
+
+/* Forward declarations. These are internal (opaque) structs. */
+struct person;
+struct car;
+
+/****************************************************************************
+ * Accessors for: struct person
+ ****************************************************************************/
+
+/**
+ * person_set_name() - Set name.
+ * @p: The &struct person instance to update.
+ * @name: New string; a copy is stored. Pass NULL to clear.
+ */
+void person_set_name(struct person *p, const char *name);
+
+/**
+ * person_get_name() - Get name.
+ * @p: The &struct person instance to query.
+ *
+ * Return: The value of the name field, or NULL if not set.
+ */
+const char *person_get_name(const struct person *p);
+
+/**
+ * person_set_age() - Set age.
+ * @p: The &struct person instance to update.
+ * @age: Value to assign to the age field.
+ */
+void person_set_age(struct person *p, int age);
+
+/**
+ * person_get_age() - Get age.
+ * @p: The &struct person instance to query.
+ *
+ * Return: The value of the age field.
+ */
+int person_get_age(const struct person *p);
+
+/**
+ * person_get_id() - Get id.
+ * @p: The &struct person instance to query.
+ *
+ * Return: The value of the id field, or NULL if not set.
+ */
+const char *person_get_id(const struct person *p);
+
+/* secret: no accessors (//!accessors:none) */
+
+/**
+ * person_get_role() - Get role.
+ * @p: The &struct person instance to query.
+ *
+ * Return: The value of the role field, or NULL if not set.
+ */
+const char *person_get_role(const struct person *p);
+
+/****************************************************************************
+ * Accessors for: struct car
+ ****************************************************************************/
+
+void car_set_model(struct car *p, const char *model);
+const char *car_get_model(const struct car *p);
+
+void car_set_year(struct car *p, int year);
+int car_get_year(const struct car *p);
+
+const char *car_get_vin(const struct car *p);
+
+#endif /* _ACCESSORS_H_ */
+```
+
+> **Note:** The `secret` member is absent because of `//!accessors:none`. The `role` member has only a getter because of `//!accessors:readonly`. The `id` and `vin` members have only getters because they are declared `const`.
+
+### Generated `accessors.c`
+
+```c
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/* ... banner ... */
+
+#include <stdlib.h>
+#include <string.h>
+#include "accessors.h"
+
+#include "person.h"
+#include "compiler_attributes.h"
+
+/****************************************************************************
+ * Accessors for: struct person
+ ****************************************************************************/
+
+__public void person_set_name(struct person *p, const char *name)
+{
+    free(p->name);
+    p->name = name ? strdup(name) : NULL;
+}
+
+__public const char *person_get_name(const struct person *p)
+{
+    return p->name;
+}
+
+__public void person_set_age(struct person *p, int age)
+{
+    p->age = age;
+}
+
+__public int person_get_age(const struct person *p)
+{
+    return p->age;
+}
+
+__public const char *person_get_id(const struct person *p)
+{
+    return p->id;
+}
+
+__public const char *person_get_role(const struct person *p)
+{
+    return p->role;
+}
+
+/* ... struct car accessors follow the same pattern ... */
+```
+
+------
+
+## Limitations
+
+- `typedef struct` is not supported.
+- Nested structs (a `struct` member whose type is also a `struct`) are skipped.
+- Only `char *` pointer members are supported; other pointer types are skipped.
+
+------
+
+## Notes
+
+1. **Dynamic strings** (`char *`) — setters store a `strdup()` copy; passing `NULL` clears the field.
+2. **Fixed char arrays** (`char foo[N]`) — setters use `snprintf`, always NUL-terminated.
+3. **`const` members** — only a getter is generated, no setter.
+4. **`//!accessors:readonly`** — same effect as `const`: getter only.
+5. **`//!accessors:none`** — member is completely ignored by the generator.
+6. **`--prefix`** — prepended to every function name (e.g. `--prefix nvme_` turns `ctrl_set_name` into `nvme_ctrl_set_name`).
+7. **Line length** — generated code is automatically wrapped to stay within the 80-column limit required by `checkpatch.pl`.
diff --git a/libnvme/tools/generator/generate-accessors.py b/libnvme/tools/generator/generate-accessors.py
new file mode 100755
index 0000000000..e8085eedb7
--- /dev/null
+++ b/libnvme/tools/generator/generate-accessors.py
@@ -0,0 +1,672 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: LGPL-2.1-or-later
+"""
+generate-accessors.py — Generate setter/getter accessor functions for C structs.
+
+This file is part of libnvme.
+Copyright (c) 2025, Dell Technologies Inc. or its subsidiaries.
+Authors: Martin Belanger <Martin.Belanger@dell.com>
+
+Parses C header files and produces:
+  accessors.h   — function declarations with KernelDoc comments
+  accessors.c   — function implementations
+  accessors.ld  — linker version-script entries
+
+Limitations:
+  - Does not support typedef struct.
+  - Does not support struct within struct.
+
+Struct inclusion — annotate the opening brace line of the struct:
+  struct nvme_ctrl { /*!generate-accessors*/
+  struct nvme_ctrl { //!generate-accessors
+
+Member exclusion — annotate the member declaration line:
+  char *model; /*!accessors:none*/
+  char *model; //!accessors:none
+
+Read-only members (getter only, setter suppressed):
+  - Members declared with the 'const' qualifier, or
+  - Annotate the member declaration line:
+      char *state; /*!accessors:readonly*/
+      char *state; //!accessors:readonly
+
+Example usage:
+  ./generate-accessors.py private.h
+  ./generate-accessors.py --prefix nvme_ private.h
+"""
+
+import argparse
+import glob as glob_module
+import io
+import os
+import re
+import sys
+
+# ---------------------------------------------------------------------------
+# Output format — controls getter/setter function naming.
+#   {pre} = "{prefix}{struct_name}",  {mem} = member name
+#   Alternate style: "{pre}_{mem}_set" / "{pre}_{mem}_get"
+# ---------------------------------------------------------------------------
+SET_FMT = "{pre}_set_{mem}"
+GET_FMT = "{pre}_get_{mem}"
+
+SPDX_C  = "// SPDX-License-Identifier: LGPL-2.1-or-later"
+SPDX_H  = "/* SPDX-License-Identifier: LGPL-2.1-or-later */"
+SPDX_LD = "# SPDX-License-Identifier: LGPL-2.1-or-later"
+
+BANNER = (
+    "/**\n"
+    " * This file is part of libnvme.\n"
+    " *\n"
+    " * Copyright (c) 2025, Dell Technologies Inc. or its subsidiaries.\n"
+    " * Authors: Martin Belanger <Martin.Belanger@dell.com>\n"
+    " *\n"
+    " *   ____                           _           _    ____          _\n"
+    " *  / ___| ___ _ __   ___ _ __ __ _| |_ ___  __| |  / ___|___   __| | ___\n"
+    " * | |  _ / _ \\ '_ \\ / _ \\ '__/ _` | __/ _ \\/ _` | | |   / _ \\ / _` |/ _ \\\n"
+    " * | |_| |  __/ | | |  __/ | | (_| | ||  __/ (_| | | |__| (_) | (_| |  __/\n"
+    " *  \\____|\\___|_| |_|\\___|_|  \\__,_|\\__\\___|\\__,_|  \\____\\___/ \\__,_|\\___|\n"
+    " *\n"
+    " * Auto-generated struct member accessors (setter/getter)\n"
+    " *\n"
+    " * To update run: meson compile -C [BUILD-DIR] update-accessors\n"
+    " * Or:            make update-accessors\n"
+    " */"
+)
+
+# ---------------------------------------------------------------------------
+# Regular expressions
+# ---------------------------------------------------------------------------
+
+# Matches:  struct name { body };
+# [^}]* matches any character except '}', including newlines.
+STRUCT_RE = re.compile(
+    r'struct\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{([^}]*)\}\s*;'
+)
+
+# Matches:  [const] char name[size];
+CHAR_ARRAY_RE = re.compile(
+    r'^(const\s+)?char\s+([A-Za-z_][A-Za-z0-9_]*)\s*\[\s*([A-Za-z0-9_]+)\s*\]\s*;'
+)
+
+# Matches:  [const] type[*] name;
+MEMBER_RE = re.compile(
+    r'^(const\s+)?([A-Za-z_][A-Za-z0-9_]*)([*\s]+)([A-Za-z_][A-Za-z0-9_]*)\s*;'
+)
+
+
+# ---------------------------------------------------------------------------
+# Annotation helpers
+# ---------------------------------------------------------------------------
+
+def has_annotation(text, annotation):
+    """Return True if *text* contains /*!annotation*/ or //!annotation."""
+    return f'/*!{annotation}*/' in text or f'//!{annotation}' in text
+
+
+def strip_block_comments(text):
+    """Remove /* ... */ block comments (replaced with a single space each)."""
+    return re.sub(r'/\*.*?\*/', ' ', text, flags=re.DOTALL)
+
+
+def strip_inline_comment(line):
+    """Remove a // comment and everything after it."""
+    idx = line.find('//')
+    return line[:idx] if idx >= 0 else line
+
+
+# ---------------------------------------------------------------------------
+# Misc helpers
+# ---------------------------------------------------------------------------
+
+def sanitize_identifier(s):
+    """Replace characters that are invalid in a C identifier with '_'."""
+    if not s:
+        return s
+    chars = list(s)
+    if not (chars[0].isalpha() or chars[0] == '_'):
+        chars[0] = '_'
+    for i in range(1, len(chars)):
+        if not (chars[i].isalnum() or chars[i] == '_'):
+            chars[i] = '_'
+    return ''.join(chars)
+
+
+def type_sep(type_str):
+    """Return '' when *type_str* ends with '*', else ' '.
+
+    checkpatch.pl requires that '*' in a pointer return type is attached to
+    the function name, not the type keyword (e.g. ``const char *foo(...)``
+    not ``const char * foo(...)``).
+    """
+    return '' if type_str.endswith('*') else ' '
+
+
+def makedirs_for(filepath):
+    """Create all intermediate directories needed to hold *filepath*."""
+    os.makedirs(os.path.dirname(os.path.abspath(filepath)), exist_ok=True)
+
+
+# ---------------------------------------------------------------------------
+# Line-length helpers
+#
+# checkpatch.pl enforces an 80-column limit.  Because generated function
+# names vary in length we must measure before committing to a layout.
+#
+# fits_80(s)          — True when len(s) <= 80.
+# fits_80_ntabs(n, s) — True when the line would be <= 80 visible columns
+#                       given that it starts with n hard tabs (each tab
+#                       expands to 8 spaces, costing 7 extra visible columns
+#                       beyond the 1 byte that len() counts).
+# ---------------------------------------------------------------------------
+
+def fits_80(s):
+    return len(s) <= 80
+
+
+def fits_80_ntabs(n, s):
+    return len(s) + n * 7 <= 80
+
+
+# ---------------------------------------------------------------------------
+# Member data class
+# ---------------------------------------------------------------------------
+
+class Member:
+    """Represents one member of a parsed C struct."""
+
+    __slots__ = ('name', 'type', 'is_const', 'is_char_array', 'array_size')
+
+    def __init__(self, name, type_str, is_const, is_char_array, array_size):
+        self.name = name
+        self.type = type_str        # e.g. "const char *", "int", "__u32"
+        self.is_const = is_const    # True → getter only (no setter generated)
+        self.is_char_array = is_char_array
+        self.array_size = array_size  # only valid when is_char_array is True
+
+
+# ---------------------------------------------------------------------------
+# Parsing
+# ---------------------------------------------------------------------------
+
+def parse_members(struct_name, raw_body, verbose):
+    """Parse *raw_body* and return a list of Member objects.
+
+    Annotations are detected on the **raw** (un-stripped) line so that
+    comment masking cannot hide them.  Comments are stripped only afterwards,
+    for regex matching.
+    """
+    members = []
+
+    for raw_line in raw_body.splitlines():
+        # ----------------------------------------------------------------
+        # Annotation checks on the raw line — BEFORE stripping comments.
+        # ----------------------------------------------------------------
+        if has_annotation(raw_line, 'accessors:none'):
+            continue
+        readonly = has_annotation(raw_line, 'accessors:readonly')
+
+        # ----------------------------------------------------------------
+        # Strip comments for member-declaration parsing.
+        # ----------------------------------------------------------------
+        clean = strip_inline_comment(strip_block_comments(raw_line)).strip()
+
+        if not clean or ';' not in clean:
+            continue
+        if 'static' in clean or 'struct' in clean:
+            continue
+
+        # --- char array: [const] char name[size]; -----------------------
+        m = CHAR_ARRAY_RE.match(clean)
+        if m:
+            members.append(Member(
+                name=m.group(2),
+                type_str='const char *',
+                is_const=readonly or bool(m.group(1)),
+                is_char_array=True,
+                array_size=m.group(3),
+            ))
+            continue
+
+        # --- general member: [const] type[*] name; ----------------------
+        m = MEMBER_RE.match(clean)
+        if m:
+            is_const_qual = bool(m.group(1))
+            type_base = m.group(2)
+            ptr_part  = m.group(3)
+            name      = m.group(4)
+
+            is_ptr = '*' in ptr_part
+            if is_ptr:
+                if type_base != 'char':
+                    continue  # only char* pointers are supported
+                type_str = 'const char *'
+            else:
+                type_str = type_base
+
+            members.append(Member(
+                name=name,
+                type_str=type_str,
+                is_const=readonly or is_const_qual,
+                is_char_array=False,
+                array_size=None,
+            ))
+
+    return members
+
+
+def parse_file(text, verbose):
+    """Return list of (struct_name, [Member]) tuples found in *text*.
+
+    Only structs annotated with ``/*!generate-accessors*/`` or
+    ``//!generate-accessors`` as the first token inside the opening brace
+    are processed.
+    """
+    result = []
+
+    for match in STRUCT_RE.finditer(text):
+        struct_name = match.group(1)
+        raw_body    = match.group(2)
+
+        # The annotation must be the first token after the opening '{'.
+        first_token = raw_body.lstrip()
+        if not (first_token.startswith('/*!generate-accessors*/') or
+                first_token.startswith('//!generate-accessors')):
+            continue
+
+        members = parse_members(struct_name, raw_body, verbose)
+
+        if verbose and members:
+            print(f"Found struct: {struct_name} ({len(members)} members)")
+
+        if members:
+            result.append((struct_name, members))
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Header (*.h) code emitters
+# ---------------------------------------------------------------------------
+
+def _set_name(prefix, sname, mname):
+    return SET_FMT.format(pre=f'{prefix}{sname}', mem=mname)
+
+
+def _get_name(prefix, sname, mname):
+    return GET_FMT.format(pre=f'{prefix}{sname}', mem=mname)
+
+
+def emit_hdr_setter_str(f, prefix, sname, mname, is_dyn_str):
+    """Emit a header declaration for a string setter."""
+    f.write(
+        f'/**\n'
+        f' * {_set_name(prefix, sname, mname)}() - Set {mname}.\n'
+        f' * @p: The &struct {sname} instance to update.\n'
+    )
+    if is_dyn_str:
+        f.write(
+            f' * @{mname}: New string; a copy is stored. Pass NULL to clear.\n'
+        )
+    else:
+        f.write(
+            f' * @{mname}: New string; truncated to fit, always NUL-terminated.\n'
+        )
+    f.write(' */\n')
+
+    single = (f'void {_set_name(prefix, sname, mname)}'
+              f'(struct {sname} *p, const char *{mname});')
+    if fits_80(single):
+        f.write(single + '\n\n')
+    else:
+        f.write(
+            f'void {_set_name(prefix, sname, mname)}(\n'
+            f'\t\tstruct {sname} *p,\n'
+            f'\t\tconst char *{mname});\n\n'
+        )
+
+
+def emit_hdr_setter_val(f, prefix, sname, mname, mtype):
+    """Emit a header declaration for a value setter."""
+    f.write(
+        f'/**\n'
+        f' * {_set_name(prefix, sname, mname)}() - Set {mname}.\n'
+        f' * @p: The &struct {sname} instance to update.\n'
+        f' * @{mname}: Value to assign to the {mname} field.\n'
+        f' */\n'
+    )
+
+    single = (f'void {_set_name(prefix, sname, mname)}'
+              f'(struct {sname} *p, {mtype} {mname});')
+    if fits_80(single):
+        f.write(single + '\n\n')
+    else:
+        f.write(
+            f'void {_set_name(prefix, sname, mname)}(\n'
+            f'\t\tstruct {sname} *p,\n'
+            f'\t\t{mtype} {mname});\n\n'
+        )
+
+
+def emit_hdr_getter(f, prefix, sname, mname, mtype, is_dyn_str):
+    """Emit a header declaration for a getter."""
+    tail = ', or NULL if not set.' if is_dyn_str else '.'
+    f.write(
+        f'/**\n'
+        f' * {_get_name(prefix, sname, mname)}() - Get {mname}.\n'
+        f' * @p: The &struct {sname} instance to query.\n'
+        f' *\n'
+        f' * Return: The value of the {mname} field{tail}\n'
+        f' */\n'
+    )
+
+    sep    = type_sep(mtype)
+    single = (f'{mtype}{sep}{_get_name(prefix, sname, mname)}'
+              f'(const struct {sname} *p);')
+    if fits_80(single):
+        f.write(single + '\n\n')
+    else:
+        f.write(
+            f'{mtype}{sep}{_get_name(prefix, sname, mname)}(\n'
+            f'\t\tconst struct {sname} *p);\n\n'
+        )
+
+
+def generate_hdr(f, prefix, struct_name, members):
+    """Write header declarations for all members of one struct."""
+    for member in members:
+        is_dyn_str = (not member.is_char_array and
+                      member.type == 'const char *')
+        if not member.is_const:
+            if member.is_char_array or is_dyn_str:
+                emit_hdr_setter_str(f, prefix, struct_name,
+                                    member.name, is_dyn_str)
+            else:
+                emit_hdr_setter_val(f, prefix, struct_name,
+                                    member.name, member.type)
+        emit_hdr_getter(f, prefix, struct_name,
+                        member.name, member.type, is_dyn_str)
+
+
+# ---------------------------------------------------------------------------
+# Source (*.c) code emitters
+# ---------------------------------------------------------------------------
+
+PUB = '__public '
+
+
+def emit_src_setter_dynstr(f, prefix, sname, mname):
+    """Emit a dynamic-string setter (free old + strdup new)."""
+    sig = (f'{PUB}void {_set_name(prefix, sname, mname)}'
+           f'(struct {sname} *p, const char *{mname})')
+    if fits_80(sig):
+        f.write(sig + '\n')
+    else:
+        f.write(
+            f'{PUB}void {_set_name(prefix, sname, mname)}(\n'
+            f'\t\tstruct {sname} *p,\n'
+            f'\t\tconst char *{mname})\n'
+        )
+
+    f.write(f'{{\n\tfree(p->{mname});\n')
+    body = f'\tp->{mname} = {mname} ? strdup({mname}) : NULL;'
+    if fits_80_ntabs(1, body):
+        f.write(body + '\n')
+    else:
+        f.write(f'\tp->{mname} =\n\t\t{mname} ? strdup({mname}) : NULL;\n')
+    f.write('}\n\n')
+
+
+def emit_src_setter_chararray(f, prefix, sname, mname, array_size):
+    """Emit a fixed char-array setter (snprintf)."""
+    sig = (f'{PUB}void {_set_name(prefix, sname, mname)}'
+           f'(struct {sname} *p, const char *{mname})')
+    if fits_80(sig):
+        f.write(sig + '\n')
+    else:
+        f.write(
+            f'{PUB}void {_set_name(prefix, sname, mname)}(\n'
+            f'\t\tstruct {sname} *p,\n'
+            f'\t\tconst char *{mname})\n'
+        )
+
+    if array_size.isdigit():
+        f.write(
+            f'{{\n\tsnprintf(p->{mname}, {int(array_size)}, "%s", {mname});\n}}\n\n'
+        )
+    else:
+        f.write(
+            f'{{\n\tsnprintf(p->{mname}, {array_size}, "%s", {mname});\n}}\n\n'
+        )
+
+
+def emit_src_setter_val(f, prefix, sname, mname, mtype):
+    """Emit a value setter (direct assignment)."""
+    sig = (f'{PUB}void {_set_name(prefix, sname, mname)}'
+           f'(struct {sname} *p, {mtype} {mname})')
+    if fits_80(sig):
+        f.write(
+            sig + '\n'
+            f'{{\n\tp->{mname} = {mname};\n}}\n\n'
+        )
+    else:
+        f.write(
+            f'{PUB}void {_set_name(prefix, sname, mname)}(\n'
+            f'\t\tstruct {sname} *p,\n'
+            f'\t\t{mtype} {mname})\n'
+            f'{{\n\tp->{mname} = {mname};\n}}\n\n'
+        )
+
+
+def emit_src_getter(f, prefix, sname, mname, mtype):
+    """Emit a getter (return member value)."""
+    sep = type_sep(mtype)
+    sig = (f'{PUB}{mtype}{sep}{_get_name(prefix, sname, mname)}'
+           f'(const struct {sname} *p)')
+    if fits_80(sig):
+        f.write(
+            sig + '\n'
+            f'{{\n\treturn p->{mname};\n}}\n\n'
+        )
+    else:
+        f.write(
+            f'{PUB}{mtype}{sep}{_get_name(prefix, sname, mname)}(\n'
+            f'\t\tconst struct {sname} *p)\n'
+            f'{{\n\treturn p->{mname};\n}}\n\n'
+        )
+
+
+def generate_src(f, prefix, struct_name, members):
+    """Write source implementations for all members of one struct."""
+    for member in members:
+        if not member.is_const:
+            is_dyn_str = (not member.is_char_array and
+                          member.type == 'const char *')
+            if is_dyn_str:
+                emit_src_setter_dynstr(f, prefix, struct_name, member.name)
+            elif member.is_char_array:
+                emit_src_setter_chararray(f, prefix, struct_name,
+                                          member.name, member.array_size)
+            else:
+                emit_src_setter_val(f, prefix, struct_name,
+                                    member.name, member.type)
+        emit_src_getter(f, prefix, struct_name, member.name, member.type)
+
+
+# ---------------------------------------------------------------------------
+# Linker script (*.ld) emitter
+# ---------------------------------------------------------------------------
+
+def generate_ld(f, prefix, struct_name, members):
+    """Write linker version-script entries for all members of one struct."""
+    for member in members:
+        f.write(
+            f'\t\t{_get_name(prefix, struct_name, member.name)};\n'
+            f'\t\t{_set_name(prefix, struct_name, member.name)};\n'
+        )
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Generate C struct accessor functions.',
+        add_help=False,   # -h is reserved for --h-out
+    )
+    parser.add_argument('-c', '--c-out',   default='accessors.c',
+                        dest='c_fname',   metavar='FILE',
+                        help='Generated *.c file. Default: accessors.c')
+    parser.add_argument('-h', '--h-out',   default='accessors.h',
+                        dest='h_fname',   metavar='FILE',
+                        help='Generated *.h file. Default: accessors.h')
+    parser.add_argument('-l', '--ld-out',  default='accessors.ld',
+                        dest='l_fname',   metavar='FILE',
+                        help='Generated *.ld file. Default: accessors.ld')
+    parser.add_argument('-p', '--prefix',  default='',
+                        dest='prefix',    metavar='STR',
+                        help='Prefix prepended to every generated function name.')
+    parser.add_argument('-v', '--verbose', action='store_true',
+                        help='Verbose output.')
+    parser.add_argument('-H', '--help',    action='help',
+                        default=argparse.SUPPRESS,
+                        help='Show this message and exit.')
+    parser.add_argument('headers', nargs='+',
+                        help='Header files to parse (wildcards accepted).')
+    args = parser.parse_args()
+
+    # Expand wildcards in the header file arguments.
+    header_files = []
+    for pattern in args.headers:
+        expanded = glob_module.glob(pattern)
+        if expanded:
+            header_files.extend(os.path.realpath(p) for p in sorted(expanded))
+        else:
+            print(f"Warning: No match for {pattern}", file=sys.stderr)
+
+    if not header_files:
+        print("error: no input headers found", file=sys.stderr)
+        sys.exit(1)
+
+    # -----------------------------------------------------------------------
+    # Pass 1 — parse all header files, accumulate generated fragments.
+    # -----------------------------------------------------------------------
+    files_to_include = []   # basenames of headers that contributed structs
+    forward_declares = []   # struct names needing forward declarations
+    hdr_parts = []          # fragments for accessors.h
+    src_parts = []          # fragments for accessors.c
+    ld_parts  = []          # fragments for accessors.ld
+
+    for in_hdr in header_files:
+        if args.verbose:
+            print(f"\nProcessing {in_hdr}")
+
+        try:
+            with open(in_hdr) as f:
+                text = f.read()
+        except OSError as e:
+            print(f"error: cannot read '{in_hdr}': {e}", file=sys.stderr)
+            sys.exit(1)
+
+        structs = parse_file(text, args.verbose)
+
+        if not structs:
+            if args.verbose:
+                print(f"No annotated structs found in {in_hdr}.")
+            continue
+
+        files_to_include.append(os.path.basename(in_hdr))
+
+        for struct_name, members in structs:
+            forward_declares.append(struct_name)
+
+            section_banner = (
+                f'/****************************************************************************\n'
+                f' * Accessors for: struct {struct_name}\n'
+                f' ****************************************************************************/\n'
+                f'\n'
+            )
+
+            hdr_buf = io.StringIO()
+            hdr_buf.write(section_banner)
+            generate_hdr(hdr_buf, args.prefix, struct_name, members)
+            hdr_parts.append(hdr_buf.getvalue())
+
+            src_buf = io.StringIO()
+            src_buf.write(section_banner)
+            generate_src(src_buf, args.prefix, struct_name, members)
+            src_parts.append(src_buf.getvalue())
+
+            ld_buf = io.StringIO()
+            generate_ld(ld_buf, args.prefix, struct_name, members)
+            ld_parts.append(ld_buf.getvalue())
+
+    # -----------------------------------------------------------------------
+    # Pass 2 — write output files.
+    # -----------------------------------------------------------------------
+
+    # --- accessors.h -------------------------------------------------------
+    guard = '_' + sanitize_identifier(os.path.basename(args.h_fname).upper()) + '_'
+
+    makedirs_for(args.h_fname)
+    with open(args.h_fname, 'w') as f:
+        f.write(
+            f'{SPDX_H}\n'
+            f'\n'
+            f'{BANNER}\n'
+            f'#ifndef {guard}\n'
+            f'#define {guard}\n'
+            f'\n'
+            f'#include <stdlib.h>\n'
+            f'#include <string.h>\n'
+            f'#include <stdbool.h>\n'
+            f'#include <stdint.h>\n'
+            f'#include <linux/types.h> /* __u32, __u64, etc. */\n'
+            f'\n'
+        )
+        f.write('/* Forward declarations. These are internal (opaque) structs. */\n')
+        for s in forward_declares:
+            f.write(f'struct {s};\n')
+        f.write('\n')
+        f.write(''.join(hdr_parts))
+        f.write(f'#endif /* {guard} */\n')
+
+    # --- accessors.c -------------------------------------------------------
+    makedirs_for(args.c_fname)
+    with open(args.c_fname, 'w') as f:
+        f.write(
+            f'{SPDX_C}\n'
+            f'\n'
+            f'{BANNER}\n'
+            f'#include <stdlib.h>\n'
+            f'#include <string.h>\n'
+            f'#include "{os.path.basename(args.h_fname)}"\n'
+            f'\n'
+        )
+        for fname in files_to_include:
+            f.write(f'#include "{fname}"\n')
+        f.write('#include "compiler_attributes.h"\n')
+        f.write('\n')
+        f.write(''.join(src_parts))
+
+    # --- accessors.ld ------------------------------------------------------
+    makedirs_for(args.l_fname)
+    with open(args.l_fname, 'w') as f:
+        f.write(
+            f'{SPDX_LD}\n'
+            f'\n'
+            f'{BANNER}\n'
+            f'\n'
+            f'LIBNVME_ACCESSORS_3 {{\n'
+            f'\tglobal:\n'
+        )
+        f.write(''.join(ld_parts))
+        f.write('};\n')
+
+    if args.verbose:
+        print(f"\nGenerated {args.h_fname} and {args.c_fname}")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/libnvme/tools/generator/meson.build b/libnvme/tools/generator/meson.build
new file mode 100644
index 0000000000..6b20e9068f
--- /dev/null
+++ b/libnvme/tools/generator/meson.build
@@ -0,0 +1,40 @@
+# 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>
+#
+# The accessor files (accessors.h, accessors.c, accessors.ld) are
+# pre-generated and committed to the source tree.  They are NOT
+# regenerated during a normal build.
+#
+# To regenerate them after changing private.h (e.g. adding or removing
+# a /*!generate-accessors*/ annotation):
+#
+#   meson compile -C <build-dir> update-accessors
+
+# ---------------------------------------------------------------------------
+# Developer-only helper: run the generator and regenerate if structs change.
+# NOT executed during a normal build (build_by_default: false).
+# Usage: meson compile -C <build-dir> update-accessors
+# ---------------------------------------------------------------------------
+
+# Generated source files go to src/nvme/ (alongside the library sources).
+# The generated version script goes to src/ (alongside the other .ld files).
+libnvme_src = libnvme_srcroot / 'src'
+libnvme_src_nvme = libnvme_src / 'nvme'
+
+_py3 = find_program('python3', required: true)
+
+run_target(
+    'update-accessors',
+    command: [
+        'update-accessors.sh',
+        _py3,
+        files('generate-accessors.py'),
+        libnvme_src_nvme,
+        libnvme_src,
+        libnvme_src_nvme / 'private.h',
+    ],
+)
diff --git a/libnvme/tools/generator/update-accessors.sh b/libnvme/tools/generator/update-accessors.sh
new file mode 100755
index 0000000000..a21a90268b
--- /dev/null
+++ b/libnvme/tools/generator/update-accessors.sh
@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: LGPL-2.1-or-later
+#
+# update-accessors.sh - Regenerate accessor files only when they change.
+#
+# This file is part of libnvme.
+# Copyright (c) 2025, Dell Technologies Inc. or its subsidiaries.
+# Authors: Martin Belanger <Martin.Belanger@dell.com>
+#
+# This script is invoked via: meson compile -C <build-dir> update-accessors
+# It is NOT run during a normal build.
+#
+# accessors.h and accessors.c are updated automatically when the generator
+# produces different output.
+#
+# accessors.ld is NOT updated automatically because its version section labels
+# (e.g. LIBNVME_ACCESSORS_3) must be assigned by the maintainer.  Instead,
+# this script reports which symbols have been added or removed so the maintainer
+# knows exactly what to change in accessors.ld.
+#
+# Arguments (supplied by the Meson run_target):
+#   $1      path to the python3 interpreter
+#   $2      path to generate-accessors.py
+#   $3      source directory for accessors.c and accessors.h (src/nvme/)
+#   $4      source directory for accessors.ld (src/)
+#   $5 ...  one or more input headers (wildcards are accepted)
+
+set -euo pipefail
+
+PYTHON="${1:?missing python3 interpreter}"
+GENERATOR="${2:?missing generator script}"
+NVME_SRCDIR="${3:?missing nvme source directory}"
+LD_SRCDIR="${4:?missing ld source directory}"
+shift 4
+INPUT_HEADERS=("$@")
+[ ${#INPUT_HEADERS[@]} -gt 0 ] || { echo "error: no input headers specified" >&2; exit 1; }
+
+TMPDIR=$(mktemp -d)
+trap 'rm -rf "$TMPDIR"' EXIT
+
+echo "Regenerating accessor files..."
+
+"$PYTHON" "$GENERATOR" \
+    --h-out  "$TMPDIR/accessors.h"  \
+    --c-out  "$TMPDIR/accessors.c"  \
+    --ld-out "$TMPDIR/accessors.ld" \
+    "${INPUT_HEADERS[@]}"
+
+# ---------------------------------------------------------------------------
+# Update accessors.h and accessors.c atomically when content changes.
+# ---------------------------------------------------------------------------
+changed=0
+for f in accessors.h accessors.c; do
+    dest="$NVME_SRCDIR/$f"
+    if [ -f "$dest" ] && cmp -s "$TMPDIR/$f" "$dest"; then
+        printf "  unchanged: %s\n" "$f"
+    else
+        # Write to a sibling temp file then rename for atomicity
+        tmp_dest=$(mktemp "$NVME_SRCDIR/.${f}.XXXXXX")
+        cp "$TMPDIR/$f" "$tmp_dest"
+        mv -f "$tmp_dest" "$dest"
+        printf "  updated:   %s\n" "$f"
+        changed=$((changed + 1))
+    fi
+done
+
+echo ""
+if [ "$changed" -gt 0 ]; then
+    printf "%d file(s) updated in %s\n" "$changed" "$NVME_SRCDIR"
+    echo "Don't forget to commit the updated files."
+else
+    echo "All accessor source files are up to date."
+fi
+
+# ---------------------------------------------------------------------------
+# Compare symbol lists to detect accessors.ld drift.
+#
+# accessors.ld is manually maintained because its version section labels
+# (e.g. LIBNVME_ACCESSORS_3) must be assigned by a human.  We therefore
+# only report what has changed; we never overwrite the file.
+#
+# Symbol lines in an ld version script look like:
+#   <whitespace> symbol_name ;
+# ---------------------------------------------------------------------------
+extract_syms() {
+    grep -E '^\s+[a-zA-Z_][a-zA-Z0-9_]*;' "$1" \
+        | sed 's/[[:space:]]//g; s/;//' \
+        | sort
+}
+
+extract_syms "$TMPDIR/accessors.ld"  > "$TMPDIR/syms_new.txt"
+extract_syms "$LD_SRCDIR/accessors.ld"  > "$TMPDIR/syms_old.txt"
+
+added=$(comm   -23 "$TMPDIR/syms_new.txt" "$TMPDIR/syms_old.txt")
+removed=$(comm -13 "$TMPDIR/syms_new.txt" "$TMPDIR/syms_old.txt")
+
+if [ -z "$added" ] && [ -z "$removed" ]; then
+    echo "accessors.ld: symbol list is up to date."
+else
+    echo "WARNING: accessors.ld needs manual attention."
+    echo ""
+    if [ -n "$added" ]; then
+        echo "  Symbols to ADD (place in a new version section, e.g. LIBNVME_ACCESSORS_X_Y):"
+        printf '%s\n' "$added" | sed 's/^/    /'
+    fi
+    if [ -n "$removed" ]; then
+        echo ""
+        echo "  Symbols to REMOVE from accessors.ld:"
+        printf '%s\n' "$removed" | sed 's/^/    /'
+    fi
+fi
diff --git a/logging.c b/logging.c
index 9faa639e05..0d87fba367 100644
--- a/logging.c
+++ b/logging.c
@@ -1,18 +1,18 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <errno.h>
 #include <inttypes.h>
 #include <signal.h>
 #include <stdint.h>
 #include <string.h>
-#include <errno.h>
 
-#include "platform/includes.h"
+#include <platform/includes.h>
+
+#include <ccan/endian/endian.h>
 
 #include <libnvme.h>
 #include <libnvme-mi.h>
 
-#include <ccan/endian/endian.h>
-
 #include "logging.h"
 #include "util/sighdl.h"
 #include "nvme-print.h"
diff --git a/meson.build b/meson.build
index 17f9a30875..d03a01ac28 100644
--- a/meson.build
+++ b/meson.build
@@ -51,11 +51,12 @@ is_windows = host_machine.system() == 'windows'
 # dependencies are present. Also, -Dpython=enabled forces -Dlibnvme=enabled.
 want_nvme = get_option('nvme').disabled() == false
 want_libnvme = get_option('libnvme').disabled() == false
+want_fabrics = get_option('fabrics').disabled() == false and not is_windows
 want_docs = get_option('docs')
 want_docs_build = get_option('docs-build')
 
 feature_python = get_option('python')
-if is_windows or feature_python.disabled()
+if not want_fabrics or feature_python.disabled()
     py3_dep = dependency('', required: false)  # Needed for muon
     want_python = false
 else
@@ -128,6 +129,8 @@ endif
 conf.set('SYSCONFDIR', '"@0@"'.format(sysconfdir))
 conf.set('RUNDIR', '"@0@"'.format(rundir))
 
+conf.set('CONFIG_FABRICS', want_fabrics, description: 'Is fabrics enabled')
+
 if is_windows
     ws2_32_dep = cc.find_library('ws2_32', required: true)
     kernel32_dep = cc.find_library('kernel32', required: true)
@@ -293,14 +296,14 @@ else
 endif
 
 
-if is_windows or get_option('liburing').disabled()
+if not want_fabrics or get_option('liburing').disabled()
     liburing_dep = dependency('', required: false)
 else
     liburing_dep = dependency('liburing', version: '>=2.2', required: get_option('liburing'))
 endif
 conf.set('CONFIG_LIBURING', liburing_dep.found(), description: 'Is liburing available?')
 
-if get_option('openssl').disabled()
+if not want_fabrics or get_option('openssl').disabled()
     openssl_dep = dependency('', required: false)
 else
     openssl_dep = dependency(
@@ -329,14 +332,14 @@ if openssl_dep.found()
 endif
 conf.set('CONFIG_OPENSSL', openssl_dep.found(), description: 'Is OpenSSL/LibreSSL available?')
 
-if is_windows or get_option('keyutils').disabled()
+if not want_fabrics or get_option('keyutils').disabled()
     keyutils_dep = dependency('', required: false)
 else
     keyutils_dep = dependency('libkeyutils', required : get_option('keyutils'))
 endif
 conf.set('CONFIG_KEYUTILS', keyutils_dep.found(), description: 'Is libkeyutils available?')
 
-if is_windows or get_option('libdbus').disabled()
+if not want_fabrics or get_option('libdbus').disabled()
     libdbus_dep = dependency('', required: false)
 else
     # Check for libdbus availability. Optional, only required for MCTP dbus scan
@@ -485,22 +488,26 @@ if want_nvme
     subdir('util')      # declares: util_sources
 
     sources = [
-        'nvme.c',
+        'libnvme-wrap.c',
+        'logging.c',
+        'nvme-cmds.c',
         'nvme-models.c',
-        'nvme-print.c',
-        'nvme-print-stdout.c',
         'nvme-print-binary.c',
+        'nvme-print-stdout.c',
+        'nvme-print.c',
+        'nvme.c',
         'plugin.c',
-        'libnvme-wrap.c',
-        'logging.c',
     ]
+    if want_fabrics
+        sources += 'fabrics.c'
+    endif
+
     if is_windows
         sources += [
             'windows-stubs.c',
         ]
     else
         sources += [
-            'fabrics.c',
             'nvme-rpmb.c',
         ]
     endif
@@ -673,6 +680,7 @@ summary(dep_dict, section: 'Dependencies', bool_yn: true)
 wanted_dict = {
     'nvme':             want_nvme,
     'libnvme':          want_libnvme,
+    'fabrics':          want_fabrics,
     'python bindings ': want_python,
     'build docs':       want_docs_build,
 }
diff --git a/meson_options.txt b/meson_options.txt
index 6fd51daf77..88c8f364cb 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -11,6 +11,12 @@ option(
   value: 'enabled',
   description: 'Build libnvme library'
 )
+option(
+  'fabrics',
+  type : 'feature',
+  value: 'enabled',
+  description : 'NVMeoF support'
+)
 option(
   'python',
   type : 'feature',
diff --git a/nvme-builtin.h b/nvme-builtin.h
index 585174d9b2..3f3d82a497 100644
--- a/nvme-builtin.h
+++ b/nvme-builtin.h
@@ -102,12 +102,15 @@ COMMAND_LIST(
 	ENTRY("show-regs", "Shows the controller registers or properties. Requires character device", show_registers)
 	ENTRY("set-reg", "Set a register and show the resulting value", set_register)
 	ENTRY("get-reg", "Get a register and show the resulting value", get_register)
+#ifdef CONFIG_FABRICS
 	ENTRY("discover", "Discover NVMeoF subsystems", discover_cmd)
 	ENTRY("connect-all", "Discover and Connect to NVMeoF subsystems", connect_all_cmd)
 	ENTRY("connect", "Connect to NVMeoF subsystem", connect_cmd)
 	ENTRY("disconnect", "Disconnect from NVMeoF subsystem", disconnect_cmd)
 	ENTRY("disconnect-all", "Disconnect from all connected NVMeoF subsystems", disconnect_all_cmd)
 	ENTRY("config", "Configuration of NVMeoF subsystems", config_cmd)
+	ENTRY("dim", "Send Discovery Information Management command to a Discovery Controller", dim_cmd)
+#endif
 	ENTRY("gen-hostnqn", "Generate NVMeoF host NQN", gen_hostnqn_cmd)
 	ENTRY("show-hostnqn", "Show NVMeoF host NQN", show_hostnqn_cmd)
 	ENTRY("gen-dhchap-key", "Generate NVMeoF DH-HMAC-CHAP host key", gen_dhchap_key)
@@ -120,8 +123,7 @@ COMMAND_LIST(
 	ENTRY("virt-mgmt", "Manage Flexible Resources between Primary and Secondary Controller", virtual_mgmt)
 	ENTRY("rpmb", "Replay Protection Memory Block commands", rpmb_cmd)
 	ENTRY("lockdown", "Submit a Lockdown command,return result", lockdown_cmd)
-	ENTRY("dim", "Send Discovery Information Management command to a Discovery Controller", dim_cmd) \
-	ENTRY("show-topology", "Show the topology", show_topology_cmd) \
+	ENTRY("show-topology", "Show the topology", show_topology_cmd)
 	ENTRY("io-mgmt-recv", "I/O Management Receive", io_mgmt_recv)
 	ENTRY("io-mgmt-send", "I/O Management Send", io_mgmt_send)
 	ENTRY("nvme-mi-recv", "Submit a NVMe-MI Receive command, return results", nmi_recv)
diff --git a/nvme-cmds.c b/nvme-cmds.c
new file mode 100644
index 0000000000..11148379d0
--- /dev/null
+++ b/nvme-cmds.c
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2020 Western Digital Corporation or its affiliates.
+ *
+ * Authors: Keith Busch <keith.busch@wdc.com>
+ *	    Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
+ */
+
+#include <libnvme.h>
+
+#include "nvme-cmds.h"
+
+static int nvme_ns_attachment(struct nvme_transport_handle *hdl, bool ish,
+		__u32 nsid, __u16 num_ctrls, __u16 *ctrlist, bool attach)
+{
+	struct nvme_ctrl_list cntlist = { 0 };
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_ctrl_list(&cntlist, num_ctrls, ctrlist);
+	if (ish && nvme_transport_handle_is_mi(hdl))
+		nvme_init_mi_cmd_flags(&cmd, ish);
+
+	if (attach)
+		nvme_init_ns_attach_ctrls(&cmd, nsid, &cntlist);
+	else
+		nvme_init_ns_detach_ctrls(&cmd, nsid, &cntlist);
+
+	return nvme_submit_admin_passthru(hdl, &cmd);
+}
+
+int nvme_namespace_attach_ctrls(struct nvme_transport_handle *hdl, bool ish,
+		__u32 nsid, __u16 num_ctrls, __u16 *ctrlist)
+{
+	return nvme_ns_attachment(hdl, ish, nsid, num_ctrls, ctrlist, true);
+}
+
+int nvme_namespace_detach_ctrls(struct nvme_transport_handle *hdl, bool ish,
+		__u32 nsid, __u16 num_ctrls, __u16 *ctrlist)
+{
+	return nvme_ns_attachment(hdl, ish, nsid, num_ctrls, ctrlist, false);
+}
+
+
diff --git a/nvme-cmds.h b/nvme-cmds.h
new file mode 100644
index 0000000000..97cd8ba578
--- /dev/null
+++ b/nvme-cmds.h
@@ -0,0 +1,1749 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2020 Western Digital Corporation or its affiliates.
+ *
+ * Authors: Keith Busch <keith.busch@wdc.com>
+ *	    Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
+ *	    Daniel Wagner <dwagner@suse.de>
+ */
+
+#ifndef NVME_CMDS
+#define NVME_CMDS
+
+#include <nvme/cmds.h>
+#include <nvme/ioctl.h>
+#include <nvme/types.h>
+
+/**
+ * nvme_flush() - Send an nvme flush command
+ * @hdl:	Transport handle
+ * @nsid:	Namespace identifier
+ *
+ * The Flush command requests that the contents of volatile write cache be made
+ * non-volatile.
+ *
+ * Return: 0 on success, the nvme command status if a response was
+ * received (see &enum nvme_status_field) or a negative error otherwise.
+ */
+static inline int nvme_flush(struct nvme_transport_handle *hdl, __u32 nsid)
+{
+	struct nvme_passthru_cmd cmd = {};
+
+	cmd.opcode = nvme_cmd_flush;
+	cmd.nsid = nsid;
+
+	return nvme_submit_io_passthru(hdl, &cmd);
+}
+
+/**
+ * nvme_identify() - Submit a generic Identify command
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	Namespace ID (if applicable to the requested CNS).
+ * @csi:	Command Set Identifier.
+ * @cns:	Identify Controller or Namespace Structure (CNS) value,
+ *		specifying the type of data to be returned.
+ * @data:	Pointer to the buffer where the identification data will
+ *		be stored.
+ * @len:	Length of the data buffer in bytes.
+ *
+ * The generic wrapper for submitting an Identify command, allowing the host
+ * to specify any combination of Identify parameters.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_identify(struct nvme_transport_handle *hdl, __u32 nsid, enum nvme_csi csi,
+		enum nvme_identify_cns cns, void *data, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_identify(&cmd, nsid, csi, cns, data, len);
+
+	return nvme_submit_admin_passthru(hdl, &cmd);
+}
+
+/**
+ * nvme_identify_ctrl() - Submit an Identify Controller command
+ * @hdl:	Transport handle for the controller.
+ * @id:		Pointer to the buffer (&struct nvme_id_ctrl) where the
+ *		controller identification data will be stored upon
+ *		successful completion.
+ *
+ * Submits the Identify Controller command to retrieve the controller's
+ * capabilities and configuration data.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_identify_ctrl(struct nvme_transport_handle *hdl,
+		struct nvme_id_ctrl *id)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_identify_ctrl(&cmd, id);
+
+	return nvme_submit_admin_passthru(hdl, &cmd);
+}
+
+/**
+ * nvme_identify_active_ns_list() - Submit an Identify Active Namespace
+ * List command
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	The Namespace ID to query
+ * @ns_list:	Pointer to the buffer (&struct nvme_ns_list) where the
+ *		active namespace list will be stored.
+ *
+ * Submits the Identify command to retrieve a list of active Namespace IDs.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_identify_active_ns_list(struct nvme_transport_handle *hdl,
+		__u32 nsid, struct nvme_ns_list *ns_list)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_identify_active_ns_list(&cmd, nsid, ns_list);
+
+	return nvme_submit_admin_passthru(hdl, &cmd);
+}
+
+/**
+ * nvme_identify_ns() - Submit an Identify Namespace command
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	The Namespace ID to identify.
+ * @ns:		Pointer to the buffer (&struct nvme_id_ns) where the namespace
+ *		identification data will be stored.
+ *
+ * Submits the Identify command to retrieve the Namespace Identification
+ * data structure for a specified namespace.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+
+static inline int
+nvme_identify_ns(struct nvme_transport_handle *hdl,
+		__u32 nsid, struct nvme_id_ns *ns)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_identify_ns(&cmd, nsid, ns);
+
+	return nvme_submit_admin_passthru(hdl, &cmd);
+}
+
+/**
+ * nvme_identify_csi_ns() - Submit a CSI-specific Identify Namespace command
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	The Namespace ID to identify.
+ * @csi:	The Command Set Identifier
+ * @uidx:	The UUID Index for the command.
+ * @id_ns:	Pointer to the buffer (@struct nvme_nvm_id_ns) where the
+ *		CSI-specific namespace identification data will be stored.
+ *
+ * Submits the Identify command to retrieve Namespace Identification data
+ * specific to a Command Set Identifier (CSI).
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_identify_csi_ns(struct nvme_transport_handle *hdl, __u32 nsid,
+		enum nvme_csi csi, __u8 uidx, struct nvme_nvm_id_ns *id_ns)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_identify_csi_ns(&cmd, nsid, csi, uidx, id_ns);
+
+	return nvme_submit_admin_passthru(hdl, &cmd);
+}
+
+/**
+ * nvme_identify_uuid_list() - Submit an Identify UUID List command
+ * @hdl:	Transport handle for the controller.
+ * @uuid_list:	Pointer to the buffer (&struct nvme_id_uuid_list) where the
+ *		UUID list will be stored.
+ *
+ * Submits the Identify command to retrieve a list of UUIDs associated
+ * with the controller.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_identify_uuid_list(struct nvme_transport_handle *hdl,
+		struct nvme_id_uuid_list *uuid_list)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_identify_uuid_list(&cmd, uuid_list);
+
+	return nvme_submit_admin_passthru(hdl, &cmd);
+}
+
+/**
+ * nvme_identify_csi_ns_user_data_format() - Submit an Identify CSI Namespace
+ * User Data Format command
+ * @hdl:	Transport handle for the controller.
+ * @csi:	Command Set Identifier.
+ * @fidx:	Format Index, specifying which format entry to return.
+ * @uidx:	The UUID Index for the command.
+ * @data:	Pointer to the buffer where the format data will be stored.
+ *
+ * Submits the Identify command to retrieve a CSI-specific Namespace User
+ * Data Format data structure.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_identify_csi_ns_user_data_format(struct nvme_transport_handle *hdl,
+		enum nvme_csi csi, __u16 fidx, __u8 uidx, void *data)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_identify_csi_ns_user_data_format(&cmd, csi, fidx, uidx, data);
+
+	return nvme_submit_admin_passthru(hdl, &cmd);
+}
+
+/**
+ * nvme_identify_ns_granularity() - Submit an Identify Namespace Granularity
+ * List command
+ * @hdl:	Transport handle for the controller.
+ * @gr_list:	Pointer to the buffer (&struct nvme_id_ns_granularity_list)
+ *		where the granularity list will be stored.
+ *
+ * Submits the Identify command to retrieve the Namespace Granularity List.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_identify_ns_granularity(struct nvme_transport_handle *hdl,
+		struct nvme_id_ns_granularity_list *gr_list)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_identify_ns_granularity(&cmd, gr_list);
+
+	return nvme_submit_admin_passthru(hdl, &cmd);
+}
+
+/**
+ * nvme_identify_ns_descs_list() - Submit an Identify Namespace ID Descriptor
+ * List command
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	The Namespace ID to query.
+ * @descs:	Pointer to the buffer (&struct nvme_ns_id_desc) where the
+ *		descriptor list will be stored.
+ *
+ * Submits the Identify command to retrieve the Namespace ID Descriptor List
+ * for a specified namespace.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_identify_ns_descs_list(struct nvme_transport_handle *hdl,
+		__u32 nsid, struct nvme_ns_id_desc *descs)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_identify_ns_descs_list(&cmd, nsid, descs);
+
+	return nvme_submit_admin_passthru(hdl, &cmd);
+}
+
+/**
+ * nvme_zns_identify_ns() - Submit a ZNS-specific Identify Namespace command
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	The Namespace ID to identify.
+ * @data:	Pointer to the buffer (&struct nvme_zns_id_ns) where the ZNS
+ *		namespace identification data will be stored.
+ *
+ * Submits the Identify command to retrieve the Zoned Namespace (ZNS)
+ * specific identification data structure for a specified namespace.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_zns_identify_ns(struct nvme_transport_handle *hdl,
+		__u32 nsid, struct nvme_zns_id_ns *data)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_zns_identify_ns(&cmd, nsid, data);
+
+	return nvme_submit_admin_passthru(hdl, &cmd);
+}
+
+/**
+ * nvme_get_log_simple() - Retrieve a log page using default parameters
+ * @hdl:	Transport handle for the controller.
+ * @lid:	Log Identifier, specifying the log page to retrieve
+ *		(@enum nvme_cmd_get_log_lid).
+ * @data:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the data buffer in bytes.
+ *
+ * Submits the Get Log Page command using the common settings:
+ * NVME\_NSID\_ALL, Retain Asynchronous Event (RAE) set to false,
+ * and assuming the NVM Command Set.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_simple(struct nvme_transport_handle *hdl,
+		enum nvme_cmd_get_log_lid lid, void *data, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log(&cmd, NVME_NSID_ALL, lid, NVME_CSI_NVM, data, len);
+
+	return nvme_get_log(hdl, &cmd, false, NVME_LOG_PAGE_PDU_SIZE);
+}
+
+/**
+ * nvme_get_log_supported_log_pages() - Retrieve the Supported Log Pages
+ * Log Page
+ * @hdl:	Transport handle for the controller.
+ * @log:	Pointer to the buffer (@struct nvme_supported_log_pages) where
+ *		the log page data will be stored.
+ *
+ * Submits the Get Log Page command specifically for the Supported Log Pages
+ * Log.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_supported_log_pages(struct nvme_transport_handle *hdl,
+		struct nvme_supported_log_pages *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log(&cmd, NVME_NSID_ALL, NVME_LOG_LID_SUPPORTED_LOG_PAGES,
+		NVME_CSI_NVM, log, sizeof(*log));
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
+}
+
+
+/**
+ * nvme_get_log_error() - Retrieve the Error Information Log Page
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	Namespace ID to request the log for (usually NVME_NSID_ALL).
+ * @nr_entries:	The maximum number of error log entries to retrieve.
+ * @err_log:	Pointer to the buffer (array of @struct nvme_error_log_page)
+ *		where the log page data will be stored.
+ *
+ * This log page describes extended error information for a command that
+ * completed with error, or may report an error that is not specific to a
+ * particular command. The total size requested is determined by
+ * @nr_entries * sizeof(@struct nvme_error_log_page).
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_error(struct nvme_transport_handle *hdl, __u32 nsid,
+		unsigned int nr_entries, struct nvme_error_log_page *err_log)
+{
+	struct nvme_passthru_cmd cmd;
+	size_t len = sizeof(*err_log) * nr_entries;
+
+	nvme_init_get_log(&cmd, nsid, NVME_LOG_LID_ERROR,
+		NVME_CSI_NVM, err_log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_fw_slot() - Retrieve the Firmware Slot Information Log Page
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	Namespace ID to request the log for (use NVME_NSID_ALL).
+ * @fw_log:	Pointer to the buffer (@struct nvme_firmware_slot) where the log
+ *		page data will be stored.
+ *
+ * This log page describes the firmware revision stored in each firmware slot
+ * supported. The firmware revision is indicated as an ASCII string. The log
+ * page also indicates the active slot number.
+ *
+ * This command is typically issued for the controller scope, thus using
+ * NVME_NSID_ALL.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_fw_slot(struct nvme_transport_handle *hdl, __u32 nsid,
+		struct nvme_firmware_slot *fw_log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log(&cmd, nsid, NVME_LOG_LID_FW_SLOT,
+		NVME_CSI_NVM, fw_log, sizeof(*fw_log));
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*fw_log));
+}
+
+/**
+ * nvme_get_log_changed_ns_list() - Retrieve the Namespace Change Log Page
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	Namespace ID to request the log for (use NVME_NSID_ALL).
+ * @ns_log:	Pointer to the buffer (@struct nvme_ns_list) where the log
+ *		page data will be stored.
+ *
+ * This log page describes namespaces attached to this controller that have
+ * changed since the last time the namespace was identified, been added, or
+ * deleted.
+ *
+ * This command is typically issued for the controller scope, thus using
+ * NVME_NSID_ALL. The Retain Asynchronous Event (RAE) is true to retain
+ * asynchronous events associated with the log page
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_changed_ns_list(struct nvme_transport_handle *hdl, __u32 nsid,
+		struct nvme_ns_list *ns_log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log(&cmd, nsid, NVME_LOG_LID_CHANGED_NS,
+		NVME_CSI_NVM, ns_log, sizeof(*ns_log));
+
+	return nvme_get_log(hdl, &cmd, true, sizeof(*ns_log));
+}
+
+/**
+ * nvme_get_log_cmd_effects() - Retrieve the Command Effects Log Page
+ * @hdl:	Transport handle for the controller.
+ * @csi:	Command Set Identifier for the requested log page.
+ * @effects_log:Pointer to the buffer (@struct nvme_cmd_effects_log) where the
+ *		log page data will be stored.
+ *
+ * This log page describes the commands that the controller supports and the
+ * effects of those commands on the state of the NVM subsystem.
+ *
+ * It automatically sets the Log Identifier (LID) and Retain Asynchronous
+ * Event (RAE) to false. This command is typically issued for the controller
+ * scope, thus using NVME_NSID_ALL.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_cmd_effects(struct nvme_transport_handle *hdl,
+		enum nvme_csi csi, struct nvme_cmd_effects_log *effects_log)
+{
+	struct nvme_passthru_cmd cmd;
+	size_t len = sizeof(*effects_log);
+
+	nvme_init_get_log_cmd_effects(&cmd, csi, effects_log);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_device_self_test() - Retrieve the Device Self-Test Log Page
+ * @hdl:	Transport handle for the controller.
+ * @log:	Pointer to the buffer (@struct nvme_self_test_log) where the log
+ *		page data will be stored.
+ *
+ * This log page indicates the status of an in-progress self-test and the
+ * percent complete of that operation, and the results of the previous 20
+ * self-test operations.
+ *
+ * It automatically sets the Log Identifier (LID) and Retain Asynchronous
+ * Event (RAE) to false. This command is typically issued for the controller
+ * scope, thus using NVME_NSID_ALL.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_device_self_test(struct nvme_transport_handle *hdl,
+		struct nvme_self_test_log *log)
+{
+	struct nvme_passthru_cmd cmd;
+	size_t len = sizeof(*log);
+
+	nvme_init_get_log(&cmd, NVME_NSID_ALL, NVME_LOG_LID_DEVICE_SELF_TEST,
+		NVME_CSI_NVM, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_create_telemetry_host_mcda() - Create the Host Initiated
+ * Telemetry Log
+ * @hdl:	Transport handle for the controller.
+ * @mcda:	Maximum Created Data Area. Specifies the maximum amount of data
+ *		that may be returned by the controller.
+ * @log:	Pointer to the buffer (@struct nvme_telemetry_log) where the log
+ *		page data will be stored.
+ *
+ * Submits the Get Log Page command to initiate the creation of a Host Initiated
+ * Telemetry Log. It sets the Log Identifier (LID) to Telemetry Host and
+ * includes the Maximum Created Data Area (MCDA) in the Log Specific Parameter
+ * (LSP) field along with the Create bit.
+ *
+ * It automatically sets Retain Asynchronous Event (RAE) to false.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_create_telemetry_host_mcda(struct nvme_transport_handle *hdl,
+		enum nvme_telemetry_da mcda, struct nvme_telemetry_log *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_create_telemetry_host_mcda(&cmd, mcda, log);
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
+}
+
+/**
+ * nvme_get_log_create_telemetry_host() - Create the Host Initiated Telemetry
+ * Log (Controller Determined Size)
+ * @hdl:	Transport handle for the controller.
+ * @log:	Pointer to the buffer (@struct nvme_telemetry_log) where the log
+ *		page data will be stored.
+ *
+ * Submits the Get Log Page command to initiate the creation of a Host Initiated
+ * Telemetry Log. This is a convenience wrapper that automatically uses the
+ * Controller Determined size for the Maximum Created Data Area (MCDA).
+ *
+ * It automatically sets Retain Asynchronous Event (RAE) to false.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_create_telemetry_host(struct nvme_transport_handle *hdl,
+		struct nvme_telemetry_log *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_create_telemetry_host(&cmd, log);
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
+}
+
+/**
+ * nvme_get_log_telemetry_host() - Retrieve the Host-Initiated
+ * Telemetry Log Page (Retain)
+ * @hdl:	Transport handle for the controller.
+ * @lpo:	Offset (in bytes) into the telemetry data to start the
+ *		retrieval.
+ * @log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command to retrieve a previously captured
+ * Host-Initiated Telemetry Log, starting at a specified offset (@lpo). The Log
+ * Specific Parameter (LSP) field is set to indicate the capture should be
+ * retained (not deleted after read).
+ *
+ * It automatically sets the Log Identifier (LID) and Retain Asynchronous Event
+ * (RAE) to false.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_telemetry_host(struct nvme_transport_handle *hdl,
+		__u64 lpo, void *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_telemetry_host(&cmd, lpo, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_telemetry_ctrl() - Retrieve the Controller-Initiated
+ * Telemetry Log Page
+ * @hdl:	Transport handle for the controller.
+ * @rae:	Retain asynchronous events
+ * @lpo:	Offset (in bytes) into the telemetry data to start the
+ *		retrieval.
+ * @log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Controller-Initiated
+ * Telemetry Log, allowing retrieval of data starting at a specified offset
+ * (@lpo).
+ *
+ * It automatically sets the Log Identifier (LID).
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_telemetry_ctrl(struct nvme_transport_handle *hdl, bool rae,
+		__u64 lpo, void *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_telemetry_ctrl(&cmd, lpo, log, len);
+
+	return nvme_get_log(hdl, &cmd, rae, len);
+}
+
+/**
+ * nvme_get_log_endurance_group() - Retrieve the Endurance Group Log Page
+ * @hdl:	Transport handle for the controller.
+ * @endgid:	Starting Endurance Group Identifier (ENDGID) to return in
+ *		the list.
+ * @log:	Pointer to the buffer (@struct nvme_endurance_group_log) where
+ *		the log page data will be stored.
+ *
+ * This log page indicates if an Endurance Group Event has occurred for a
+ * particular Endurance Group. The ENDGID is placed in the Log Specific
+ * Identifier (LSI) field of the Get Log Page command.
+ *
+ * It automatically sets the Log Identifier (LID) and Retain Asynchronous
+ * Event (RAE) to false. This command is typically issued for the controller
+ * scope, thus using NVME_NSID_NONE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_endurance_group(struct nvme_transport_handle *hdl,
+		__u16 endgid, struct nvme_endurance_group_log *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_endurance_group(&cmd, endgid, log);
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
+}
+
+/**
+ * nvme_get_log_predictable_lat_nvmset() - Retrieve the Predictable Latency
+ * Per NVM Set Log Page
+ * @hdl:	Transport handle for the controller.
+ * @nvmsetid:	The NVM Set Identifier (NVMSETID) for which to retrieve the log.
+ * @log:	Pointer to the buffer (@struct nvme_nvmset_predictable_lat_log)
+ *		where the log page data will be stored.
+ *
+ * Submits the Get Log Page command specifically for the Predictable Latency Per
+ * NVM Set Log. The NVMSETID is placed in the Log Specific Identifier (LSI)
+ * field of the command.
+ *
+ * It automatically sets the Log Identifier (LID) and Retain Asynchronous
+ * Event (RAE) to false. This command is typically issued for the controller
+ * scope, thus using NVME_NSID_NONE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_predictable_lat_nvmset(struct nvme_transport_handle *hdl,
+		__u16 nvmsetid, struct nvme_nvmset_predictable_lat_log *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_predictable_lat_nvmset(&cmd, nvmsetid, log);
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
+}
+
+/**
+ * nvme_get_log_predictable_lat_event() - Retrieve the Predictable Latency Event
+ * Aggregate Log Page
+ * @hdl:	Transport handle for the controller.
+ * @rae:	Retain asynchronous events
+ * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
+ * @log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Predictable Latency
+ * Event Aggregate Log, allowing retrieval of data starting at a specified
+ * offset (@lpo).
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_PREDICTABLE_LAT_AGG.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_predictable_lat_event(struct nvme_transport_handle *hdl,
+		bool rae, __u64 lpo, void *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_predictable_lat_event(&cmd, lpo, log, len);
+
+	return nvme_get_log(hdl, &cmd, rae, len);
+}
+
+/**
+ * nvme_get_log_fdp_configurations() - Retrieve the Flexible Data Placement
+ * (FDP) Configurations Log Page
+ * @hdl:	Transport handle for the controller.
+ * @egid:	Endurance Group Identifier (EGID) to return in the
+ *		list (used in LSI).
+ * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
+ * @log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the FDP Configurations Log.
+ * The EGID is placed in the Log Specific Identifier (LSI) field.
+ *
+ * It automatically sets the Log Identifier (LID) and Retain Asynchronous
+ * Event (RAE) to false. This command is typically issued for the controller
+ * scope, thus using NVME_NSID_NONE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_fdp_configurations(struct nvme_transport_handle *hdl,
+		__u16 egid, __u64 lpo, void *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_fdp_configurations(&cmd, egid, lpo, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_reclaim_unit_handle_usage() - Retrieve the FDP Reclaim Unit
+ * Handle (RUH) Usage Log Page
+ * @hdl:	Transport handle for the controller.
+ * @egid:	Endurance Group Identifier (EGID) (used in LSI).
+ * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
+ * @log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the FDP Reclaim Unit Handle
+ * Usage Log. The EGID is placed in the Log Specific Identifier (LSI) field.
+ *
+ * It automatically sets the Log Identifier (LID) and Retain Asynchronous
+ * Event (RAE) to false. This command is typically issued for the controller
+ * scope, thus using NVME_NSID_NONE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_reclaim_unit_handle_usage(struct nvme_transport_handle *hdl,
+		__u16 egid, __u64 lpo, void *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_reclaim_unit_handle_usage(&cmd, egid, lpo, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_fdp_stats() - Retrieve the Flexible Data Placement (FDP)
+ * Statistics Log Page
+ * @hdl:	Transport handle for the controller.
+ * @egid:	Endurance Group Identifier (EGID) (used in LSI).
+ * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
+ * @log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the FDP Statistics Log.
+ * The EGID is placed in the Log Specific Identifier (LSI) field.
+ *
+ * It automatically sets the Log Identifier (LID) and Retain Asynchronous
+ * Event (RAE) to false. This command is typically issued for the controller
+ * scope, thus using NVME_NSID_NONE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_fdp_stats(struct nvme_transport_handle *hdl,
+		__u16 egid, __u64 lpo, void *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_fdp_stats(&cmd, egid, lpo, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_fdp_events() - Retrieve the Flexible Data Placement (FDP)
+ * Events Log Page
+ * @hdl:	Transport handle for the controller.
+ * @egid:	Endurance Group Identifier (EGID) (used in LSI).
+ * @host_events:Whether to report host-initiated events (true) or
+ *		controller-initiated events (false).
+ * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
+ * @log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the FDP Events Log.
+ * The EGID is placed in the Log Specific Identifier (LSI) field, and the
+ * @host_events flag is used to set the Log Specific Parameter (LSP) field.
+ *
+ * It automatically sets the Log Identifier (LID) and Retain Asynchronous
+ * Event (RAE) to false. This command is typically issued for the controller
+ * scope, thus using NVME_NSID_NONE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_fdp_events(struct nvme_transport_handle *hdl,
+		__u16 egid, bool host_events, __u64 lpo, void *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_fdp_events(&cmd, egid, host_events, lpo, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_ana() - Retrieve the Asymmetric Namespace Access (ANA) Log Page
+ * @hdl:	Transport handle for the controller.
+ * @rae:	Retain asynchronous events
+ * @lsp:	Log specific parameter, see &enum nvme_get_log_ana_lsp.
+ * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
+ * @log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * This log consists of a header describing the log and descriptors containing
+ * the ANA information for groups that contain namespaces attached to the
+ * controller. The @lsp parameter is placed in the Log Specific Parameter field
+ * of the command.
+ *
+ * See &struct nvme_ana_log for the definition of the returned structure.
+ *
+ * It automatically sets the Log Identifier (LID) to NVME_LOG_LID_ANA.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_ana(struct nvme_transport_handle *hdl, bool rae,
+		 enum nvme_log_ana_lsp lsp, __u64 lpo, void *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_ana(&cmd, lsp, lpo, log, len);
+
+	return nvme_get_log(hdl, &cmd, rae, len);
+}
+
+/**
+ * nvme_get_log_ana_groups() - Retrieve the Asymmetric Namespace Access (ANA)
+ * Groups Only Log Page
+ * @hdl:	Transport handle for the controller.
+ * @rae:	Retain asynchronous events
+ * @log:	Pointer to the buffer (@struct nvme_ana_log) where the log page
+ *		data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * This function retrieves only the ANA Group Descriptors by setting the Log
+ * Specific Parameter (LSP) field to NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY. It is a
+ * convenience wrapper around nvme_get_log_ana, using a Log Page Offset (LPO) of
+ * 0.
+ *
+ * See &struct nvme_ana_log for the definition of the returned structure.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_ana_groups(struct nvme_transport_handle *hdl, bool rae,
+		struct nvme_ana_log *log, __u32 len)
+{
+	return nvme_get_log_ana(hdl, rae, NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY,
+		0, log, len);
+}
+
+/**
+ * nvme_get_log_lba_status() - Retrieve the LBA Status Log Page
+ * @hdl:	Transport handle for the controller.
+ * @rae:	Retain asynchronous events
+ * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
+ * @log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the LBA Status Log.
+ *
+ * It automatically sets the Log Identifier (LID) to NVME_LOG_LID_LBA_STATUS.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_lba_status(struct nvme_transport_handle *hdl,
+		bool rae, __u64 lpo, void *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_lba_status(&cmd, lpo, log, len);
+
+	return nvme_get_log(hdl, &cmd, rae, len);
+}
+
+/**
+ * nvme_get_log_endurance_grp_evt() - Retrieve the Endurance Group Event
+ * Aggregate Log Page
+ * @hdl:	Transport handle for the controller.
+ * @rae:	Retain asynchronous events
+ * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
+ * @log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Endurance Group Event
+ * Aggregate Log, allowing retrieval of data starting at a specified offset
+ * (@lpo).
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_ENDURANCE_GRP_EVT.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_endurance_grp_evt(struct nvme_transport_handle *hdl,
+		bool rae, __u64 lpo, void *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_endurance_grp_evt(&cmd, lpo, log, len);
+
+	return nvme_get_log(hdl, &cmd, rae, len);
+}
+
+/**
+ * nvme_get_log_fid_supported_effects() - Retrieve the Feature Identifiers
+ * Supported and Effects Log Page
+ * @hdl:	Transport handle for the controller.
+ * @csi:	Command set identifier, see &enum nvme_csi for known values
+ * @log:	Pointer to the buffer (@struct nvme_fid_supported_effects_log)
+ *		where the log page data will be stored.
+ *
+ * Submits the Get Log Page command specifically for the Feature Identifiers
+ * Supported and Effects Log. It automatically sets the Log Identifier (LID).
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_fid_supported_effects(struct nvme_transport_handle *hdl,
+		enum nvme_csi csi, struct nvme_fid_supported_effects_log *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_fid_supported_effects(&cmd, csi, log);
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
+}
+
+/**
+ * nvme_get_log_mi_cmd_supported_effects() - Retrieve the Management Interface
+ * (MI) Commands Supported and Effects Log Page
+ * @hdl:	Transport handle for the controller.
+ * @log:	Pointer to the buffer
+ *		(@struct nvme_mi_cmd_supported_effects_log) where the log page
+ *		data will be stored.
+ *
+ * Submits the Get Log Page command specifically for the MI Commands Supported
+ * and Effects Log. It automatically sets the Log Identifier (LID). This command
+ * is typically issued with a namespace ID of 0xFFFFFFFF (NVME_NSID_NONE).
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_mi_cmd_supported_effects(struct nvme_transport_handle *hdl,
+		struct nvme_mi_cmd_supported_effects_log *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_mi_cmd_supported_effects(&cmd, log);
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
+}
+
+/**
+ * nvme_get_log_boot_partition() - Retrieve the Boot Partition Log Page
+ * @hdl:	Transport handle for the controller.
+ * @lsp:	The Log Specific Parameter (LSP) field for this Log
+ *		Identifier (LID).
+ * @part:	Pointer to the buffer (@struct nvme_boot_partition) where
+ *		the log page data will be stored.
+ * @len:	Length of the buffer provided in @part.
+ *
+ * Submits the Get Log Page command specifically for the Boot Partition Log.
+ * The LSP field is set based on the @lsp parameter.
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_BOOT_PARTITION.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_boot_partition(struct nvme_transport_handle *hdl,
+		__u8 lsp, struct nvme_boot_partition *part, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_boot_partition(&cmd, lsp, part, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_rotational_media_info() - Retrieve the Rotational Media
+ * Information Log Page
+ * @hdl:	Transport handle for the controller.
+ * @endgid:	The Endurance Group Identifier (ENDGID) to retrieve the
+ *		log for (used in LSI).
+ * @log:	Pointer to the buffer (@struct nvme_rotational_media_info_log)
+ *		where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Rotational Media
+ * Information Log. The ENDGID is placed in the Log Specific Identifier (LSI)
+ * field of the command.
+ *
+ * It automatically sets the Log Identifier (LID) and Retain Asynchronous
+ * Event (RAE) to false. This command is typically issued for the controller
+ * scope, thus using NVME_NSID_NONE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_rotational_media_info(struct nvme_transport_handle *hdl,
+		__u16 endgid, struct nvme_rotational_media_info_log *log,
+		__u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_rotational_media_info(&cmd, endgid, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_dispersed_ns_participating_nss() - Retrieve the Dispersed
+ * Namespace Participating NVM Subsystems Log Page
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	Namespace ID to request the log for.
+ * @log:	Pointer to the buffer
+ *		(@struct nvme_dispersed_ns_participating_nss_log)
+ *		where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Dispersed Namespace
+ * Participating NVM Subsystems Log. It automatically sets the Log Identifier
+ * (LID) and Retain Asynchronous Event (RAE) to false.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_dispersed_ns_participating_nss(struct nvme_transport_handle *hdl,
+		__u32 nsid, struct nvme_dispersed_ns_participating_nss_log *log,
+		__u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_dispersed_ns_participating_nss(&cmd, nsid, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_mgmt_addr_list() - Retrieve the Management Address List Log Page
+ * @hdl:	Transport handle for the controller.
+ * @log:	Pointer to the buffer (@struct nvme_mgmt_addr_list_log) where
+ *		the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Management Address List
+   Log.
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_MGMT_ADDR_LIST, Retain Asynchronous Event (RAE) to false, and
+ * uses NVME_NSID_NONE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_mgmt_addr_list(struct nvme_transport_handle *hdl,
+		struct nvme_mgmt_addr_list_log *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_mgmt_addr_list(&cmd, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_phy_rx_eom() - Retrieve the Physical Interface Receiver Eye
+ * Opening Measurement Log Page
+ * @hdl:	Transport handle for the controller.
+ * @lsp:	Log Specific Parameter (LSP), which controls the action
+ *		and measurement quality.
+ * @controller:	Target Controller ID (used in LSI).
+ * @log:	Pointer to the buffer (@struct nvme_phy_rx_eom_log) where
+ *		the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Physical Interface
+ * Receiver Eye Opening Measurement Log. The Controller ID is placed in the
+ * Log Specific Identifier (LSI) field.
+ *
+ * It automatically sets the Log Identifier (LID) to NVME_LOG_LID_PHY_RX_EOM,
+ * and Retain Asynchronous Event (RAE) to false. This command is typically
+ * issued for the controller scope, thus using NVME_NSID_NONE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_phy_rx_eom(struct nvme_transport_handle *hdl,
+		__u8 lsp, __u16 controller, struct nvme_phy_rx_eom_log *log,
+		__u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_phy_rx_eom(&cmd, lsp, controller, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_reachability_groups() - Retrieve the Reachability Groups
+ * Log Page
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	Namespace ID to request the log for.
+ * @rgo:	Return Groups Only. Set to true to return only the Reachability
+ *		Group Descriptors.
+ * @log:	Pointer to the buffer (@struct nvme_reachability_groups_log)
+ *		where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Reachability Groups
+ * Log. The @rgo parameter is placed in the Log Specific Parameter (LSP) field.
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_REACHABILITY_GROUPS.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_reachability_groups(struct nvme_transport_handle *hdl,
+		__u32 nsid, bool rgo, struct nvme_reachability_groups_log *log,
+		__u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_reachability_groups(&cmd, rgo, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_reachability_associations() - Retrieve the Reachability
+ * Associations Log Page
+ * @hdl:	Transport handle for the controller.
+ * @rae:	Retain asynchronous events
+ * @rao:	Return Associations Only. Set to true to return only the
+ *		Reachability Association Descriptors.
+ * @log:	Pointer to the buffer
+ *		(@struct nvme_reachability_associations_log) where the log
+ *		page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Reachability
+ * Associations Log. The @rao parameter is placed in the Log Specific Parameter
+ * (LSP) field.
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_REACHABILITY_ASSOCIATIONS.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_reachability_associations(struct nvme_transport_handle *hdl,
+		bool rae, bool rao,
+		struct nvme_reachability_associations_log *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_reachability_associations(&cmd, rao, log, len);
+
+	return nvme_get_log(hdl, &cmd, rae, len);
+}
+
+/**
+ * nvme_get_log_changed_alloc_ns_list() - Retrieve the Changed Allocated
+ * Namespace List Log Page
+ * @hdl:	Transport handle for the controller.
+ * @log:	Pointer to the buffer (@struct nvme_ns_list) where the log page
+ *		data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Changed Allocated
+ * Namespace List Log.
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_CHANGED_ALLOC_NS_LIST.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_changed_alloc_ns_list(struct nvme_transport_handle *hdl,
+		struct nvme_ns_list *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_changed_ns(&cmd, log);
+
+	return nvme_get_log(hdl, &cmd, true, len);
+}
+
+/**
+ * nvme_get_log_discovery() - Retrieve the Discovery Log Page
+ * @hdl:	Transport handle for the controller.
+ * @lpo:	Offset (in bytes) into the log page data to start the retrieval.
+ * @log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Discovery Log.
+ * Supported only by NVMe-oF Discovery controllers, returning discovery records.
+ *
+ * It automatically sets the Log Identifier (LID) to NVME_LOG_LID_DISCOVERY.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_discovery(struct nvme_transport_handle *hdl,
+		__u64 lpo, __u32 len, void *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_discovery(&cmd, lpo, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_host_discovery() - Retrieve the Host Discovery Log Page
+ * @hdl:	Transport handle for the controller.
+ * @rae:	Retain asynchronous events
+ * @allhoste:	All Host Entries. Set to true to report all host entries.
+ * @log:	Pointer to the buffer (@struct nvme_host_discover_log)
+ *		where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Host Discovery Log.
+ * The @allhoste parameter is placed in the Log Specific Parameter (LSP) field.
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_HOST_DISCOVERY.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_host_discovery(struct nvme_transport_handle *hdl,
+			   bool rae, bool allhoste,
+			   struct nvme_host_discover_log *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_host_discovery(&cmd, allhoste, log, len);
+
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_ave_discovery() - Retrieve the Asynchronous Event
+ * Group (AVE) Discovery Log Page
+ * @hdl:	Transport handle for the controller.
+ * @rae:	Retain asynchronous events
+ * @log:	Pointer to the buffer (@struct nvme_ave_discover_log) where
+ *		the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Asynchronous Event
+ * Group (AVE) Discovery Log. It automatically sets the Log Identifier (LID).
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_ave_discovery(struct nvme_transport_handle *hdl,
+		bool rae, struct nvme_ave_discover_log *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_ave_discovery(&cmd, log, len);
+
+	return nvme_get_log(hdl, &cmd, rae, len);
+}
+
+/**
+ * nvme_get_log_pull_model_ddc_req() - Retrieve the Pull Model DDC Request
+ * Log Page
+ * @hdl:	Transport handle for the controller.
+ * @rae:	Retain asynchronous events
+ * @log:	Pointer to the buffer (@struct nvme_pull_model_ddc_req_log)
+ *		where the log page data will be stored.
+ * @len:	Length of the buffer provided in @log.
+ *
+ * Submits the Get Log Page command specifically for the Pull Model DDC Request
+ * Log. It automatically sets the Log Identifier (LID).
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_pull_model_ddc_req(struct nvme_transport_handle *hdl,
+		bool rae, struct nvme_pull_model_ddc_req_log *log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_pull_model_ddc_req(&cmd, log, len);
+
+	return nvme_get_log(hdl, &cmd, rae, len);
+}
+
+/**
+ * nvme_get_log_media_unit_stat() - Retrieve the Media Unit Status Log Page
+ * @hdl:	Transport handle for the controller.
+ * @domid:	The Domain Identifier (DOMID) selection, if supported
+ *		(used in LSI).
+ * @mus:	Pointer to the buffer (@struct nvme_media_unit_stat_log)
+ *		where the log page data will be stored.
+ *
+ * Submits the Get Log Page command specifically for the Media Unit Status Log.
+ * The DOMID is placed in the Log Specific Identifier (LSI) field of the
+ * command.
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_MEDIA_UNIT_STATUS, and Retain Asynchronous Event (RAE) to false.
+ * This command is typically issued for the controller scope, thus using
+ * NVME_NSID_NONE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_media_unit_stat(struct nvme_transport_handle *hdl,
+		__u16 domid, struct nvme_media_unit_stat_log *mus)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_media_unit_stat(&cmd, domid, mus);
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*mus));
+}
+
+/**
+ * nvme_get_log_support_cap_config_list() - Retrieve the Supported Capacity
+ * Configuration List Log Page
+ * @hdl:	Transport handle for the controller.
+ * @domid:	The Domain Identifier (DOMID) selection, if
+ *		supported (used in LSI).
+ * @cap:	Pointer to the buffer
+ *		(@struct nvme_supported_cap_config_list_log) where the log
+ *		page data will be stored.
+ *
+ * Submits the Get Log Page command specifically for the Supported Capacity
+ * Configuration List Log. The DOMID is placed in the Log Specific Identifier
+ * (LSI) field of the command.
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_SUPPORTED_CAP_CONFIG_LIST, and Retain Asynchronous Event (RAE)
+ * to false. This command is typically issued for the controller scope, thus
+ * using NVME_NSID_NONE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_support_cap_config_list(struct nvme_transport_handle *hdl,
+		__u16 domid, struct nvme_supported_cap_config_list_log *cap)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_support_cap_config_list(&cmd, domid, cap);
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*cap));
+}
+
+/**
+ * nvme_get_log_reservation() - Retrieve the Reservation Notification Log Page
+ * @hdl:	Transport handle for the controller.
+ * @log:	Pointer to the buffer (@struct nvme_resv_notification_log)
+ *		where the log page data will be stored.
+ *
+ * Submits the Get Log Page command specifically for the Reservation
+ * Notification Log. It automatically sets the Log Identifier (LID).
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_reservation(struct nvme_transport_handle *hdl,
+		struct nvme_resv_notification_log *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_reservation(&cmd, log);
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
+}
+
+/**
+ * nvme_get_log_sanitize() - Retrieve the Sanitize Status Log Page
+ * @hdl:	Transport handle for the controller.
+ * @rae:	Retain asynchronous events
+ * @log:	Pointer to the buffer (@struct nvme_sanitize_log_page)
+ *		where the log page data will be stored.
+ *
+ * Submits the Get Log Page command specifically for the Sanitize Status Log.
+ * The log page reports sanitize operation time estimates and information about
+ * the most recent sanitize operation.
+ *
+ * It automatically sets the Log Identifier (LID) to NVME_LOG_LID_SANITIZE.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_sanitize(struct nvme_transport_handle *hdl,
+		bool rae, struct nvme_sanitize_log_page *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_sanitize(&cmd, log);
+
+	return nvme_get_log(hdl, &cmd, rae, sizeof(*log));
+}
+
+/**
+ * nvme_get_log_zns_changed_zones() - Retrieve the ZNS Changed Zones Log Page
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	Namespace ID to request the log for.
+ * @rae:	Retain asynchronous events
+ * @log:	Pointer to the buffer (@struct nvme_zns_changed_zone_log)
+ *		where the log page data will be stored.
+ *
+ * Submits the Get Log Page command specifically for the ZNS Changed Zones Log.
+ * This log lists zones that have changed state due to an exceptional event.
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_ZNS_CHANGED_ZONES.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_zns_changed_zones(struct nvme_transport_handle *hdl,
+		__u32 nsid, bool rae, struct nvme_zns_changed_zone_log *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_zns_changed_zones(&cmd, nsid, log);
+
+	return nvme_get_log(hdl, &cmd, rae, sizeof(*log));
+}
+
+/**
+ * nvme_get_log_persistent_event() - Retrieve the Persistent Event Log Page
+ * @hdl:	Transport handle for the controller.
+ * @action:	Action the controller should take during processing this
+ *		command, see &enum nvme_pevent_log_action (used in LSP).
+ * @pevent_log:	Pointer to the buffer where the log page data will be stored.
+ * @len:	Length of the buffer provided in @pevent_log.
+ *
+ * Submits the Get Log Page command specifically for the Persistent Event Log.
+ * The @action parameter is placed in the Log Specific Parameter (LSP) field.
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_PERSISTENT_EVENT and Retain Asynchronous Event (RAE) to false.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_persistent_event(struct nvme_transport_handle *hdl,
+		enum nvme_pevent_log_action action, void *pevent_log, __u32 len)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_persistent_event(&cmd, action, pevent_log, len);
+
+	/*
+	 * Call the generic log execution function.
+	 * The data length is determined by the 'len' parameter.
+	 */
+	return nvme_get_log(hdl, &cmd, false, len);
+}
+
+/**
+ * nvme_get_log_lockdown() - Retrieve the Command and Feature Lockdown Log Page
+ * @hdl:	Transport handle for the controller.
+ * @cnscp:	Contents and Scope (CNSCP) of Command and Feature
+ *		Identifier Lists (used in LSP).
+ * @log:	Pointer to the buffer (@struct nvme_lockdown_log) where the log
+ *		page data will be stored.
+ *
+ * Submits the Get Log Page command specifically for the Command and Feature
+ * Lockdown Log. The @cnscp parameter is placed in the Log Specific Parameter
+ * (LSP) field.
+ *
+ * It automatically sets the Log Identifier (LID) to
+ * NVME_LOG_LID_CMD_AND_FEAT_LOCKDOWN and Retain Asynchronous Event (RAE) to
+ * false.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_lockdown(struct nvme_transport_handle *hdl,
+		__u8 cnscp, struct nvme_lockdown_log *log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_lockdown(&cmd, cnscp, log);
+
+	return nvme_get_log(hdl, &cmd, false, sizeof(*log));
+}
+
+/**
+ * nvme_get_log_smart() - Retrieve the SMART / Health Information Log Page
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	Namespace ID to request the log for.
+ * @smart_log:	Pointer to the buffer (@struct nvme_smart_log) where the log
+ *		page data will be stored.
+ *
+ * Submits the Get Log Page command specifically for the SMART / Health
+ * Information Log. It automatically sets the Log Identifier (LID) and
+ * Retain Asynchronous Event (RAE) to false.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_log_smart(struct nvme_transport_handle *hdl,
+		__u32 nsid, struct nvme_smart_log *smart_log)
+{
+	struct nvme_passthru_cmd cmd;
+
+	nvme_init_get_log_smart(&cmd, nsid, smart_log);
+
+	return nvme_get_log(hdl, &cmd, false, NVME_LOG_PAGE_PDU_SIZE);
+}
+
+
+/**
+ * nvme_set_features() - Submit a generic Set Features command
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	Namespace ID	sto apply the feature to.
+ * @fid:	Feature Identifier (FID) to be set.
+ * @sv:		Save Value (SV): If true, the feature value persists
+ *		across power states.
+ * @cdw11:	Command Dword 11 parameter (feature-specific).
+ * @cdw12:	Command Dword 12 parameter (feature-specific).
+ * @cdw13:	Command Dword 13 parameter (feature-specific).
+ * @uidx:	UUID Index (UIDX) for the command, encoded into cdw14
+ * @cdw15:	Command Dword 15 parameter (feature-specific).
+ * @data:	Pointer to the data buffer to transfer (if applicable).
+ * @len:	Length of the data buffer in bytes.
+ * @result:	The command completion result (CQE dword0) on success.
+ *
+ * Submits the Set Features command, allowing all standard command
+ * fields (cdw11-cdw15) and data buffer fields to be specified directly.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_set_features(struct nvme_transport_handle *hdl, __u32 nsid, __u8 fid,
+		bool sv, __u32 cdw11, __u32 cdw12, __u32 cdw13, __u8 uidx,
+		__u32 cdw15, void *data, __u32 len, __u64 *result)
+{
+	struct nvme_passthru_cmd cmd;
+	int err;
+
+	nvme_init_set_features(&cmd, fid, sv);
+	cmd.nsid = nsid;
+	cmd.cdw11 = cdw11;
+	cmd.cdw12 = cdw12;
+	cmd.cdw13 = cdw13;
+	cmd.cdw14 = NVME_FIELD_ENCODE(uidx,
+				      NVME_SET_FEATURES_CDW14_UUID_SHIFT,
+				      NVME_SET_FEATURES_CDW14_UUID_MASK);
+	cmd.cdw15 = cdw15;
+	cmd.data_len = len;
+	cmd.addr = (__u64)(uintptr_t)data;
+
+	err = nvme_submit_admin_passthru(hdl, &cmd);
+	if (result)
+		*result = cmd.result;
+	return err;
+}
+
+/**
+ * nvme_set_features_simple() - Submit a Set Features command using only cdw11
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	Namespace ID to apply the feature to.
+ * @fid:	Feature Identifier (FID) to be set.
+ * @sv:		Save Value (SV): If true, the feature value persists across
+ *		power states.
+ * @cdw11:	Command Dword 11 parameter (feature-specific value).
+ * @result:	The command completion result (CQE dword0) on success.
+ *
+ * Submits the Set Features command for features that only require
+ * parameters in cdw11.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_set_features_simple(struct nvme_transport_handle *hdl,
+		__u32 nsid, __u8 fid, bool sv, __u32 cdw11, __u64 *result)
+{
+	struct nvme_passthru_cmd cmd;
+	int err;
+
+	nvme_init_set_features(&cmd, fid, sv);
+	cmd.nsid = nsid;
+	cmd.cdw11 = cdw11;
+
+	err = nvme_submit_admin_passthru(hdl, &cmd);
+	if (result)
+		*result = cmd.result;
+	return err;
+}
+
+/**
+ * nvme_get_features() - Submit a Get Features command
+ * @hdl:	Transport handle for the controller.
+ * @nsid:	Namespace ID, if applicable
+ * @fid:	Feature identifier, see &enum nvme_features_id
+ * @sel:	Select which type of attribute to return,
+ *		see &enum nvme_get_features_sel
+ * @cdw11:	Feature specific command dword11 field
+ * @uidx:	UUID Index for differentiating vendor specific encoding
+ * @data:	User address of feature data, if applicable
+ * @len:	Length of feature data, if applicable, in bytes
+ * @result:	The command completion result (CQE dword0) on success.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_features(struct nvme_transport_handle *hdl, __u32 nsid,
+		__u8 fid, enum nvme_get_features_sel sel,
+		__u32 cdw11, __u8 uidx, void *data,
+		__u32 len, __u64 *result)
+{
+	struct nvme_passthru_cmd cmd;
+	int err;
+
+	nvme_init_get_features(&cmd, fid, sel);
+
+	cmd.nsid = nsid;
+	cmd.cdw11 = cdw11;
+	cmd.cdw14 = NVME_FIELD_ENCODE(uidx,
+			NVME_GET_FEATURES_CDW14_UUID_SHIFT,
+			NVME_GET_FEATURES_CDW14_UUID_MASK);
+	cmd.data_len = len;
+	cmd.addr = (__u64)(uintptr_t)data;
+
+	err = nvme_submit_admin_passthru(hdl, &cmd);
+	if (result)
+		*result = cmd.result;
+	return err;
+}
+
+/**
+ * nvme_get_features_simple() - Submit a simple Get Features command
+ * @hdl:	Transport handle for the controller.
+ * @fid:	Feature Identifier (FID) to be retrieved.
+ * @sel:	Select (SEL), specifying which feature value
+ *		to return (&struct nvme_get_features_sel).
+ * @result:	The command completion result (CQE dword0) on success.
+ *
+ * Submits the Get Features command for features that only require parameters in
+ * the CQE dword0 and do not need any parameters in cdw11 through cdw15.
+ *
+ * Return: 0 on success, the NVMe command status on error, or a negative
+ * errno otherwise.
+ */
+static inline int
+nvme_get_features_simple(struct nvme_transport_handle *hdl, __u8 fid,
+		enum nvme_get_features_sel sel, __u64 *result)
+{
+	struct nvme_passthru_cmd cmd;
+	int err;
+
+	nvme_init_get_features(&cmd, fid, sel);
+
+	err = nvme_submit_admin_passthru(hdl, &cmd);
+	if (result)
+		*result = cmd.result;
+	return err;
+}
+
+/**
+ * nvme_namespace_attach_ctrls() - Attach namespace to controller(s)
+ * @hdl:	Transport handle
+ * @ish:	Ignore Shutdown (for NVMe-MI command)
+ * @nsid:	Namespace ID to attach
+ * @num_ctrls:	Number of controllers in ctrlist
+ * @ctrlist:	List of controller IDs to perform the attach action
+ *
+ * Return: 0 on success, the nvme command status if a response was
+ * received (see &enum nvme_status_field) or a negative error otherwise.
+ */
+int nvme_namespace_attach_ctrls(struct nvme_transport_handle *hdl, bool ish,
+				__u32 nsid, __u16 num_ctrls, __u16 *ctrlist);
+
+/**
+ * nvme_namespace_detach_ctrls() - Detach namespace from controller(s)
+ * @hdl:	Transport handle
+ * @ish:	Ignore Shutdown (for NVMe-MI command)
+ * @nsid:	Namespace ID to detach
+ * @num_ctrls:	Number of controllers in ctrlist
+ * @ctrlist:	List of controller IDs to perform the detach action
+ *
+ * Return: 0 on success, the nvme command status if a response was
+ * received (see &enum nvme_status_field) or a negative error otherwise.
+ */
+int nvme_namespace_detach_ctrls(struct nvme_transport_handle *hdl, bool ish,
+			__u32 nsid, __u16 num_ctrls, __u16 *ctrlist);
+
+
+#endif /* NVME_CMDS */
diff --git a/nvme-models.c b/nvme-models.c
index 161939beaf..a8b655ee0c 100644
--- a/nvme-models.c
+++ b/nvme-models.c
@@ -1,13 +1,14 @@
 /* SPDX-License-Identifier: GPL-2.0-or-later */
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdbool.h>
 #include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
 #include <unistd.h>
-#include <errno.h>
+
+#include <sys/stat.h>
+#include <sys/types.h>
 #include "nvme-models.h"
 #include "nvme.h"
 #include "platform/includes.h"
diff --git a/nvme-print-json.c b/nvme-print-json.c
index d8b25faede..15ca6f4dd0 100644
--- a/nvme-print-json.c
+++ b/nvme-print-json.c
@@ -432,6 +432,10 @@ void json_nvme_id_ctrl(struct nvme_id_ctrl *ctrl,
 	obj_add_uint128(r, "megcap", megcap);
 	obj_add_int(r, "tmpthha", ctrl->tmpthha);
 	obj_add_int(r, "cqt", le16_to_cpu(ctrl->cqt));
+	obj_add_int(r, "cdpa", le16_to_cpu(ctrl->cdpa));
+	obj_add_int(r, "mup", le16_to_cpu(ctrl->mup));
+	obj_add_int(r, "ipmsr", le16_to_cpu(ctrl->ipmsr));
+	obj_add_int(r, "msmt", le16_to_cpu(ctrl->msmt));
 	obj_add_int(r, "sqes", ctrl->sqes);
 	obj_add_int(r, "cqes", ctrl->cqes);
 	obj_add_int(r, "maxcmd", le16_to_cpu(ctrl->maxcmd));
@@ -473,6 +477,8 @@ void json_nvme_id_ctrl(struct nvme_id_ctrl *ctrl,
 	obj_add_int(r, "fcatt", ctrl->fcatt);
 	obj_add_int(r, "msdbd", ctrl->msdbd);
 	obj_add_int(r, "ofcs", le16_to_cpu(ctrl->ofcs));
+	obj_add_int(r, "dctype", ctrl->dctype);
+	obj_add_int(r, "ccrl", ctrl->ccrl);
 
 	obj_add_array(r, "psds", psds);
 
@@ -2672,7 +2678,7 @@ static unsigned int json_print_nvme_subsystem_multipath(nvme_subsystem_t s, json
 		path_attrs = json_create_object();
 		obj_add_str(path_attrs, "Name", nvme_ctrl_get_name(c));
 		obj_add_str(path_attrs, "Transport", nvme_ctrl_get_transport(c));
-		obj_add_str(path_attrs, "Address", nvme_ctrl_get_address(c));
+		obj_add_str(path_attrs, "Address", nvme_ctrl_get_traddr(c));
 		obj_add_str(path_attrs, "State", nvme_ctrl_get_state(c));
 		obj_add_str(path_attrs, "ANAState", nvme_path_get_ana_state(p));
 		array_add_obj(paths, path_attrs);
@@ -2693,7 +2699,7 @@ static void json_print_nvme_subsystem_ctrls(nvme_subsystem_t s,
 		path_attrs = json_create_object();
 		obj_add_str(path_attrs, "Name", nvme_ctrl_get_name(c));
 		obj_add_str(path_attrs, "Transport", nvme_ctrl_get_transport(c));
-		obj_add_str(path_attrs, "Address", nvme_ctrl_get_address(c));
+		obj_add_str(path_attrs, "Address", nvme_ctrl_get_traddr(c));
 		obj_add_str(path_attrs, "State", nvme_ctrl_get_state(c));
 		array_add_obj(paths, path_attrs);
 	}
@@ -2728,7 +2734,7 @@ static void json_print_nvme_subsystem_list(struct nvme_global_ctx *ctx,
 
 			subsystem_attrs = json_create_object();
 			obj_add_str(subsystem_attrs, "Name", nvme_subsystem_get_name(s));
-			obj_add_str(subsystem_attrs, "NQN", nvme_subsystem_get_nqn(s));
+			obj_add_str(subsystem_attrs, "NQN", nvme_subsystem_get_subsysnqn(s));
 
 			if (verbose_mode()) {
 				obj_add_str(subsystem_attrs, "Model",
@@ -2736,11 +2742,11 @@ static void json_print_nvme_subsystem_list(struct nvme_global_ctx *ctx,
 				obj_add_str(subsystem_attrs, "Serial",
 						nvme_subsystem_get_serial(s));
 				obj_add_str(subsystem_attrs, "Firmware",
-						nvme_subsystem_get_fw_rev(s));
+						nvme_subsystem_get_firmware(s));
 				obj_add_str(subsystem_attrs, "IOPolicy",
 						nvme_subsystem_get_iopolicy(s));
 				obj_add_str(subsystem_attrs, "Type",
-						nvme_subsystem_get_type(s));
+						nvme_subsystem_get_subsystype(s));
 			}
 
 			array_add_obj(subsystems, subsystem_attrs);
@@ -4657,7 +4663,7 @@ static void json_print_detail_list_multipath(nvme_subsystem_t s,
 			obj_add_str(jpath, "ModelNumber", nvme_ctrl_get_model(c));
 			obj_add_str(jpath, "Firmware", nvme_ctrl_get_firmware(c));
 			obj_add_str(jpath, "Transport", nvme_ctrl_get_transport(c));
-			obj_add_str(jpath, "Address", nvme_ctrl_get_address(c));
+			obj_add_str(jpath, "Address", nvme_ctrl_get_traddr(c));
 			obj_add_str(jpath, "Slot", nvme_ctrl_get_phy_slot(c));
 
 			array_add_obj(jpaths, jpath);
@@ -4685,7 +4691,7 @@ static void json_print_detail_list(nvme_subsystem_t s, struct json_object *jss)
 		obj_add_str(jctrl, "ModelNumber", nvme_ctrl_get_model(c));
 		obj_add_str(jctrl, "Firmware", nvme_ctrl_get_firmware(c));
 		obj_add_str(jctrl, "Transport", nvme_ctrl_get_transport(c));
-		obj_add_str(jctrl, "Address", nvme_ctrl_get_address(c));
+		obj_add_str(jctrl, "Address", nvme_ctrl_get_traddr(c));
 		obj_add_str(jctrl, "Slot", nvme_ctrl_get_phy_slot(c));
 
 		nvme_ctrl_for_each_ns(c, n) {
@@ -4734,7 +4740,7 @@ static void json_detail_list_v2(struct nvme_global_ctx *ctx)
 			struct json_object *jss = json_create_object();
 
 			obj_add_str(jss, "Subsystem", nvme_subsystem_get_name(s));
-			obj_add_str(jss, "SubsystemNQN", nvme_subsystem_get_nqn(s));
+			obj_add_str(jss, "SubsystemNQN", nvme_subsystem_get_subsysnqn(s));
 
 			if (nvme_is_multipath(s))
 				json_print_detail_list_multipath(s, jss);
@@ -4780,7 +4786,7 @@ static void json_detail_list(struct nvme_global_ctx *ctx)
 			struct json_object *jnss = json_create_array();
 
 			obj_add_str(jss, "Subsystem", nvme_subsystem_get_name(s));
-			obj_add_str(jss, "SubsystemNQN", nvme_subsystem_get_nqn(s));
+			obj_add_str(jss, "SubsystemNQN", nvme_subsystem_get_subsysnqn(s));
 
 			nvme_subsystem_for_each_ctrl(s, c) {
 				struct json_object *jctrl = json_create_object();
@@ -4793,7 +4799,7 @@ static void json_detail_list(struct nvme_global_ctx *ctx)
 				obj_add_str(jctrl, "ModelNumber", nvme_ctrl_get_model(c));
 				obj_add_str(jctrl, "Firmware", nvme_ctrl_get_firmware(c));
 				obj_add_str(jctrl, "Transport", nvme_ctrl_get_transport(c));
-				obj_add_str(jctrl, "Address", nvme_ctrl_get_address(c));
+				obj_add_str(jctrl, "Address", nvme_ctrl_get_traddr(c));
 				obj_add_str(jctrl, "Slot", nvme_ctrl_get_phy_slot(c));
 
 				nvme_ctrl_for_each_ns(c, n) {
@@ -4973,7 +4979,7 @@ static unsigned int json_subsystem_topology_multipath(nvme_subsystem_t s,
 			ctrl_attrs = json_create_object();
 			obj_add_str(ctrl_attrs, "Name", nvme_ctrl_get_name(c));
 			obj_add_str(ctrl_attrs, "Transport", nvme_ctrl_get_transport(c));
-			obj_add_str(ctrl_attrs, "Address", nvme_ctrl_get_address(c));
+			obj_add_str(ctrl_attrs, "Address", nvme_ctrl_get_traddr(c));
 			obj_add_str(ctrl_attrs, "State", nvme_ctrl_get_state(c));
 			array_add_obj(ctrls, ctrl_attrs);
 			obj_add_array(path_attrs, "Controller", ctrls);
@@ -5011,7 +5017,7 @@ static void json_print_nvme_subsystem_topology(nvme_subsystem_t s,
 			obj_add_str(ctrl_attrs, "Transport",
 						     nvme_ctrl_get_transport(c));
 			obj_add_str(ctrl_attrs, "Address",
-						     nvme_ctrl_get_address(c));
+						     nvme_ctrl_get_traddr(c));
 			obj_add_str(ctrl_attrs, "State",
 						     nvme_ctrl_get_state(c));
 
@@ -5042,7 +5048,7 @@ static void json_simple_topology(struct nvme_global_ctx *ctx)
 		nvme_for_each_subsystem(h, s) {
 			subsystem_attrs = json_create_object();
 			obj_add_str(subsystem_attrs, "Name", nvme_subsystem_get_name(s));
-			obj_add_str(subsystem_attrs, "NQN", nvme_subsystem_get_nqn(s));
+			obj_add_str(subsystem_attrs, "NQN", nvme_subsystem_get_subsysnqn(s));
 			obj_add_str(subsystem_attrs, "IOPolicy",
 					nvme_subsystem_get_iopolicy(s));
 
@@ -5052,9 +5058,9 @@ static void json_simple_topology(struct nvme_global_ctx *ctx)
 				obj_add_str(subsystem_attrs, "Serial",
 						nvme_subsystem_get_serial(s));
 				obj_add_str(subsystem_attrs, "Firmware",
-						nvme_subsystem_get_fw_rev(s));
+						nvme_subsystem_get_firmware(s));
 				obj_add_str(subsystem_attrs, "Type",
-						nvme_subsystem_get_type(s));
+						nvme_subsystem_get_subsystype(s));
 			}
 
 			array_add_obj(subsystems, subsystem_attrs);
@@ -5195,6 +5201,7 @@ static void json_directive_show(__u8 type, __u8 oper, __u16 spec, __u32 nsid, __
 	json_print(r);
 }
 
+#ifdef CONFIG_FABRICS
 static void json_discovery_log(struct nvmf_discovery_log *log, int numrec)
 {
 	struct json_object *r = json_create_object();
@@ -5236,6 +5243,9 @@ static void json_discovery_log(struct nvmf_discovery_log *log, int numrec)
 
 	json_print(r);
 }
+#else
+static void json_discovery_log(struct nvmf_discovery_log *log, int numrec) {}
+#endif
 
 static void json_connect_msg(nvme_ctrl_t c)
 {
@@ -5562,6 +5572,7 @@ static void json_reachability_associations_log(struct nvme_reachability_associat
 	json_print(r);
 }
 
+#ifdef CONFIG_FABRICS
 static void json_host_discovery_log(struct nvme_host_discover_log *log)
 {
 	struct json_object *r = json_create_object();
@@ -5689,6 +5700,10 @@ static void json_ave_discovery_log(struct nvme_ave_discover_log *log)
 		obj_add_obj(r, json_str, adlpe_o);
 	}
 }
+#else
+static void json_host_discovery_log(struct nvme_host_discover_log *log) {}
+static void json_ave_discovery_log(struct nvme_ave_discover_log *log) {}
+#endif
 
 static void json_pull_model_ddc_req_log(struct nvme_pull_model_ddc_req_log *log)
 {
diff --git a/nvme-print-stdout.c b/nvme-print-stdout.c
index 9a4a8be854..e82d7d81a7 100644
--- a/nvme-print-stdout.c
+++ b/nvme-print-stdout.c
@@ -2,8 +2,8 @@
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -1188,7 +1188,7 @@ static unsigned int stdout_subsystem_multipath(nvme_subsystem_t s)
 		printf(" +- %s %s %s %s %s\n",
 			nvme_ctrl_get_name(c),
 			nvme_ctrl_get_transport(c),
-			nvme_ctrl_get_address(c),
+			nvme_ctrl_get_traddr(c),
 			nvme_ctrl_get_state(c),
 			ana_state);
 		i++;
@@ -1205,7 +1205,7 @@ static void stdout_subsystem_ctrls(nvme_subsystem_t s)
 		printf(" +- %s %s %s %s\n",
 			nvme_ctrl_get_name(c),
 			nvme_ctrl_get_transport(c),
-			nvme_ctrl_get_address(c),
+			nvme_ctrl_get_traddr(c),
 			nvme_ctrl_get_state(c));
 	}
 }
@@ -1215,7 +1215,7 @@ static void stdout_subsys_config(nvme_subsystem_t s, bool show_iopolicy)
 	int len = strlen(nvme_subsystem_get_name(s));
 
 	printf("%s - NQN=%s\n", nvme_subsystem_get_name(s),
-	       nvme_subsystem_get_nqn(s));
+	       nvme_subsystem_get_subsysnqn(s));
 	printf("%*s   hostnqn=%s\n", len, " ",
 	       nvme_host_get_hostnqn(nvme_subsystem_get_host(s)));
 	if (show_iopolicy)
@@ -1228,9 +1228,9 @@ static void stdout_subsys_config(nvme_subsystem_t s, bool show_iopolicy)
 		printf("%*s   serial=%s\n", len, " ",
 			nvme_subsystem_get_serial(s));
 		printf("%*s   firmware=%s\n", len, " ",
-			nvme_subsystem_get_fw_rev(s));
+			nvme_subsystem_get_firmware(s));
 		printf("%*s   type=%s\n", len, " ",
-			nvme_subsystem_get_type(s));
+			nvme_subsystem_get_subsystype(s));
 	}
 }
 
@@ -2427,6 +2427,32 @@ static void stdout_id_ctrl_tmpthha(__u8 tmpthha)
 	printf("\n");
 }
 
+static void stdout_id_ctrl_cdpa(__le16 ctrl_cdpa)
+{
+	__u16 cdpa = le16_to_cpu(ctrl_cdpa);
+	__u16 rsvd1 = (cdpa >> 1);
+	bool hmac_sha_384 = !!(cdpa & NVME_CTRL_CDPA_HMAC_SHA_384);
+
+	if (rsvd1)
+		printf("  [15:1] : %#x\tReserved\n", rsvd1);
+	printf("  [0:0] : %#x\tHMAC-SHA-384 %sSupported\n",
+			hmac_sha_384, hmac_sha_384 ? "" : "Not ");
+
+	printf("\n");
+}
+
+static void stdout_id_ctrl_ipmsr(__le16 ctrl_ipmsr)
+{
+	__u16 ipmsr = le16_to_cpu(ctrl_ipmsr);
+	__u16 srs = NVME_GET(ipmsr, CTRL_IPMSR_SRS);
+	__u16 srv = NVME_GET(ipmsr, CTRL_IPMSR_SRV);
+
+	printf("  [15:8] : %#x\tSample Rate Scale\n", srs);
+	printf("  [7:0]  : %#x\tSample Rate Value\n", srv);
+
+	printf("\n");
+}
+
 static void stdout_id_ctrl_sqes(__u8 sqes)
 {
 	__u8 msqes = (sqes & 0xF0) >> 4;
@@ -2696,6 +2722,26 @@ static void stdout_id_ctrl_ofcs(__le16 ofcs)
 
 }
 
+static void stdout_id_ctrl_dctype(__u8 dctype)
+{
+	__u8 rsvd = (dctype & 0xFC) >> 2;
+	__u8 dctype_val = dctype & 0x3;
+	char *dctype_str;
+
+	if (rsvd)
+		printf("  [7:3] : %#x\tReserved\n", rsvd);
+	if (dctype_val == NVME_CTRL_DCTYPE_CDC)
+		dctype_str = "CDC";
+	else if (dctype_val == NVME_CTRL_DCTYPE_DDC)
+		dctype_str = "DDC";
+	else
+		dctype_str = "not reported";
+
+	printf("  [0:2] : %#x\tDiscovery Controller Type: %s\n",
+				dctype_val, dctype_str);
+	printf("\n");
+}
+
 static void stdout_id_ns_size(uint64_t nsze, uint64_t ncap, uint64_t nuse)
 {
 	printf("nsze    : %#"PRIx64"\tTotal size in logical blocks\n",
@@ -3431,6 +3477,14 @@ static void stdout_id_ctrl(struct nvme_id_ctrl *ctrl,
 	if (human)
 		stdout_id_ctrl_tmpthha(ctrl->tmpthha);
 	printf("cqt       : %d\n", le16_to_cpu(ctrl->cqt));
+	printf("cdpa      : %d\n", le16_to_cpu(ctrl->cdpa));
+	if (human)
+		stdout_id_ctrl_cdpa(ctrl->cdpa);
+	printf("mup       : %d\n", le16_to_cpu(ctrl->mup));
+	printf("ipmsr     : %#x\n", le16_to_cpu(ctrl->ipmsr));
+	if (human)
+		stdout_id_ctrl_ipmsr(ctrl->ipmsr);
+	printf("msmt      : %#x\n", le16_to_cpu(ctrl->msmt));
 	printf("sqes      : %#x\n", ctrl->sqes);
 	if (human)
 		stdout_id_ctrl_sqes(ctrl->sqes);
@@ -3496,6 +3550,10 @@ static void stdout_id_ctrl(struct nvme_id_ctrl *ctrl,
 	printf("ofcs      : %d\n", le16_to_cpu(ctrl->ofcs));
 	if (human)
 		stdout_id_ctrl_ofcs(ctrl->ofcs);
+	printf("dctype    : %d\n", ctrl->dctype);
+	if (human)
+		stdout_id_ctrl_dctype(ctrl->dctype);
+	printf("ccrl      : %d\n", ctrl->ccrl);
 
 	stdout_id_ctrl_power(ctrl);
 	if (vendor_show)
@@ -5721,7 +5779,8 @@ static bool stdout_detailed_subsys(const char *name, void *arg)
 	     s;
 	     s = htable_subsys_getnext(&res->ht_s, name, &it)) {
 		if (first) {
-			printf("%-16s %-96s ", name, nvme_subsystem_get_nqn(s));
+			printf("%-16s %-96s ", name,
+			       nvme_subsystem_get_subsysnqn(s));
 			first = false;
 		}
 
@@ -5756,7 +5815,7 @@ static bool stdout_detailed_ctrl(const char *name, void *arg)
 	       nvme_ctrl_get_model(c),
 	       nvme_ctrl_get_firmware(c),
 	       nvme_ctrl_get_transport(c),
-	       nvme_ctrl_get_address(c),
+	       nvme_ctrl_get_traddr(c),
 	       nvme_ctrl_get_phy_slot(c),
 	       nvme_subsystem_get_name(nvme_ctrl_get_subsystem(c)));
 
@@ -5963,7 +6022,7 @@ static void stdout_tabular_subsystem_topology_multipath(nvme_subsystem_t s)
 					nvme_ctrl_get_transport(c), LEFT);
 			/* col 7: Address */
 			table_set_value_str(t, ++col, row,
-					nvme_ctrl_get_address(c), LEFT);
+					nvme_ctrl_get_traddr(c), LEFT);
 			/* col 8: State */
 			table_set_value_str(t, ++col, row,
 					nvme_ctrl_get_state(c), LEFT);
@@ -5998,7 +6057,7 @@ static void stdout_subsystem_topology_multipath(nvme_subsystem_t s,
 				printf("  +- %s %s %s %s %s\n",
 				       nvme_ctrl_get_name(c),
 				       nvme_ctrl_get_transport(c),
-				       nvme_ctrl_get_address(c),
+				       nvme_ctrl_get_traddr(c),
 				       nvme_ctrl_get_state(c),
 				       nvme_path_get_ana_state(p));
 			}
@@ -6009,7 +6068,7 @@ static void stdout_subsystem_topology_multipath(nvme_subsystem_t s,
 			printf(" +- %s %s %s\n",
 			       nvme_ctrl_get_name(c),
 			       nvme_ctrl_get_transport(c),
-			       nvme_ctrl_get_address(c));
+			       nvme_ctrl_get_traddr(c));
 			printf(" \\\n");
 
 			nvme_subsystem_for_each_ns(s, n) {
@@ -6045,7 +6104,7 @@ static void stdout_subsystem_topology_multipath(nvme_subsystem_t s,
 						nvme_path_get_numa_nodes(p),
 						nvme_ctrl_get_name(c),
 						nvme_ctrl_get_transport(c),
-						nvme_ctrl_get_address(c),
+						nvme_ctrl_get_traddr(c),
 						nvme_ctrl_get_state(c));
 
 				} else if (!strcmp(iopolicy, "queue-depth")) {
@@ -6059,7 +6118,7 @@ static void stdout_subsystem_topology_multipath(nvme_subsystem_t s,
 						nvme_path_get_queue_depth(p),
 						nvme_ctrl_get_name(c),
 						nvme_ctrl_get_transport(c),
-						nvme_ctrl_get_address(c),
+						nvme_ctrl_get_traddr(c),
 						nvme_ctrl_get_state(c));
 
 				} else { /* round-robin */
@@ -6072,7 +6131,7 @@ static void stdout_subsystem_topology_multipath(nvme_subsystem_t s,
 						nvme_path_get_ana_state(p),
 						nvme_ctrl_get_name(c),
 						nvme_ctrl_get_transport(c),
-						nvme_ctrl_get_address(c),
+						nvme_ctrl_get_traddr(c),
 						nvme_ctrl_get_state(c));
 				}
 			}
@@ -6130,7 +6189,7 @@ static void stdout_tabular_subsystem_topology(nvme_subsystem_t s)
 					nvme_ctrl_get_transport(c), LEFT);
 			/* col 4: Address */
 			table_set_value_str(t, 4, row,
-					nvme_ctrl_get_address(c), LEFT);
+					nvme_ctrl_get_traddr(c), LEFT);
 			/* col 5: State */
 			table_set_value_str(t, 5, row,
 					nvme_ctrl_get_state(c), LEFT);
@@ -6157,7 +6216,7 @@ static void stdout_subsystem_topology(nvme_subsystem_t s,
 				printf("  +- %s %s %s %s\n",
 				       nvme_ctrl_get_name(c),
 				       nvme_ctrl_get_transport(c),
-				       nvme_ctrl_get_address(c),
+				       nvme_ctrl_get_traddr(c),
 				       nvme_ctrl_get_state(c));
 			}
 		}
@@ -6167,7 +6226,7 @@ static void stdout_subsystem_topology(nvme_subsystem_t s,
 			printf(" +- %s %s %s\n",
 			       nvme_ctrl_get_name(c),
 			       nvme_ctrl_get_transport(c),
-			       nvme_ctrl_get_address(c));
+			       nvme_ctrl_get_traddr(c));
 			printf(" \\\n");
 			nvme_ctrl_for_each_ns(c, n) {
 				printf("  +- ns %d %s\n",
@@ -6188,7 +6247,7 @@ static void stdout_subsystem_topology(nvme_subsystem_t s,
 				printf("  +- %s %s %s %s\n",
 						nvme_ctrl_get_name(c),
 						nvme_ctrl_get_transport(c),
-						nvme_ctrl_get_address(c),
+						nvme_ctrl_get_traddr(c),
 						nvme_ctrl_get_state(c));
 			}
 		}
@@ -6302,6 +6361,7 @@ static void stdout_key_value(const char *key, const char *val, va_list ap)
 	printf("%s: %s\n", key, value ? value : alloc_error);
 }
 
+#ifdef CONFIG_FABRICS
 static void stdout_discovery_log(struct nvmf_discovery_log *log, int numrec)
 {
 	int i;
@@ -6344,6 +6404,9 @@ static void stdout_discovery_log(struct nvmf_discovery_log *log, int numrec)
 		}
 	}
 }
+#else
+static void stdout_discovery_log(struct nvmf_discovery_log *log, int numrec) {}
+#endif
 
 static void stdout_connect_msg(nvme_ctrl_t c)
 {
@@ -6438,6 +6501,7 @@ static void stdout_reachability_associations_log(struct nvme_reachability_associ
 	}
 }
 
+#ifdef CONFIG_FABRICS
 static void stdout_host_discovery_log(struct nvme_host_discover_log *log)
 {
 	__u32 i;
@@ -6548,6 +6612,10 @@ static void stdout_ave_discovery_log(struct nvme_ave_discover_log *log)
 		}
 	}
 }
+#else
+static void stdout_host_discovery_log(struct nvme_host_discover_log *log) {}
+static void stdout_ave_discovery_log(struct nvme_ave_discover_log *log) {}
+#endif
 
 static void stdout_pull_model_ddc_req_log(struct nvme_pull_model_ddc_req_log *log)
 {
diff --git a/nvme-print.c b/nvme-print.c
index 5b13ab68ce..92de312aec 100644
--- a/nvme-print.c
+++ b/nvme-print.c
@@ -1,12 +1,13 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 #include <assert.h>
 #include <errno.h>
+#include <locale.h>
 #include <stdio.h>
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
+
 #include <sys/stat.h>
-#include <locale.h>
 
 #include <libnvme.h>
 
diff --git a/nvme-print.h b/nvme-print.h
index 3d80227e76..0d976215d1 100644
--- a/nvme-print.h
+++ b/nvme-print.h
@@ -2,13 +2,14 @@
 #ifndef NVME_PRINT_H
 #define NVME_PRINT_H
 
-#include "nvme.h"
-#include "types.h"
-#include "util/table.h"
 #include <inttypes.h>
 
 #include <ccan/list/list.h>
 
+#include "nvme.h"
+#include "types.h"
+#include "util/table.h"
+
 typedef struct nvme_effects_log_node {
 	struct nvme_cmd_effects_log effects; /* needs to be first member because of alignment requirement. */
 	enum nvme_csi csi;
diff --git a/nvme-rpmb.c b/nvme-rpmb.c
index 9f47f82c08..6e00be4824 100644
--- a/nvme-rpmb.c
+++ b/nvme-rpmb.c
@@ -15,25 +15,28 @@
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  * nvme-rpmb.c - Implementation of NVMe RPMB support commands in Nvme
  */
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stddef.h>
-#include <unistd.h>
-#include <errno.h>
 #include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <sys/socket.h>
+#include <unistd.h>
+
 #include <linux/if_alg.h>
 #include <linux/socket.h>
-#include <limits.h>
+
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 
 #include <libnvme.h>
 
 #include "common.h"
-#include "nvme.h"
+#include "nvme-cmds.h"
 #include "nvme-print.h"
+#include "nvme.h"
 
 #define CREATE_CMD
 
diff --git a/nvme.c b/nvme.c
index 9f90472c1e..37e86da5eb 100644
--- a/nvme.c
+++ b/nvme.c
@@ -24,30 +24,27 @@
 /**
  * This program uses NVMe IOCTLs to run native nvme commands to a device.
  */
-#include "nvme/tree.h"
-#include "nvme/types.h"
-#include "util/cleanup.h"
+#include <dirent.h>
 #include <errno.h>
-#include <getopt.h>
 #include <fcntl.h>
+#include <getopt.h>
 #include <inttypes.h>
+#include <libgen.h>
 #include <locale.h>
-#include <stdio.h>
+#include <math.h>
+#include <signal.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include <math.h>
-#include <libgen.h>
-#include <signal.h>
 
 #ifndef _WIN32
 #include <linux/fs.h>
 #endif
 
-#include <sys/types.h>
 #include <sys/stat.h>
-
+#include <sys/types.h>
 
 #if HAVE_SYS_RANDOM
 	#include <sys/random.h>
@@ -56,16 +53,21 @@
 #include <libnvme.h>
 
 #include "common.h"
-#include "nvme.h"
+#include "fabrics.h"
+#include "logging.h"
+#include "nvme-cmds.h"
 #include "nvme-print.h"
+#include "nvme.h"
+#include "nvme/tree.h"
+#include "nvme/types.h"
 #include "plugin.h"
+#include "util/argconfig.h"
 #include "util/base64.h"
+#include "util/cleanup.h"
 #include "util/crc32.h"
-#include "util/argconfig.h"
-#include "util/suffix.h"
-#include "logging.h"
 #include "util/sighdl.h"
-#include "fabrics.h"
+#include "util/suffix.h"
+
 #define CREATE_CMD
 #include "nvme-builtin.h"
 #include "malloc.h"
@@ -5466,7 +5468,7 @@ static int subsystem_reset(int argc, char **argv, struct command *acmd, struct p
 		return -EINVAL;
 	}
 
-	err = nvme_subsystem_reset(hdl);
+	err = nvme_reset_subsystem(hdl);
 	if (err < 0) {
 		if (errno == ENOTTY)
 			nvme_show_error("Subsystem-reset: NVM Subsystem Reset not supported.");
@@ -5497,7 +5499,7 @@ static int reset(int argc, char **argv, struct command *acmd, struct plugin *plu
 		return -EINVAL;
 	}
 
-	err = nvme_ctrl_reset(hdl);
+	err = nvme_reset_ctrl(hdl);
 	if (err < 0)
 		nvme_show_error("Reset: %s", nvme_strerror(-err));
 	else if (argconfig_parse_seen(opts, "verbose"))
@@ -5532,7 +5534,7 @@ static int ns_rescan(int argc, char **argv, struct command *acmd, struct plugin
 		return err;
 	}
 
-	err = nvme_ns_rescan(hdl);
+	err = nvme_rescan_ns(hdl);
 	if (err < 0)
 		nvme_show_error("Namespace Rescan: %s\n", nvme_strerror(-err));
 	else if (argconfig_parse_seen(opts, "verbose"))
@@ -6823,7 +6825,7 @@ static int format_cmd(int argc, char **argv, struct command *acmd, struct plugin
 	printf("Success formatting namespace:%x\n", cfg.namespace_id);
 	if (nvme_transport_handle_is_direct(hdl) && cfg.lbaf != prev_lbaf) {
 		if (nvme_transport_handle_is_chardev(hdl)) {
-			if (nvme_ns_rescan(hdl) < 0) {
+			if (nvme_rescan_ns(hdl) < 0) {
 				nvme_show_error("failed to rescan namespaces");
 				return -errno;
 			}
@@ -6855,7 +6857,7 @@ static int format_cmd(int argc, char **argv, struct command *acmd, struct plugin
 	}
 	if (nvme_transport_handle_is_direct(hdl) && cfg.reset &&
 	    nvme_transport_handle_is_chardev(hdl))
-		nvme_ctrl_reset(hdl);
+		nvme_reset_ctrl(hdl);
 
 	return err;
 }
@@ -8351,9 +8353,9 @@ static int submit_io(int opcode, char *command, const char *desc, int argc, char
 	__u32 dsmgmt = 0;
 	int mode = 0644;
 	void *buffer;
+	__u16 ms = 0;
 	int err = 0;
 	int flags;
-	__u16 ms;
 
 	const char *start_block_addr = "64-bit addr of first block to access";
 	const char *block_size = "if specified, logical block size in bytes;\n"
@@ -8530,13 +8532,7 @@ static int submit_io(int opcode, char *command, const char *desc, int argc, char
 	} else {
 		err = get_pi_info(hdl, cfg.nsid, cfg.prinfo,
 			cfg.ilbrt, cfg.lbst, &logical_block_size, &ms);
-		if (err) {
-			logical_block_size = 0;
-			ms = 0;
-			pi_available = false;
-		} else {
-			pi_available = true;
-		}
+		pi_available = err == 0;
 	}
 
 	buffer_size = ((long long)cfg.block_count + 1) * logical_block_size;
@@ -9528,7 +9524,7 @@ static int gen_hostnqn_cmd(int argc, char **argv, struct command *acmd, struct p
 {
 	char *hostnqn;
 
-	hostnqn = nvmf_hostnqn_generate();
+	hostnqn = nvme_generate_hostnqn();
 	if (!hostnqn) {
 		nvme_show_error("\"%s\" not supported. Install lib uuid and rebuild.",
 				acmd->name);
@@ -9543,9 +9539,9 @@ static int show_hostnqn_cmd(int argc, char **argv, struct command *acmd, struct
 {
 	char *hostnqn;
 
-	hostnqn = nvmf_hostnqn_from_file();
+	hostnqn = nvme_read_hostnqn();
 	if (!hostnqn)
-		hostnqn =  nvmf_hostnqn_generate();
+		hostnqn =  nvme_generate_hostnqn();
 
 	if (!hostnqn) {
 		nvme_show_error("hostnqn is not available -- use nvme gen-hostnqn");
@@ -9673,7 +9669,7 @@ static int gen_dhchap_key(int argc, char **argv, struct command *acmd, struct pl
 	}
 
 	if (!cfg.nqn) {
-		cfg.nqn = hnqn = nvmf_hostnqn_from_file();
+		cfg.nqn = hnqn = nvme_read_hostnqn();
 		if (!cfg.nqn) {
 			nvme_show_error("Could not read host NQN");
 			return -ENOENT;
@@ -9937,7 +9933,7 @@ static int gen_tls_key(int argc, char **argv, struct command *acmd, struct plugi
 			return -EINVAL;
 		}
 		if (!cfg.hostnqn) {
-			cfg.hostnqn = hnqn = nvmf_hostnqn_from_file();
+			cfg.hostnqn = hnqn = nvme_read_hostnqn();
 			if (!cfg.hostnqn) {
 				nvme_show_error("Failed to read host NQN");
 				return -EINVAL;
@@ -10099,7 +10095,7 @@ static int check_tls_key(int argc, char **argv, struct command *acmd, struct plu
 
 	if (cfg.subsysnqn) {
 		if (!cfg.hostnqn) {
-			cfg.hostnqn = hnqn = nvmf_hostnqn_from_file();
+			cfg.hostnqn = hnqn = nvme_read_hostnqn();
 			if (!cfg.hostnqn) {
 				nvme_show_error("Failed to read host NQN");
 				return -EINVAL;
@@ -10433,6 +10429,7 @@ static int show_topology_cmd(int argc, char **argv, struct command *acmd, struct
 	return err;
 }
 
+#ifdef CONFIG_FABRICS
 static int discover_cmd(int argc, char **argv, struct command *acmd, struct plugin *plugin)
 {
 	const char *desc = "Send Get Log Page request to Discovery Controller.";
@@ -10483,6 +10480,7 @@ static int dim_cmd(int argc, char **argv, struct command *acmd, struct plugin *p
 
 	return fabrics_dim(desc, argc, argv);
 }
+#endif
 
 static int nvme_mi(int argc, char **argv, __u8 admin_opcode, const char *desc)
 {
diff --git a/nvme.h b/nvme.h
index ca58c8e8bc..ca4baebec1 100644
--- a/nvme.h
+++ b/nvme.h
@@ -19,6 +19,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
+
 #include <sys/stat.h>
 
 #include "platform/includes.h"
diff --git a/plugin.c b/plugin.c
index 0406bd0246..d0e6ef57f7 100644
--- a/plugin.c
+++ b/plugin.c
@@ -4,11 +4,11 @@
 #include <stdlib.h>
 #include <unistd.h>
 
+#include <libnvme.h>
+
 #include "plugin.h"
 #include "util/argconfig.h"
 
-#include <libnvme.h>
-
 static int version_cmd(struct plugin *plugin)
 {
 	struct program *prog = plugin->parent;
diff --git a/plugins/amzn/amzn-nvme.c b/plugins/amzn/amzn-nvme.c
index 276f71c681..5613095144 100644
--- a/plugins/amzn/amzn-nvme.c
+++ b/plugins/amzn/amzn-nvme.c
@@ -10,9 +10,10 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "nvme-print.h"
 
 #define CREATE_CMD
 #include "amzn-nvme.h"
diff --git a/plugins/dapustor/dapustor-nvme.c b/plugins/dapustor/dapustor-nvme.c
index d2b3cc3439..cb88df38f9 100644
--- a/plugins/dapustor/dapustor-nvme.c
+++ b/plugins/dapustor/dapustor-nvme.c
@@ -14,9 +14,10 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "nvme-print.h"
 
 #include "util/suffix.h"
 
diff --git a/plugins/dera/dera-nvme.c b/plugins/dera/dera-nvme.c
index fc30df0c27..da3cafe0e5 100644
--- a/plugins/dera/dera-nvme.c
+++ b/plugins/dera/dera-nvme.c
@@ -5,17 +5,18 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
-#include <dirent.h> 
-#include <ctype.h> 
+#include <dirent.h>
+#include <ctype.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 
 #include <libnvme.h>
 
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
 #include "platform/types.h"
-#include "nvme-print.h"
 
 #define CREATE_CMD
 #include "dera-nvme.h"
diff --git a/plugins/fdp/fdp.c b/plugins/fdp/fdp.c
index 4790d565e1..1ffb677a6a 100644
--- a/plugins/fdp/fdp.c
+++ b/plugins/fdp/fdp.c
@@ -14,8 +14,9 @@
 #include <libnvme.h>
 
 #include "common.h"
-#include "nvme.h"
+#include "nvme-cmds.h"
 #include "nvme-print.h"
+#include "nvme.h"
 
 #define CREATE_CMD
 #include "fdp.h"
diff --git a/plugins/feat/feat-nvme.c b/plugins/feat/feat-nvme.c
index a7c1c7210f..324dfa749d 100644
--- a/plugins/feat/feat-nvme.c
+++ b/plugins/feat/feat-nvme.c
@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 #include <errno.h>
 #include <fcntl.h>
+
+#include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "nvme-print.h"
-#include "common.h"
 
 #define CREATE_CMD
 #include "feat-nvme.h"
diff --git a/plugins/huawei/huawei-nvme.c b/plugins/huawei/huawei-nvme.c
index 65f3fc73c6..dcf4f3dc2b 100644
--- a/plugins/huawei/huawei-nvme.c
+++ b/plugins/huawei/huawei-nvme.c
@@ -30,6 +30,7 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
 #include "nvme.h"
 #include "plugin.h"
 
@@ -318,7 +319,7 @@ static int huawei_list(int argc, char **argv, struct command *acmd,
 	if (ret < 0 || (fmt != JSON && fmt != NORMAL))
 		return ret;
 
-	n = scandir("/dev", &devices, nvme_namespace_filter, alphasort);
+	n = scandir("/dev", &devices, nvme_filter_namespace, alphasort);
 	if (n <= 0)
 		return n;
 
diff --git a/plugins/ibm/ibm-nvme.c b/plugins/ibm/ibm-nvme.c
index 2407049a76..38f3cf0fe1 100644
--- a/plugins/ibm/ibm-nvme.c
+++ b/plugins/ibm/ibm-nvme.c
@@ -4,8 +4,9 @@
 #include <unistd.h>
 
 #include "common.h"
-#include "nvme.h"
+#include "nvme-cmds.h"
 #include "nvme-print.h"
+#include "nvme.h"
 #include "plugin.h"
 
 #define CREATE_CMD
diff --git a/plugins/inspur/inspur-nvme.c b/plugins/inspur/inspur-nvme.c
index 7681a8ee63..7e798c4916 100644
--- a/plugins/inspur/inspur-nvme.c
+++ b/plugins/inspur/inspur-nvme.c
@@ -13,9 +13,10 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "nvme-print.h"
 #include "util/suffix.h"
 
 #define CREATE_CMD
diff --git a/plugins/intel/intel-nvme.c b/plugins/intel/intel-nvme.c
index 9b18a1063d..6ac095df79 100644
--- a/plugins/intel/intel-nvme.c
+++ b/plugins/intel/intel-nvme.c
@@ -9,10 +9,11 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
 #include "platform/types.h"
-#include "nvme-print.h"
 
 #define CREATE_CMD
 #include "intel-nvme.h"
diff --git a/plugins/lm/lm-nvme.c b/plugins/lm/lm-nvme.c
index 9196983b2f..423cf2c9f9 100644
--- a/plugins/lm/lm-nvme.c
+++ b/plugins/lm/lm-nvme.c
@@ -6,30 +6,32 @@
  */
 
 #include <assert.h>
-#include <fcntl.h>
+#include <dirent.h>
 #include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
-#include <linux/fs.h>
-#include <inttypes.h>
+
 #include <asm/byteorder.h>
+#include <linux/fs.h>
+
 #include <sys/mman.h>
 #include <sys/shm.h>
-#include <sys/sysinfo.h>
 #include <sys/stat.h>
+#include <sys/sysinfo.h>
 #include <sys/types.h>
-#include <dirent.h>
-#include <time.h>
 
 #include <libnvme.h>
 
 #include "common.h"
-#include "nvme.h"
+#include "nvme-cmds.h"
 #include "nvme-print.h"
+#include "nvme.h"
 #include "plugin.h"
-#include "platform/types.h"
 #include "util/cleanup.h"
 
 #define CREATE_CMD
diff --git a/plugins/lm/lm-print-stdout.c b/plugins/lm/lm-print-stdout.c
index 44951990d0..ed2cc6cb48 100644
--- a/plugins/lm/lm-print-stdout.c
+++ b/plugins/lm/lm-print-stdout.c
@@ -1,10 +1,9 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "lm-print.h"
-
 #include <inttypes.h>
 
 #include "common.h"
+#include "lm-print.h"
 #include "util/types.h"
 
 static struct lm_print_ops stdout_print_ops;
diff --git a/plugins/memblaze/memblaze-nvme.c b/plugins/memblaze/memblaze-nvme.c
index ddb0f4dbb9..bbbe7a4142 100644
--- a/plugins/memblaze/memblaze-nvme.c
+++ b/plugins/memblaze/memblaze-nvme.c
@@ -9,11 +9,12 @@
 
 #include <libnvme.h>
 
-#include "nvme.h"
 #include "common.h"
-#include "plugin.h"
-#include "platform/types.h"
+#include "nvme-cmds.h"
 #include "nvme-print.h"
+#include "nvme.h"
+#include "platform/types.h"
+#include "plugin.h"
 
 #define CREATE_CMD
 #include "memblaze-nvme.h"
diff --git a/plugins/meson.build b/plugins/meson.build
index 293dbac485..6508c5b17a 100644
--- a/plugins/meson.build
+++ b/plugins/meson.build
@@ -13,7 +13,6 @@ all_plugins = {
   'mangoboost': ['plugins/mangoboost/mangoboost-nvme.c'],
   'memblaze': ['plugins/memblaze/memblaze-nvme.c'],
   'micron': ['plugins/micron/micron-nvme.c'],
-  'nbft': ['plugins/nbft/nbft-plugin.c'],
   'nvidia': ['plugins/nvidia/nvidia-nvme.c'],
   'seagate': ['plugins/seagate/seagate-nvme.c'],
   'shannon': ['plugins/shannon/shannon-nvme.c'],
@@ -48,6 +47,10 @@ foreach plugin_name : selected_plugins
   endif
 endforeach
 
+if want_fabrics and 'nbft' in selected_plugins
+    plugin_sources += ['plugins/nbft/nbft-plugin.c']
+endif
+
 if 'feat' in selected_plugins
   subdir('feat')
 endif
diff --git a/plugins/micron/micron-nvme.c b/plugins/micron/micron-nvme.c
index b56eb7f722..2baaad56be 100644
--- a/plugins/micron/micron-nvme.c
+++ b/plugins/micron/micron-nvme.c
@@ -9,31 +9,31 @@
  *			Sivaprasad Gutha <sivaprasadg@micron.com>
  */
 
-#include <stdio.h>
-#include <string.h>
 #include <ctype.h>
-#include <stdlib.h>
-#include <inttypes.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <unistd.h>
-#include <time.h>
-#include <string.h>
+#include <inttypes.h>
 #include <libgen.h>
+#include <limits.h>
 #include <stddef.h>
-#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
 #include <sys/stat.h>
+#include <sys/types.h>
 
 #include <libnvme.h>
 
 #include "common.h"
-#include "nvme.h"
-#include <limits.h>
-#include "platform/types.h"
+#include "nvme-cmds.h"
 #include "nvme-print.h"
+#include "nvme.h"
 #include "util/cleanup.h"
-#include "util/utils.h"
 #include "util/types.h"
+#include "util/utils.h"
 
 #define CREATE_CMD
 #include "micron-nvme.h"
@@ -4418,27 +4418,22 @@ static int micron_health_info(int argc, char **argv, struct command *acmd,
 
 /*
  * Identify Controller field offsets for Micron-specific fields
- * IPMSR: Interval Power Measurement Sample Rate (2 bytes)
- * MSMT:  Maximum Stop Measurement Time (2 bytes)
  * PMS:   Power Measurement Support - bit 21 of CTRATT
  */
-#define ID_CTRL_RSVD388_OFFSET   388
-#define ID_CTRL_IPMSR_OFFSET     392
-#define ID_CTRL_MSMT_OFFSET      394
 #define CTRATT_PMS_BIT           21
 
 static inline __u16 get_id_ctrl_ipmsr(struct nvme_id_ctrl *ctrl)
 {
-	__u8 *p = &ctrl->rsvd388[ID_CTRL_IPMSR_OFFSET - ID_CTRL_RSVD388_OFFSET];
+	__le16 *p = (__le16 *)&ctrl->ipmsr;
 
-	return le16_to_cpu(*(__le16 *)p);
+	return le16_to_cpu(*p);
 }
 
 static inline __u16 get_id_ctrl_msmt(struct nvme_id_ctrl *ctrl)
 {
-	__u8 *p = &ctrl->rsvd388[ID_CTRL_MSMT_OFFSET - ID_CTRL_RSVD388_OFFSET];
+	__le16 *p = (__le16 *)&ctrl->msmt;
 
-	return le16_to_cpu(*(__le16 *)p);
+	return le16_to_cpu(*p);
 }
 
 static inline bool get_id_ctrl_pms(struct nvme_id_ctrl *ctrl)
diff --git a/plugins/netapp/netapp-nvme.c b/plugins/netapp/netapp-nvme.c
index a50560b55d..8d58e69d18 100644
--- a/plugins/netapp/netapp-nvme.c
+++ b/plugins/netapp/netapp-nvme.c
@@ -27,8 +27,8 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
 #include "nvme.h"
-
 #include "util/suffix.h"
 
 #define CREATE_CMD
diff --git a/plugins/ocp/ocp-clear-features.c b/plugins/ocp/ocp-clear-features.c
index 76cb35f3ad..02001a1d0e 100644
--- a/plugins/ocp/ocp-clear-features.c
+++ b/plugins/ocp/ocp-clear-features.c
@@ -7,10 +7,13 @@
  */
 
 #include <unistd.h>
+
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "util/types.h"
+
 #include "ocp-nvme.h"
 #include "ocp-utils.h"
-#include "nvme-print.h"
 
 static int ocp_clear_feature(int argc, char **argv, const char *desc, const __u8 fid)
 {
diff --git a/plugins/ocp/ocp-fw-activation-history.c b/plugins/ocp/ocp-fw-activation-history.c
index f7a2707bc2..aed8f3c8c8 100644
--- a/plugins/ocp/ocp-fw-activation-history.c
+++ b/plugins/ocp/ocp-fw-activation-history.c
@@ -5,17 +5,15 @@
  * Author: karl.dedow@solidigm.com
  */
 
-#include "ocp-fw-activation-history.h"
-
 #include <errno.h>
 #include <stdio.h>
 
 #include "common.h"
 #include "nvme-print.h"
-
+#include "ocp-fw-activation-history.h"
 #include "ocp-nvme.h"
-#include "ocp-utils.h"
 #include "ocp-print.h"
+#include "ocp-utils.h"
 
 static const unsigned char ocp_fw_activation_history_guid[GUID_LEN] = {
 	0x6D, 0x79, 0x9a, 0x76,
diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index 813b8f58e8..af56ccbcf2 100644
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -19,12 +19,12 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "logging.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "platform/types.h"
 #include "util/types.h"
-#include "logging.h"
-#include "nvme-print.h"
 
 #include "ocp-smart-extended-log.h"
 #include "ocp-clear-features.h"
diff --git a/plugins/ocp/ocp-smart-extended-log.c b/plugins/ocp/ocp-smart-extended-log.c
index 8ff0c5aafc..0c9c28cac3 100644
--- a/plugins/ocp/ocp-smart-extended-log.c
+++ b/plugins/ocp/ocp-smart-extended-log.c
@@ -6,14 +6,14 @@
  *          Venkat Ramesh <venkatraghavan@fb.com>
  */
 
-#include "ocp-smart-extended-log.h"
-
 #include <errno.h>
 #include <stdio.h>
 
 #include "common.h"
 #include "nvme-print.h"
+#include "ocp-nvme.h"
 #include "ocp-print.h"
+#include "ocp-smart-extended-log.h"
 #include "ocp-utils.h"
 
 /* C0 SCAO Log Page */
diff --git a/plugins/ocp/ocp-telemetry-decode.c b/plugins/ocp/ocp-telemetry-decode.c
index 3c5cc8575f..55d747ee5e 100644
--- a/plugins/ocp/ocp-telemetry-decode.c
+++ b/plugins/ocp/ocp-telemetry-decode.c
@@ -262,7 +262,89 @@ struct statistic_entry statistic_identifiers_map[] = {
 	{ 0x1A, "PERST Events Count"},
 	{ 0x1B, "Max Die Bad Block"},
 	{ 0x1C, "Max NAND Channel Bad Block"},
-	{ 0x1D, "Minimum NAND Channel Bad Block"}
+	{ 0x1D, "Minimum NAND Channel Bad Block"},
+	{ 0x1E, "Physical Media Units Written"},
+	{ 0x1F, "Physical Media Units Read"},
+	{ 0x20, "Bad User NAND Blocks"},
+	{ 0x21, "Bad System NAND Blocks"},
+	{ 0x22, "XOR Recovery Count"},
+	{ 0x23, "Uncorrectable Read Error Count"},
+	{ 0x24, "Soft ECC Error Count"},
+	{ 0x25, "End to End Correction Counts"},
+	{ 0x26, "System Data % Used"},
+	{ 0x27, "Refresh Counts"},
+	{ 0x28, "User Data Erase Counts"},
+	{ 0x29, "Thermal Throttling Status and Count"},
+	{ 0x2A, "DSSD Specification Version"},
+	{ 0x2B, "PCIe Correctable Error Count"},
+	{ 0x2C, "Incomplete Shutdowns"},
+	{ 0x2D, "% Free Blocks"},
+	{ 0x2E, "Capacitor Health"},
+	{ 0x2F, "NVM Express Base Errata Version"},
+	{ 0x30, "NVM Command Set Errata Version"},
+	{ 0x31, "NVM Express Management Interface Errata Version"},
+	{ 0x32, "Unaligned I/O"},
+	{ 0x33, "Security Version Number"},
+	{ 0x34, "Total NUSE"},
+	{ 0x35, "PLP Start Count"},
+	{ 0x36, "Endurance Estimate"},
+	{ 0x37, "PCIe Link Retraining Count"},
+	{ 0x38, "Power State Change Count"},
+	{ 0x39, "Lowest Permitted Firmware Revision"},
+	{ 0x3A, "Log Page Version"},
+	{ 0x3B, "Media Dies Offline"},
+	{ 0x3C, "Max Temperature Recorded"},
+	{ 0x3D, "NAND Avg. Erase Count"},
+	{ 0x3E, "Command Timeouts"},
+	{ 0x3F, "System Area Program Fail Count"},
+	{ 0x40, "System Area Read Fail Count"},
+	{ 0x41, "System Area Erase Fail Count"},
+	{ 0x42, "Max Peak Power Capability"},
+	{ 0x43, "Current Average Power"},
+	{ 0x44, "Lifetime Power Consumed"},
+	{ 0x45, "Error / Assert Count"},
+	{ 0x46, "Device Busy Time"},
+	{ 0x47, "Critical Warning"},
+	{ 0x48, "Composite Temperature"},
+	{ 0x49, "Available Spare"},
+	{ 0x4A, "Available Spare Threshold"},
+	{ 0x4B, "Percentage Used"},
+	{ 0x4C, "Endurance Group Critical Warning Summary"},
+	{ 0x4D, "Data Units Read"},
+	{ 0x4E, "Data Units Written"},
+	{ 0x4F, "Host Read Commands"},
+	{ 0x50, "Host Write Commands"},
+	{ 0x51, "Controller Busy Time"},
+	{ 0x52, "Power Cycles"},
+	{ 0x53, "Power On Hours"},
+	{ 0x54, "Unsafe Shutdowns"},
+	{ 0x55, "Media and Data Integrity Errors"},
+	{ 0x56, "Number of Error Information Log Entries"},
+	{ 0x57, "Warning Composite Temperature Time"},
+	{ 0x58, "Critical Composite Temperature Time"},
+	{ 0x59, "Temperature Sensor 1"},
+	{ 0x5A, "Temperature Sensor 2"},
+	{ 0x5B, "Temperature Sensor 3"},
+	{ 0x5C, "Temperature Sensor 4"},
+	{ 0x5D, "Temperature Sensor 5"},
+	{ 0x5E, "Temperature Sensor 6"},
+	{ 0x5F, "Temperature Sensor 7"},
+	{ 0x60, "Temperature Sensor 8"},
+	{ 0x61, "Thermal Management Temperature 1 Transition Count"},
+	{ 0x62, "Thermal Management Temperature 2 Transition Count"},
+	{ 0x63, "Total Time For Thermal Management Temperature 1"},
+	{ 0x64, "Total Time For Thermal Management Temperature 2"},
+	{ 0x65, "Endurance Estimate"},
+	{ 0x66, "Data Units Read"},
+	{ 0x67, "Data Units Written"},
+	{ 0x68, "Media Units Written"},
+	{ 0x69, "Number of Error Information Log Entries"},
+	{ 0x6A, "Form Factor"},
+	{ 0x6B, "Dies In Use Bad NAND Blocks"},
+	{ 0x6C, "Proactive Bad Die Retirement"},
+	{ 0x6D, "Namespace ID Context Statistic Descriptor"},
+	{ 0x6E, "Controller ID Context Statistic Descriptor"},
+	{ 0x6F, "Queue ID Context Statistic Descriptor"}
 };
 
 struct request_data host_log_page_header[] = {
@@ -562,7 +644,7 @@ int get_statistic_id_ascii_string(int identifier, char *description)
 
 	// If ASCII string isn't found, see in our internal Map
 	// for 2.5 Spec defined strings
-	if (identifier <= 0x1D) {
+	if (identifier <= 0x6F) {
 		strcpy(description, statistic_identifiers_map[identifier].description);
 		return 0;
 	}
diff --git a/plugins/ocp/ocp-utils.c b/plugins/ocp/ocp-utils.c
index c9fad63be7..966a3e9b62 100644
--- a/plugins/ocp/ocp-utils.c
+++ b/plugins/ocp/ocp-utils.c
@@ -5,12 +5,14 @@
  * Author: leonardo.da.cunha@solidigm.com
  */
 
-#include <unistd.h>
 #include <errno.h>
-#include "util/types.h"
+#include <unistd.h>
+
+#include "nvme-cmds.h"
 #include "ocp-nvme.h"
 #include "ocp-utils.h"
 #include "types.h"
+#include "util/types.h"
 
 const unsigned char ocp_uuid[NVME_UUID_LEN] = {
 	0xc1, 0x94, 0xd5, 0x5b, 0xe0, 0x94, 0x47, 0x94, 0xa2, 0x1d,
@@ -18,7 +20,7 @@ const unsigned char ocp_uuid[NVME_UUID_LEN] = {
 
 int ocp_find_uuid_index(struct nvme_id_uuid_list *uuid_list, __u8 *index)
 {
-	int i = nvme_uuid_find(uuid_list, ocp_uuid);
+	int i = nvme_find_uuid(uuid_list, ocp_uuid);
 
 	*index = 0;
 	if (i > 0)
diff --git a/plugins/sandisk/sandisk-nvme.c b/plugins/sandisk/sandisk-nvme.c
index 3b7c4a13c6..2e1b5e96ae 100644
--- a/plugins/sandisk/sandisk-nvme.c
+++ b/plugins/sandisk/sandisk-nvme.c
@@ -17,12 +17,12 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "platform/types.h"
 #include "util/cleanup.h"
 #include "util/types.h"
-#include "nvme-print.h"
 
 #define CREATE_CMD
 #include "sandisk-nvme.h"
diff --git a/plugins/sandisk/sandisk-utils.c b/plugins/sandisk/sandisk-utils.c
index 04f00fc0ab..8b41ade6ca 100644
--- a/plugins/sandisk/sandisk-utils.c
+++ b/plugins/sandisk/sandisk-utils.c
@@ -15,8 +15,10 @@
 #include <libnvme.h>
 
 #include "common.h"
-#include "nvme.h"
+#include "nvme-cmds.h"
 #include "nvme-print.h"
+#include "nvme.h"
+
 #include "sandisk-utils.h"
 #include "plugins/wdc/wdc-nvme-cmds.h"
 
@@ -335,16 +337,16 @@ bool sndk_get_dev_mgment_data(struct nvme_global_ctx *ctx, struct nvme_transport
 	memset(&uuid_list, 0, sizeof(struct nvme_id_uuid_list));
 	if (!nvme_get_uuid_list(hdl, &uuid_list)) {
 		/* check for the Sandisk UUID first  */
-		uuid_index = nvme_uuid_find(&uuid_list, SNDK_UUID);
+		uuid_index = nvme_find_uuid(&uuid_list, SNDK_UUID);
 
 		if (uuid_index < 0) {
 			/* The Sandisk UUID is not found;
 			 * check for the WDC UUID second.
 			 */
-			uuid_index = nvme_uuid_find(&uuid_list, WDC_UUID);
+			uuid_index = nvme_find_uuid(&uuid_list, WDC_UUID);
 			if (uuid_index < 0)
 				/* Check for the UUID used on SN640 and SN655 drives */
-				uuid_index = nvme_uuid_find(&uuid_list, WDC_UUID_SN640_3);
+				uuid_index = nvme_find_uuid(&uuid_list, WDC_UUID_SN640_3);
 		}
 
 		if (uuid_index >= 0)
@@ -682,16 +684,16 @@ __u64 sndk_get_enc_drive_capabilities(struct nvme_global_ctx *ctx,
 		memset(&uuid_list, 0, sizeof(struct nvme_id_uuid_list));
 		if (!nvme_get_uuid_list(hdl, &uuid_list)) {
 			/* check for the Sandisk UUID first  */
-			uuid_index = nvme_uuid_find(&uuid_list, SNDK_UUID);
+			uuid_index = nvme_find_uuid(&uuid_list, SNDK_UUID);
 
 			if (uuid_index < 0) {
 				/* The Sandisk UUID is not found;
 				 * check for the WDC UUID second.
 				 */
-				uuid_index = nvme_uuid_find(&uuid_list, WDC_UUID);
+				uuid_index = nvme_find_uuid(&uuid_list, WDC_UUID);
 				if (uuid_index < 0)
 					/* Check for the UUID used on SN640 and SN655 drives */
-					uuid_index = nvme_uuid_find(&uuid_list, WDC_UUID_SN640_3);
+					uuid_index = nvme_find_uuid(&uuid_list, WDC_UUID_SN640_3);
 			}
 		} else {
 			/* UUID Lists not supported, Use default uuid index - 0 */
diff --git a/plugins/sandisk/sandisk-utils.h b/plugins/sandisk/sandisk-utils.h
index 9a23bd3408..4b4703bf18 100644
--- a/plugins/sandisk/sandisk-utils.h
+++ b/plugins/sandisk/sandisk-utils.h
@@ -6,21 +6,20 @@
  *           Brandon Paupore <brandon.paupore@sandisk.com>
  */
 
-#include <stdio.h>
+#include <assert.h>
 #include <ctype.h>
+#include <stdbool.h>
 #include <stdarg.h>
-#include <unistd.h>
+#include <stdio.h>
 #include <stdlib.h>
-#include <sys/types.h>
-#include <assert.h>
-#include <time.h>
-#include <sys/time.h>
-#include <sys/stat.h>
-
-#include <stdbool.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
 
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
 /* Device Config */
 #define SNDK_NVME_WDC_VID                   0x1b96
 #define SNDK_NVME_SNDK_VID                  0x15b7
diff --git a/plugins/scaleflux/sfx-nvme.c b/plugins/scaleflux/sfx-nvme.c
index cc85070a2e..6de7e36c79 100644
--- a/plugins/scaleflux/sfx-nvme.c
+++ b/plugins/scaleflux/sfx-nvme.c
@@ -18,10 +18,10 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "platform/types.h"
-#include "nvme-print.h"
 #include "util/cleanup.h"
 #include "util/types.h"
 
@@ -1422,7 +1422,7 @@ static int nvme_expand_cap(struct nvme_transport_handle *hdl, __u32 namespace_id
 	else
 		strcpy(dev_name, nvme_transport_handle_get_name(hdl));
 
-	num = scandir("/dev", &devices, nvme_namespace_filter, alphasort);
+	num = scandir("/dev", &devices, nvme_filter_namespace, alphasort);
 	if (num <= 0) {
 		err = num;
 		goto ret;
diff --git a/plugins/seagate/seagate-nvme.c b/plugins/seagate/seagate-nvme.c
index 6b64c77c56..be61e55e7f 100644
--- a/plugins/seagate/seagate-nvme.c
+++ b/plugins/seagate/seagate-nvme.c
@@ -23,23 +23,25 @@
  */
 
 
-#include <fcntl.h>
+#include <ctype.h>
 #include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
-#include <inttypes.h>
+
 #include <sys/stat.h>
-#include <ctype.h>
+
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "platform/types.h"
-#include "nvme-print.h"
-#include <time.h>
 
 #define CREATE_CMD
 
diff --git a/plugins/sed/sed.c b/plugins/sed/sed.c
index 5a3d828f82..fee0636362 100644
--- a/plugins/sed/sed.c
+++ b/plugins/sed/sed.c
@@ -1,12 +1,15 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
-#include <fcntl.h>
 #include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <stdbool.h>
-#include <inttypes.h>
+
 #include <linux/fs.h>
+#include <linux/sed-opal.h>
+
 #include <sys/stat.h>
 
 #include <libnvme.h>
@@ -15,7 +18,6 @@
 #include "nvme.h"
 #include "nvme-print.h"
 #include "sedopal_cmd.h"
-#include <linux/sed-opal.h>
 
 #define CREATE_CMD
 #include "sed.h"
diff --git a/plugins/sed/sed.h b/plugins/sed/sed.h
index 1618272cb8..d349540d2b 100644
--- a/plugins/sed/sed.h
+++ b/plugins/sed/sed.h
@@ -2,9 +2,10 @@
 #undef CMD_INC_FILE
 #define CMD_INC_FILE plugins/sed/sed
 
-#include "cmd.h"
 #include <linux/sed-opal.h>
 
+#include "cmd.h"
+
 PLUGIN(NAME("sed", "SED Opal Command Set", NVME_VERSION),
 	COMMAND_LIST(
 		ENTRY("discover", "Discover SED Opal Locking Features", sed_opal_discover, "1")
diff --git a/plugins/shannon/shannon-nvme.c b/plugins/shannon/shannon-nvme.c
index 13d120dc56..19083b470c 100644
--- a/plugins/shannon/shannon-nvme.c
+++ b/plugins/shannon/shannon-nvme.c
@@ -8,10 +8,10 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "platform/types.h"
-#include "nvme-print.h"
 
 #define CREATE_CMD
 #include "shannon-nvme.h"
diff --git a/plugins/solidigm/solidigm-internal-logs.c b/plugins/solidigm/solidigm-internal-logs.c
index 471d533707..6ed5e86ef1 100644
--- a/plugins/solidigm/solidigm-internal-logs.c
+++ b/plugins/solidigm/solidigm-internal-logs.c
@@ -18,9 +18,11 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "nvme-print.h"
+
 #include "solidigm-util.h"
 
 #define DWORD_SIZE 4
diff --git a/plugins/solidigm/solidigm-latency-tracking.c b/plugins/solidigm/solidigm-latency-tracking.c
index 2f6eedc132..e007ea3401 100644
--- a/plugins/solidigm/solidigm-latency-tracking.c
+++ b/plugins/solidigm/solidigm-latency-tracking.c
@@ -14,10 +14,11 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "platform/types.h"
-#include "nvme-print.h"
+
 #include "solidigm-util.h"
 
 #define BUCKET_LIST_SIZE_4_0 152
diff --git a/plugins/solidigm/solidigm-log-page-dir.c b/plugins/solidigm/solidigm-log-page-dir.c
index aed7ffdac7..6583ac896d 100644
--- a/plugins/solidigm/solidigm-log-page-dir.c
+++ b/plugins/solidigm/solidigm-log-page-dir.c
@@ -5,17 +5,18 @@
  * Author: karl.dedow@solidigm.com
  */
 
-#include "solidigm-log-page-dir.h"
-
 #include <errno.h>
 #include <stdio.h>
 #include <unistd.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
 #include "nvme-print.h"
 
 #include "plugins/ocp/ocp-nvme.h"
 #include "plugins/ocp/ocp-utils.h"
+
+#include "solidigm-log-page-dir.h"
 #include "solidigm-util.h"
 
 #define MIN_VENDOR_LID 0xC0
diff --git a/plugins/solidigm/solidigm-nvme.h b/plugins/solidigm/solidigm-nvme.h
index c6a556c0c0..e0e5d7c4e5 100644
--- a/plugins/solidigm/solidigm-nvme.h
+++ b/plugins/solidigm/solidigm-nvme.h
@@ -13,7 +13,7 @@
 
 #include "cmd.h"
 
-#define SOLIDIGM_PLUGIN_VERSION "1.18"
+#define SOLIDIGM_PLUGIN_VERSION "1.19"
 
 PLUGIN(NAME("solidigm", "Solidigm vendor specific extensions", SOLIDIGM_PLUGIN_VERSION),
 	COMMAND_LIST(
diff --git a/plugins/solidigm/solidigm-telemetry/config.c b/plugins/solidigm/solidigm-telemetry/config.c
index 3b27d27390..525747c0c1 100644
--- a/plugins/solidigm/solidigm-telemetry/config.c
+++ b/plugins/solidigm/solidigm-telemetry/config.c
@@ -5,11 +5,15 @@
  * Author: leonardo.da.cunha@solidigm.com
  */
 
-#include <stdio.h>
-#include <string.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <json.h>
+
 #include "config.h"
+#include "telemetry-log.h"
 
 #define NOT_FOUND "NOT_FOUND"
 
@@ -20,6 +24,7 @@
 #define NLOG_OBJ_PREFIX OBJ_NAME_PREFIX "NLOG_"
 
 static bool config_get_by_version(const struct json_object *obj,
+				   const char *key,
 				   int version_major, int version_minor,
 				   struct json_object **value)
 {
@@ -39,6 +44,10 @@ static bool config_get_by_version(const struct json_object *obj,
 		/* Try wildcard minor version if exact match failed */
 		if (json_object_object_get_ex(major_obj, "*", value))
 			return value != NULL;
+
+		SOLIDIGM_LOG_WARNING(
+			"Warning: Object %s version major %d found but minor %d not found\n",
+			key, version_major, version_minor);
 	}
 
 	/* Try wildcard major version if exact major version not found */
@@ -63,7 +72,8 @@ bool sldm_config_get_struct_by_key_version(const struct json_object *config, cha
 
 	if (!json_object_object_get_ex(config, key, &token))
 		return false;
-	if (!config_get_by_version(token, version_major, version_minor, value))
+	if (!config_get_by_version(token, key,
+				   version_major, version_minor, value))
 		return false;
 	return value != NULL;
 }
diff --git a/plugins/solidigm/solidigm-telemetry/data-area.c b/plugins/solidigm/solidigm-telemetry/data-area.c
index a36a0c79b0..ed86b651cc 100644
--- a/plugins/solidigm/solidigm-telemetry/data-area.c
+++ b/plugins/solidigm/solidigm-telemetry/data-area.c
@@ -5,15 +5,16 @@
  * Author: leonardo.da.cunha@solidigm.com
  */
 
-#include "common.h"
-#include "header.h"
+#include <ctype.h>
+
 #include "cod.h"
-#include "data-area.h"
+#include "common.h"
 #include "config.h"
+#include "data-area.h"
+#include "header.h"
 #include "nlog.h"
-#include "skht.h"
 #include "side-trace.h"
-#include <ctype.h>
+#include "skht.h"
 
 #define SIGNED_int_PREFIX "int"
 #define SIGNED_INT_PREFIX "INT"
@@ -634,6 +635,18 @@ int solidigm_telemetry_log_data_areas_parse(struct telemetry_log *tl,
 
 	solidigm_telemetry_log_da1_check_ocp(tl);
 	sldm_telemetry_da2_check_skhT(tl);
+	// if TELEMETRY_CONFIG_META available copy it to the output for better
+	// context in the output data
+	if (tl->configuration) {
+		struct json_object *config_meta = NULL;
+
+		if (json_object_object_get_ex(tl->configuration,
+					     "TELEMETRY_CONFIG_META",
+					      &config_meta))
+			json_object_object_add(tl->root,
+					       "TELEMETRY_CONFIG_META",
+					       config_meta);
+	}
 	solidigm_telemetry_log_header_parse(tl);
 	solidigm_telemetry_log_cod_parse(tl);
 	if (tl->configuration) {
diff --git a/plugins/solidigm/solidigm-telemetry/debug-info.c b/plugins/solidigm/solidigm-telemetry/debug-info.c
index 2838a4ba9a..4ebb5e68d4 100644
--- a/plugins/solidigm/solidigm-telemetry/debug-info.c
+++ b/plugins/solidigm/solidigm-telemetry/debug-info.c
@@ -5,15 +5,16 @@
  * Author: leonardo.da.cunha@solidigm.com
  */
 
-#include "debug-info.h"
+#include <string.h>
+
 #include "common.h"
 #include "config.h"
 #include "data-area.h"
+#include "debug-info.h"
 #include "skht.h"
 #include "tracker.h"
 #include "uart-log.h"
 #include "util/json.h"
-#include <string.h>
 
 #define DEBUG_INFO_SIGNATURE 0x54321234 /* "ST21" */
 #define MAX_DEBUG_INFO_CORES 255
diff --git a/plugins/solidigm/solidigm-telemetry/nlog.c b/plugins/solidigm/solidigm-telemetry/nlog.c
index b5ad9b78bd..f6af75b3de 100644
--- a/plugins/solidigm/solidigm-telemetry/nlog.c
+++ b/plugins/solidigm/solidigm-telemetry/nlog.c
@@ -5,10 +5,11 @@
  * Author: leonardo.da.cunha@solidigm.com
  */
 
-#include "nlog.h"
-#include "config.h"
-#include <string.h>
 #include <stdio.h>
+#include <string.h>
+
+#include "config.h"
+#include "nlog.h"
 
 #define LOG_ENTRY_HEADER_SIZE 1
 #define LOG_ENTRY_TIMESTAMP_SIZE 2
diff --git a/plugins/solidigm/solidigm-telemetry/side-trace.c b/plugins/solidigm/solidigm-telemetry/side-trace.c
index c289e33d81..7faea4f6d2 100644
--- a/plugins/solidigm/solidigm-telemetry/side-trace.c
+++ b/plugins/solidigm/solidigm-telemetry/side-trace.c
@@ -5,14 +5,15 @@
  * Author: leonardo.da.cunha@solidigm.com
  */
 
+#include <ctype.h>
+#include <string.h>
+
 #include "common.h"
-#include "telemetry-log.h"
-#include "side-trace.h"
+#include "config.h"
 #include "data-area.h"
 #include "header.h"
-#include "config.h"
-#include <ctype.h>
-#include <string.h>
+#include "side-trace.h"
+#include "telemetry-log.h"
 
 #define NUM_BITS_IN_BYTE 8
 #define SIDETRACE_BLOCK_SIZE 256
diff --git a/plugins/solidigm/solidigm-telemetry/telemetry-log.h b/plugins/solidigm/solidigm-telemetry/telemetry-log.h
index 7da5547382..ad87e0e78c 100644
--- a/plugins/solidigm/solidigm-telemetry/telemetry-log.h
+++ b/plugins/solidigm/solidigm-telemetry/telemetry-log.h
@@ -8,11 +8,12 @@
 #ifndef _SOLIDIGM_TELEMETRY_LOG_H
 #define _SOLIDIGM_TELEMETRY_LOG_H
 
+#include <assert.h>
+#include <stdbool.h>
+
 #include <libnvme.h>
 
 #include "util/json.h"
-#include <assert.h>
-#include <stdbool.h>
 
 #if !defined __cplusplus
 #define static_assert _Static_assert
diff --git a/plugins/solidigm/solidigm-telemetry/uart-log.c b/plugins/solidigm/solidigm-telemetry/uart-log.c
index 603157ad48..e80c7d8c11 100644
--- a/plugins/solidigm/solidigm-telemetry/uart-log.c
+++ b/plugins/solidigm/solidigm-telemetry/uart-log.c
@@ -5,14 +5,15 @@
  * Author: leonardo.da.cunha@solidigm.com
  */
 
-#include "uart-log.h"
+#include <stdio.h>
+#include <string.h>
+
 #include "common.h"
 #include "config.h"
 #include "data-area.h"
 #include "skht.h"
+#include "uart-log.h"
 #include "util/json.h"
-#include <stdio.h>
-#include <string.h>
 
 static bool parse_uart_entry(struct telemetry_log *tl, uint64_t entry_offset_bit,
 			      struct json_object *uart_array)
diff --git a/plugins/solidigm/solidigm-util.c b/plugins/solidigm/solidigm-util.c
index 11b3ba1647..5a9009da77 100644
--- a/plugins/solidigm/solidigm-util.c
+++ b/plugins/solidigm/solidigm-util.c
@@ -6,6 +6,9 @@
  */
 
 #include <errno.h>
+
+#include "nvme-cmds.h"
+
 #include "solidigm-util.h"
 
 const unsigned char solidigm_uuid[NVME_UUID_LEN] = {
@@ -15,7 +18,7 @@ const unsigned char solidigm_uuid[NVME_UUID_LEN] = {
 
 int sldgm_find_uuid_index(struct nvme_id_uuid_list *uuid_list, __u8 *index)
 {
-	int i = nvme_uuid_find(uuid_list, solidigm_uuid);
+	int i = nvme_find_uuid(uuid_list, solidigm_uuid);
 
 	*index = 0;
 	if (i > 0)
diff --git a/plugins/solidigm/solidigm-workload-tracker.c b/plugins/solidigm/solidigm-workload-tracker.c
index 324755b1ff..5c408f6930 100644
--- a/plugins/solidigm/solidigm-workload-tracker.c
+++ b/plugins/solidigm/solidigm-workload-tracker.c
@@ -5,11 +5,13 @@
  * Authors: leonardo.da.cunha@solidigm.com
  */
 
-#include "common.h"
-#include "nvme-print.h"
 #include <errno.h>
 #include <time.h>
 
+#include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
+
 #define LID 0xf9
 #define FID 0xf1
 #define WLT2US 25
diff --git a/plugins/ssstc/ssstc-nvme.c b/plugins/ssstc/ssstc-nvme.c
index 0866a4d4a0..95c3b2c266 100644
--- a/plugins/ssstc/ssstc-nvme.c
+++ b/plugins/ssstc/ssstc-nvme.c
@@ -9,10 +9,10 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "platform/types.h"
-#include "nvme-print.h"
 
 #define CREATE_CMD
 #include "ssstc-nvme.h"
diff --git a/plugins/toshiba/toshiba-nvme.c b/plugins/toshiba/toshiba-nvme.c
index 0baa7f8164..df8d65441c 100644
--- a/plugins/toshiba/toshiba-nvme.c
+++ b/plugins/toshiba/toshiba-nvme.c
@@ -10,10 +10,10 @@
 
 #include <libnvme.h>
 
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "platform/types.h"
-#include "nvme-print.h"
 
 #define CREATE_CMD
 #include "toshiba-nvme.h"
diff --git a/plugins/transcend/transcend-nvme.c b/plugins/transcend/transcend-nvme.c
index 3c36f2434a..425fc4cc2a 100644
--- a/plugins/transcend/transcend-nvme.c
+++ b/plugins/transcend/transcend-nvme.c
@@ -8,6 +8,7 @@
 
 #include <libnvme.h>
 
+#include "nvme-cmds.h"
 #include "nvme.h"
 #include "plugin.h"
 
diff --git a/plugins/virtium/virtium-nvme.c b/plugins/virtium/virtium-nvme.c
index 1e8e5e5d4b..20367db310 100644
--- a/plugins/virtium/virtium-nvme.c
+++ b/plugins/virtium/virtium-nvme.c
@@ -13,6 +13,7 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
 #include "nvme.h"
 #include "plugin.h"
 #include "util/types.h"
diff --git a/plugins/wdc/wdc-nvme.c b/plugins/wdc/wdc-nvme.c
index ab1ed50a5a..8ba7cd1be2 100644
--- a/plugins/wdc/wdc-nvme.c
+++ b/plugins/wdc/wdc-nvme.c
@@ -34,12 +34,12 @@
 #include <libnvme.h>
 
 #include "common.h"
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "platform/types.h"
 #include "util/cleanup.h"
 #include "util/types.h"
-#include "nvme-print.h"
 
 #define CREATE_CMD
 #include "wdc-nvme.h"
@@ -2121,13 +2121,13 @@ static __u64 wdc_get_enc_drive_capabilities(struct nvme_global_ctx *ctx,
 		memset(&uuid_list, 0, sizeof(struct nvme_id_uuid_list));
 		if (wdc_CheckUuidListSupport(hdl, &uuid_list)) {
 			/* check for the Sandisk UUID first  */
-			uuid_index = nvme_uuid_find(&uuid_list, SNDK_UUID);
+			uuid_index = nvme_find_uuid(&uuid_list, SNDK_UUID);
 
 			if (uuid_index < 0)
 				/* The Sandisk UUID is not found;
 				 * check for the WDC UUID second.
 				 */
-				uuid_index = nvme_uuid_find(&uuid_list, WDC_UUID);
+				uuid_index = nvme_find_uuid(&uuid_list, WDC_UUID);
 		}
 
 		/* WD UUID not found, use default uuid index - 0 */
@@ -2734,15 +2734,15 @@ static bool get_dev_mgment_data(struct nvme_global_ctx *ctx, struct nvme_transpo
 	memset(&uuid_list, 0, sizeof(struct nvme_id_uuid_list));
 	if (wdc_CheckUuidListSupport(hdl, &uuid_list)) {
 		/* check for the Sandisk UUID first  */
-		uuid_index = nvme_uuid_find(&uuid_list, SNDK_UUID);
+		uuid_index = nvme_find_uuid(&uuid_list, SNDK_UUID);
 
 		if (uuid_index < 0) {
 			/* The Sandisk UUID is not found;
 			 * check for the WDC UUID second.
 			 */
-			uuid_index = nvme_uuid_find(&uuid_list, WDC_UUID);
+			uuid_index = nvme_find_uuid(&uuid_list, WDC_UUID);
 			if (uuid_index < 0)
-				uuid_index = nvme_uuid_find(&uuid_list, WDC_UUID_SN640_3);
+				uuid_index = nvme_find_uuid(&uuid_list, WDC_UUID_SN640_3);
 		}
 
 		if (uuid_index >= 0)
@@ -2803,15 +2803,15 @@ static bool get_dev_mgment_cbs_data(struct nvme_global_ctx *ctx, struct nvme_tra
 	memset(&uuid_list, 0, sizeof(struct nvme_id_uuid_list));
 	if (wdc_CheckUuidListSupport(hdl, &uuid_list)) {
 		/* check for the Sandisk UUID first  */
-		uuid_index = nvme_uuid_find(&uuid_list, SNDK_UUID);
+		uuid_index = nvme_find_uuid(&uuid_list, SNDK_UUID);
 
 		if (uuid_index < 0) {
 			/* The Sandisk UUID is not found;
 			 * check for the WDC UUID second.
 			 */
-			uuid_index = nvme_uuid_find(&uuid_list, WDC_UUID);
+			uuid_index = nvme_find_uuid(&uuid_list, WDC_UUID);
 			if (uuid_index < 0)
-				uuid_index = nvme_uuid_find(&uuid_list, WDC_UUID_SN640_3);
+				uuid_index = nvme_find_uuid(&uuid_list, WDC_UUID_SN640_3);
 		}
 
 		if (uuid_index >= 0)
@@ -9096,13 +9096,13 @@ static int wdc_drive_status(int argc, char **argv, struct command *acmd,
 	memset(&uuid_list, 0, sizeof(struct nvme_id_uuid_list));
 	if (wdc_CheckUuidListSupport(hdl, &uuid_list)) {
 		/* check for the Sandisk UUID first  */
-		uuid_index = nvme_uuid_find(&uuid_list, SNDK_UUID);
+		uuid_index = nvme_find_uuid(&uuid_list, SNDK_UUID);
 
 		if (uuid_index < 0)
 			/* The Sandisk UUID is not found;
 			 * check for the WDC UUID second.
 			 */
-			uuid_index = nvme_uuid_find(&uuid_list, WDC_UUID);
+			uuid_index = nvme_find_uuid(&uuid_list, WDC_UUID);
 	}
 
 	/* WD UUID not found, use default uuid index - 0 */
@@ -10871,13 +10871,13 @@ static int wdc_log_page_directory(int argc, char **argv, struct command *acmd,
 		if (!wdc_is_sn861(device_id)) {
 			if (uuid_supported) {
 				/* check for the Sandisk UUID first  */
-				uuid_index = nvme_uuid_find(&uuid_list, SNDK_UUID);
+				uuid_index = nvme_find_uuid(&uuid_list, SNDK_UUID);
 
 				if (uuid_index < 0)
 					/* The Sandisk UUID is not found;
 					 * check for the WDC UUID second.
 					 */
-					uuid_index = nvme_uuid_find(&uuid_list, WDC_UUID);
+					uuid_index = nvme_find_uuid(&uuid_list, WDC_UUID);
 			}
 
 			/* WD UUID not found, use default uuid index - 0 */
diff --git a/plugins/wdc/wdc-utils.c b/plugins/wdc/wdc-utils.c
index 7e257d355d..7e6afaf014 100644
--- a/plugins/wdc/wdc-utils.c
+++ b/plugins/wdc/wdc-utils.c
@@ -27,8 +27,10 @@
 
 #include <libnvme.h>
 
-#include "nvme.h"
+#include "nvme-cmds.h"
 #include "nvme-print.h"
+#include "nvme.h"
+
 #include "wdc-utils.h"
 
 int wdc_UtilsSnprintf(char *buffer, unsigned int sizeOfBuffer, const char *format, ...)
diff --git a/plugins/wdc/wdc-utils.h b/plugins/wdc/wdc-utils.h
index 1ea1ec49cc..6b87891543 100644
--- a/plugins/wdc/wdc-utils.h
+++ b/plugins/wdc/wdc-utils.h
@@ -20,21 +20,20 @@
  *   Author: Jeff Lien <jeff.lien@wdc.com>,
  */
 
-#include <stdio.h>
+#include <assert.h>
 #include <ctype.h>
+#include <stdbool.h>
 #include <stdarg.h>
-#include <unistd.h>
+#include <stdio.h>
 #include <stdlib.h>
-#include <sys/types.h>
-#include <assert.h>
-#include <time.h>
-#include <sys/time.h>
-#include <sys/stat.h>
-
-#include <stdbool.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
 
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
 /* Create Dir Command Status */
 #define WDC_STATUS_SUCCESS                		  			0
 #define WDC_STATUS_FAILURE   					 			-1
diff --git a/plugins/ymtc/ymtc-nvme.c b/plugins/ymtc/ymtc-nvme.c
index ff3efc4d27..6f4a5e5d1d 100644
--- a/plugins/ymtc/ymtc-nvme.c
+++ b/plugins/ymtc/ymtc-nvme.c
@@ -7,10 +7,10 @@
 
 #include <libnvme.h>
 
+#include "nvme-cmds.h"
+#include "nvme-print.h"
 #include "nvme.h"
 #include "plugin.h"
-#include "platform/types.h"
-#include "nvme-print.h"
 
 #define CREATE_CMD
 #include "ymtc-nvme.h"
diff --git a/plugins/ymtc/ymtc-nvme.h b/plugins/ymtc/ymtc-nvme.h
index df5d598feb..8d193dc10d 100644
--- a/plugins/ymtc/ymtc-nvme.h
+++ b/plugins/ymtc/ymtc-nvme.h
@@ -5,13 +5,14 @@
 #if !defined(YMTC_NVME) || defined(CMD_HEADER_MULTI_READ)
 #define YMTC_NVME
 
-#include "cmd.h"
-#include "common.h"
-
 #include <ctype.h>
 #include <unistd.h>
-#include <sys/types.h>
+
 #include <sys/stat.h>
+#include <sys/types.h>
+
+#include "cmd.h"
+#include "common.h"
 
 PLUGIN(NAME("ymtc", "Ymtc vendor specific extensions", NVME_VERSION),
     COMMAND_LIST(
diff --git a/plugins/zns/zns.c b/plugins/zns/zns.c
index 3802318083..fe07059f5f 100644
--- a/plugins/zns/zns.c
+++ b/plugins/zns/zns.c
@@ -1,19 +1,22 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
-#include <asm-generic/errno-base.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <inttypes.h>
+
 #include <linux/fs.h>
 #include <sys/stat.h>
 
+#include <asm-generic/errno-base.h>
+
 #include <libnvme.h>
 
 #include "common.h"
-#include "nvme.h"
+#include "nvme-cmds.h"
 #include "nvme-print.h"
+#include "nvme.h"
 #include "util/cleanup.h"
 
 #define CREATE_CMD
diff --git a/scripts/build.sh b/scripts/build.sh
index 223790f113..feced9279f 100755
--- a/scripts/build.sh
+++ b/scripts/build.sh
@@ -34,6 +34,7 @@ usage() {
     echo "  html_docs           build html documentation only"
     echo "  rst_docs            build rst documentation only"
     echo "  static              build a static binary"
+    echo "  minimal_static      build a static binary without fabrics support"
     echo "  libnvme             build only libnvme"
     echo ""
     echo "configs with muon:"
@@ -90,14 +91,17 @@ config_meson_default() {
 }
 
 config_meson_musl() {
-    local c_args="-U_GNU_SOURCE \
--idirafter /usr/include -idirafter \
-/usr/include/x86_64-linux-gnu"
+	local cflags=(
+		-U_GNU_SOURCE
+		-idirafter /usr/include
+		-idirafter /usr/include/x86_64-linux-gnu
+	)
+	local cflags_str="${cflags[*]}"
 
     CC="${CC}" "${MESON}" setup                 \
         --werror                                \
         --buildtype="${BUILDTYPE}"              \
-        -Dc_args="${c_args}"                    \
+        -Dc_args="${cflags_str}"                \
         -Ddefault_library=static                \
         -Djson-c=disabled                       \
         -Dopenssl=disabled                      \
@@ -194,6 +198,46 @@ config_meson_static() {
         "${BUILDDIR}"
 }
 
+config_meson_minimal_static() {
+	local cflags=(
+		-U_GNU_SOURCE
+		-idirafter /usr/include
+		-idirafter /usr/include/x86_64-linux-gnu
+		-Oz
+		-flto
+		-ffunction-sections
+		-fdata-sections
+		-fno-unwind-tables
+		-fno-asynchronous-unwind-tables
+		-fno-stack-protector
+	)
+	local ldflags=(
+		-flto
+		-Wl,--gc-sections
+		-s
+		-Wl,--build-id=none
+		-static
+	)
+	local cflags_str="${cflags[*]}"
+	local ldflags_str="${ldflags[*]}"
+
+	CC=musl-gcc
+
+    CC="${CC}" "${MESON}" setup                 \
+        --werror                                \
+        --buildtype=release                     \
+        --default-library=static                \
+        --prefix=/usr                           \
+        -Dplugins="sed,lm,feat,zns,fdp"         \
+        -Dc_args="${cflags_str}"                \
+        -Dc_link_args="${ldflags_str}"          \
+        -Dfabrics=disabled                      \
+        -Djson-c=disabled                       \
+        -Dtests=false                           \
+        -Dexamples=false                        \
+        "${BUILDDIR}"
+}
+
 config_meson_libnvme() {
     CC="${CC}" "${MESON}" setup                 \
         --werror                                \
diff --git a/scripts/release.sh b/scripts/release.sh
index c05a2dc10d..5efeec2f4d 100755
--- a/scripts/release.sh
+++ b/scripts/release.sh
@@ -108,41 +108,6 @@ if [ "$build_doc" = true ]; then
     git commit -s -m "doc: Regenerate all docs for $VERSION"
 fi
 
-declare -A ldscripts
-ldscripts=(
-    [libnvme/src/libnvme.ld]=LIBNVME
-)
-
-lib_ver="${ver//./_}"
-
-for ld_file in "${!ldscripts[@]}"
-do
-    lib_name=${ldscripts[$ld_file]}
-
-    if [ ! -f "${ld_file}" ]; then
-       continue
-    fi
-
-    lib_unreleased="${lib_name}_UNRELEASED"
-
-    # Check if UNRELEASED has symbols
-    if ! awk -v lib_unreleased="$lib_unreleased" '
-        $0 ~ "^"lib_unreleased { in_section = 1; next }
-        in_section && $0 ~ /\}/ { exit }
-        in_section && $0 !~ /^[[:space:]]*($|\/|\/\*|\*|#)/ { found = 1; exit }
-        END { exit !found }
-    ' "${ld_file}"; then
-        continue
-    fi
-
-    sed -i \
-        -e "s/^${lib_unreleased}\s*{/&\n};\n\n${lib_name}_${lib_ver} {/" \
-        "$ld_file"
-
-    git add "${ld_file}"
-    echo "${ld_file} updated."
-done
-
 # update meson.build
 sed -i -e "0,/[ \t]version: /s/\([ \t]version: \).*/\1\'$ver\',/" meson.build
 git add meson.build
diff --git a/unit/test-argconfig-parse.c b/unit/test-argconfig-parse.c
index cecad9b9b3..29ab6907a8 100644
--- a/unit/test-argconfig-parse.c
+++ b/unit/test-argconfig-parse.c
@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <errno.h>
 #include <locale.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "../util/argconfig.h"
 #include "../util/cleanup.h"
diff --git a/unit/test-suffix-binary-parse.c b/unit/test-suffix-binary-parse.c
index 5f6ac4a896..f6da72161b 100644
--- a/unit/test-suffix-binary-parse.c
+++ b/unit/test-suffix-binary-parse.c
@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <string.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <errno.h>
+#include <string.h>
 
 #include "../util/suffix.h"
 #include "../util/types.h"
diff --git a/unit/test-suffix-si-parse.c b/unit/test-suffix-si-parse.c
index 54cff0e644..b33352ab1a 100644
--- a/unit/test-suffix-si-parse.c
+++ b/unit/test-suffix-si-parse.c
@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <errno.h>
 #include <locale.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "../util/suffix.h"
 #include "../util/types.h"
diff --git a/unit/test-uint128-si.c b/unit/test-uint128-si.c
index cc13450c45..76cebcf3f5 100644
--- a/unit/test-uint128-si.c
+++ b/unit/test-uint128-si.c
@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "../util/types.h"
 
diff --git a/unit/test-uint128.c b/unit/test-uint128.c
index f7bc6f6445..0a1f7d3259 100644
--- a/unit/test-uint128.c
+++ b/unit/test-uint128.c
@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <string.h>
+#include <locale.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <locale.h>
+#include <string.h>
 
 #include "../util/types.h"
 
diff --git a/util/argconfig.c b/util/argconfig.c
index d3e121164b..dded73c876 100644
--- a/util/argconfig.c
+++ b/util/argconfig.c
@@ -29,20 +29,20 @@
  *
  */
 
-#include "argconfig.h"
-#include "cleanup.h"
-#include "suffix.h"
-
 #include <errno.h>
-#include <inttypes.h>
 #include <getopt.h>
+#include <inttypes.h>
 #include <limits.h>
+#include <locale.h>
+#include <stdbool.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdarg.h>
 #include <string.h>
-#include <stdbool.h>
-#include <locale.h>
+
+#include "argconfig.h"
+#include "cleanup.h"
+#include "suffix.h"
 
 const char *nvme_strerror(int errnum);
 
diff --git a/util/argconfig.h b/util/argconfig.h
index afe183e5f4..5b426e2c7b 100644
--- a/util/argconfig.h
+++ b/util/argconfig.h
@@ -34,12 +34,12 @@
 #ifndef argconfig_H
 #define argconfig_H
 
-#include <string.h>
 #include <getopt.h>
-#include <stdarg.h>
-#include <stdio.h>
 #include <stdbool.h>
+#include <stdarg.h>
 #include <stdint.h>
+#include <stdio.h>
+#include <string.h>
 
 #include <platform/types.h>
 
diff --git a/util/base64.c b/util/base64.c
index 0e89f2e9df..9fc35ec46b 100644
--- a/util/base64.c
+++ b/util/base64.c
@@ -20,10 +20,11 @@
  * MA  02110-1301, USA.
  */
 
+#include <errno.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
-#include <errno.h>
+
 #include <sys/types.h>
 
 static const char base64_table[65] =
diff --git a/util/cleanup.h b/util/cleanup.h
index 93dff8c53a..8104f3950d 100644
--- a/util/cleanup.h
+++ b/util/cleanup.h
@@ -2,8 +2,8 @@
 #ifndef __CLEANUP_H
 #define __CLEANUP_H
 
-#include <unistd.h>
 #include <stdlib.h>
+#include <unistd.h>
 
 #include <libnvme.h>
 
@@ -51,12 +51,14 @@ static inline void cleanup_nvme_global_ctx(struct nvme_global_ctx **ctx)
 static inline DEFINE_CLEANUP_FUNC(cleanup_nvme_ctrl, nvme_ctrl_t, nvme_free_ctrl)
 #define _cleanup_nvme_ctrl_ __cleanup__(cleanup_nvme_ctrl)
 
+#ifdef CONFIG_FABRICS
 static inline void free_uri(struct nvme_fabrics_uri **uri)
 {
 	if (*uri)
 		nvmf_free_uri(*uri);
 }
 #define _cleanup_uri_ __cleanup__(free_uri)
+#endif
 
 static inline DEFINE_CLEANUP_FUNC(cleanup_file, FILE *, fclose)
 #define _cleanup_file_ __cleanup__(cleanup_file)
diff --git a/util/crc32.h b/util/crc32.h
index e48c97da8e..43113cf391 100644
--- a/util/crc32.h
+++ b/util/crc32.h
@@ -3,8 +3,8 @@
 #ifndef crc32_H
 #define crc32_H
 
-#include <stdint.h>
 #include <stddef.h>
+#include <stdint.h>
 
 uint32_t crc32(uint32_t crc, unsigned char *buf, size_t len);
 
diff --git a/util/mem.c b/util/mem.c
index 375c960883..0f677d5c1d 100644
--- a/util/mem.c
+++ b/util/mem.c
@@ -29,6 +29,8 @@ void *nvme_realloc(void *p, size_t len)
 	size_t old_len = malloc_usable_size(p);
 
 	void *result = nvme_alloc(len);
+	if (!result)
+		return NULL;
 
 	if (p) {
 		memcpy(result, p, min(old_len, len));
diff --git a/util/suffix.c b/util/suffix.c
index f010f3b6a9..019a12b200 100644
--- a/util/suffix.c
+++ b/util/suffix.c
@@ -30,17 +30,17 @@
  *
  */
 
-#include "suffix.h"
-#include "common.h"
-
-#include <stdlib.h>
 #include <ctype.h>
 #include <errno.h>
-#include <math.h>
 #include <float.h>
 #include <limits.h>
 #include <locale.h>
+#include <math.h>
 #include <stdio.h>
+#include <stdlib.h>
+
+#include "suffix.h"
+#include "common.h"
 
 static struct si_suffix {
 	long double magnitude;
diff --git a/util/types.h b/util/types.h
index abec3ba969..bb032227cf 100644
--- a/util/types.h
+++ b/util/types.h
@@ -5,6 +5,8 @@
 /* type conversion helpers */
 
 #include <stdint.h>
+#include <time.h>
+
 #include <platform/types.h>
 
 #include <libnvme.h>

From 4db6c0fbec18b69ac79ea1b696439070f8837bca Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Tue, 24 Mar 2026 09:57:43 -0600
Subject: [PATCH 40/83] Fixing Windows and Linux build problems caused by the
 last merge from master. (#80)

- Fixed link_args variable name used during Linux builds.
- Removed unneeded net/if.h include from platform/linux.h due to
duplicate definitions it was causing after latest updates.
- Added nvme/filters.c to Linux build sources.
- Added new pre-generated accessors.c to Windows build and removed stubs
for methods now defined in accessors.c.
- Renamed methods in ioctl-windows.c to match new names in ioctl.h/.c
and added __public decorators.
- Renamed stub methods in windows-stubs.c to match new naming and
updated nvme_ns_get_transport_handle stub.
---
 libnvme/src/meson.build          |  10 +-
 libnvme/src/nvme/accessors.h     |   2 +-
 libnvme/src/nvme/ioctl-windows.c |  14 ++-
 libnvme/src/nvme/lib.h           |   1 +
 libnvme/src/nvme/windows-stubs.c | 196 +------------------------------
 libnvme/src/platform/linux.h     |   1 -
 6 files changed, 19 insertions(+), 205 deletions(-)

diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index be53ae54e2..329ce02c38 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -6,6 +6,7 @@
 # Authors: Martin Belanger <Martin.Belanger@dell.com>
 #
 sources = [
+    'nvme/accessors.c',
     'nvme/base64.c',
     'nvme/cmds.c',
     'nvme/crc32.c',
@@ -25,7 +26,7 @@ if is_windows
     ]
 else
     sources += [
-        'nvme/accessors.c',
+        'nvme/filters.c',
         'nvme/linux.c',
         'nvme/mi-mctp.c',
         'nvme/mi.c',
@@ -94,13 +95,8 @@ accessors_ld = meson.current_source_dir() / 'accessors.ld'
 
 link_args = [
     '-Wl,--version-script=@0@'.format(nvme_ld),
+    '-Wl,--version-script=@0@'.format(accessors_ld),
 ]
-# Skipping accessor generation for now on Windows. Needs to be ported.
-if not is_windows
-    libnvme_link_args += [
-        '-Wl,--version-script=@0@'.format(accessors_ld),
-    ]
-endif
 
 libconf = configuration_data()
 if want_fabrics
diff --git a/libnvme/src/nvme/accessors.h b/libnvme/src/nvme/accessors.h
index 5c594dd127..ea0b20f74b 100644
--- a/libnvme/src/nvme/accessors.h
+++ b/libnvme/src/nvme/accessors.h
@@ -24,7 +24,7 @@
 #include <string.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <linux/types.h> /* __u32, __u64, etc. */
+#include <platform/types.h> /* __u32, __u64, etc. */
 
 /* Forward declarations. These are internal (opaque) structs. */
 struct nvme_path;
diff --git a/libnvme/src/nvme/ioctl-windows.c b/libnvme/src/nvme/ioctl-windows.c
index 5398e2e04c..111cfaad28 100644
--- a/libnvme/src/nvme/ioctl-windows.c
+++ b/libnvme/src/nvme/ioctl-windows.c
@@ -21,6 +21,8 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
+#include "compiler_attributes.h"
+
 /* Definitions not yet included in mingw's winerror.h */
 #define STG_E_FIRMWARE_SLOT_INVALID      _HRESULT_TYPEDEF_(0x80030208L)
 #define STG_E_FIRMWARE_IMAGE_INVALID     _HRESULT_TYPEDEF_(0x80030209L)
@@ -94,25 +96,25 @@ static bool get_is_win_pe(void)
 	return false;
 }
 
-int nvme_subsystem_reset(struct nvme_transport_handle *hdl)
+__public int nvme_reset_subsystem(struct nvme_transport_handle *hdl)
 {
 	(void)hdl;
 	return -ENOTSUP;
 }
 
-int nvme_ctrl_reset(struct nvme_transport_handle *hdl)
+__public int nvme_reset_ctrl(struct nvme_transport_handle *hdl)
 {
 	(void)hdl;
 	return -ENOTSUP;
 }
 
-int nvme_ns_rescan(struct nvme_transport_handle *hdl)
+__public int nvme_rescan_ns(struct nvme_transport_handle *hdl)
 {
 	(void)hdl;
 	return -ENOTSUP;
 }
 
-int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
+__public int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
 {
 	/* Get the SCSI LUN, which corresponds to NSID - 1. */
 	SCSI_ADDRESS addr = {0};
@@ -1511,7 +1513,7 @@ static int nvme_submit_admin_security_send_receive(
  * For supported commands and a mapping to the required IOCTLs, see:
  * https://learn.microsoft.com/en-us/windows-hardware/drivers/storage/stornvme-command-set-support
  */
-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 || !cmd)
@@ -1547,7 +1549,7 @@ int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
  * For supported commands and a mapping to the required IOCTLs, see:
  * https://learn.microsoft.com/en-us/windows-hardware/drivers/storage/stornvme-command-set-support
  */
-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)
 {
 	if (!hdl || !cmd)
diff --git a/libnvme/src/nvme/lib.h b/libnvme/src/nvme/lib.h
index 92b426331d..3106a5c627 100644
--- a/libnvme/src/nvme/lib.h
+++ b/libnvme/src/nvme/lib.h
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <stdbool.h>
+#include <stdio.h>
 
 #include "platform/includes.h"
 
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 9f24363e7c..9b885105bd 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -357,13 +357,6 @@ int nvme_ns_get_fd(void *ns)
 	return -1;
 }
 
-int nvme_ns_get_nsid(nvme_ns_t n)
-{
-	stub_log(__func__);
-	(void)n;
-	return 0;
-}
-
 enum nvme_csi nvme_ns_get_csi(nvme_ns_t n)
 {
 	stub_log(__func__);
@@ -392,11 +385,13 @@ void nvme_ns_get_uuid(nvme_ns_t n, unsigned char out[NVME_UUID_LEN])
 	(void)out;
 }
 
-struct nvme_transport_handle *nvme_ns_get_transport_handle(nvme_ns_t n)
+int nvme_ns_get_transport_handle(nvme_ns_t n,
+		struct nvme_transport_handle **hdl)
 {
 	stub_log(__func__);
 	(void)n;
-	return NULL;
+	(void)hdl;
+	return -ENOTSUP;
 }
 
 int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns)
@@ -408,20 +403,6 @@ int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns)
 	return -1;
 }
 
-const char *nvme_ns_get_sysfs_dir(nvme_ns_t n)
-{
-	stub_log(__func__);
-	(void)n;
-	return "";
-}
-
-const char *nvme_ns_get_name(nvme_ns_t n)
-{
-	stub_log(__func__);
-	(void)n;
-	return "";
-}
-
 const char *nvme_ns_get_generic_name(nvme_ns_t n)
 {
 	stub_log(__func__);
@@ -429,48 +410,6 @@ const char *nvme_ns_get_generic_name(nvme_ns_t n)
 	return "";
 }
 
-int nvme_ns_get_lba_size(nvme_ns_t n)
-{
-	stub_log(__func__);
-	(void)n;
-	return 0;
-}
-
-uint64_t nvme_ns_get_lba_count(nvme_ns_t n)
-{
-	stub_log(__func__);
-	(void)n;
-	return 0;
-}
-
-uint64_t nvme_ns_get_lba_util(nvme_ns_t n)
-{
-	stub_log(__func__);
-	(void)n;
-	return 0;
-}
-
-const char *nvme_path_get_name(nvme_path_t p)
-{
-	stub_log(__func__);
-	(void)p;
-	return "";
-}
-
-const char *nvme_path_get_sysfs_dir(nvme_path_t p)
-{
-	stub_log(__func__);
-	(void)p;
-	return "";
-}
-
-const char *nvme_path_get_ana_state(nvme_path_t p)
-{
-	stub_log(__func__);
-	(void)p;
-	return "";
-}
-
 nvme_ctrl_t nvme_path_get_ctrl(nvme_path_t p)
 {
 	stub_log(__func__);
@@ -485,20 +424,6 @@ nvme_ns_t nvme_path_get_ns(nvme_path_t p)
 	return NULL;
 }
 
-const char *nvme_ctrl_get_name(nvme_ctrl_t c)
-{
-	stub_log(__func__);
-	(void)c;
-	return "";
-}
-
-const char *nvme_ctrl_get_sysfs_dir(nvme_ctrl_t c)
-{
-	stub_log(__func__);
-	(void)c;
-	return "";
-}
-
 const char *nvme_ctrl_get_address(nvme_ctrl_t c)
 {
 	stub_log(__func__);
@@ -506,13 +431,6 @@ const char *nvme_ctrl_get_address(nvme_ctrl_t c)
 	return "";
 }
 
-const char *nvme_ctrl_get_transport(nvme_ctrl_t c)
-{
-	stub_log(__func__);
-	(void)c;
-	return "";
-}
-
 const char *nvme_ctrl_get_state(nvme_ctrl_t c)
 {
 	stub_log(__func__);
@@ -597,21 +515,11 @@ void *nvme_subsys_get_host(void *s)
 }
 
 /* Subsystem functions (full name) - same as subsys */
-const char *nvme_subsystem_get_name(nvme_subsystem_t s)
-{
-	return nvme_subsys_get_name(s);
-}
-
 const char *nvme_subsystem_get_nqn(nvme_subsystem_t s)
 {
 	return nvme_subsys_get_nqn(s);
 }
 
-const char *nvme_subsystem_get_sysfs_dir(nvme_subsystem_t s)
-{
-	return nvme_subsys_get_sysfs_dir(s);
-}
-
 nvme_host_t nvme_subsystem_get_host(nvme_subsystem_t s)
 {
 	return nvme_subsys_get_host(s);
@@ -637,20 +545,6 @@ nvme_ns_t nvme_subsystem_next_ns(nvme_subsystem_t s, nvme_ns_t n)
 	return nvme_subsys_next_ns(s, n);
 }
 
-const char *nvme_host_get_hostnqn(nvme_host_t h)
-{
-	stub_log(__func__);
-	(void)h;
-	return "";
-}
-
-const char *nvme_host_get_hostid(nvme_host_t h)
-{
-	stub_log(__func__);
-	(void)h;
-	return "";
-}
-
 void *nvme_host_get_root(void *h)
 {
 	stub_log(__func__);
@@ -824,42 +718,6 @@ int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encoded_key,
 /*
  * Additional stubs for nvme-cli linking
  */
-/* Controller property getters (tree.c) */
-const char *nvme_ctrl_get_cntlid(nvme_ctrl_t c)
-{
-	stub_log(__func__);
-	(void)c;
-	return "";
-}
-
-const char *nvme_ctrl_get_firmware(nvme_ctrl_t c)
-{
-	stub_log(__func__);
-	(void)c;
-	return "";
-}
-
-const char *nvme_ctrl_get_model(nvme_ctrl_t c)
-{
-	stub_log(__func__);
-	(void)c;
-	return "";
-}
-
-const char *nvme_ctrl_get_phy_slot(nvme_ctrl_t c)
-{
-	stub_log(__func__);
-	(void)c;
-	return "";
-}
-
-const char *nvme_ctrl_get_serial(nvme_ctrl_t c)
-{
-	stub_log(__func__);
-	(void)c;
-	return "";
-}
-
 /* Subsystem property getters (tree.c) */
 const char *nvme_subsystem_get_fw_rev(nvme_subsystem_t s)
 {
@@ -868,27 +726,6 @@ const char *nvme_subsystem_get_fw_rev(nvme_subsystem_t s)
 	return "";
 }
 
-const char *nvme_subsystem_get_iopolicy(nvme_subsystem_t s)
-{
-	stub_log(__func__);
-	(void)s;
-	return "";
-}
-
-const char *nvme_subsystem_get_model(nvme_subsystem_t s)
-{
-	stub_log(__func__);
-	(void)s;
-	return "";
-}
-
-const char *nvme_subsystem_get_serial(nvme_subsystem_t s)
-{
-	stub_log(__func__);
-	(void)s;
-	return "";
-}
-
 const char *nvme_subsystem_get_type(nvme_subsystem_t s)
 {
 	stub_log(__func__);
@@ -904,13 +741,6 @@ const char *nvme_ns_get_firmware(nvme_ns_t n)
 	return "";
 }
 
-int nvme_ns_get_meta_size(nvme_ns_t n)
-{
-	stub_log(__func__);
-	(void)n;
-	return 0;
-}
-
 const char *nvme_ns_get_model(nvme_ns_t n)
 {
 	stub_log(__func__);
@@ -1107,7 +937,7 @@ int nvme_generate_tls_key_identity(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-char *nvmf_hostnqn_from_file(void)
+char *nvme_read_hostnqn(void)
 {
 	stub_log(__func__);
 	/* No /etc/nvme/hostnqn equivalent on Windows */
@@ -1131,28 +961,14 @@ int nvme_gen_dhchap_key(struct nvme_global_ctx *ctx,
 }
 
 /* Hostnqn generation (fabrics.c) */
-char *nvmf_hostnqn_generate(void)
+char *nvme_generate_hostnqn(void)
 {
 	stub_log(__func__);
 	/* Could implement UUID-based generation, but for now just fail */
 	return NULL;
 }
 
-char *nvmf_hostnqn_generate_from_hostid(char *hostid)
-{
-	stub_log(__func__);
-	(void)hostid;
-	return NULL;
-}
-
 /* Path property getters (tree.c) */
-const char *nvme_path_get_numa_nodes(struct nvme_path *p)
-{
-	stub_log(__func__);
-	(void)p;
-	return "";
-}
-
 int nvme_path_get_queue_depth(struct nvme_path *p)
 {
 	stub_log(__func__);
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index 5bf7158600..2962cddc79 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -30,7 +30,6 @@
 #include <syslog.h>
 #include <dirent.h>
 #include <endian.h>
-#include <net/if.h>
 
 /* Linux cleanup attribute */
 #define __nvme_cleanup(fn) __attribute__((__cleanup__(fn)))

From 58db985c32ee13f7fa7cdf02adbcc00043e2bf8a Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Tue, 24 Mar 2026 13:02:51 -0700
Subject: [PATCH 41/83] Fixed merge error.

---
 libnvme/src/nvme/fabrics.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/libnvme/src/nvme/fabrics.c b/libnvme/src/nvme/fabrics.c
index 349f9ad7f8..7ae52ebe4f 100644
--- a/libnvme/src/nvme/fabrics.c
+++ b/libnvme/src/nvme/fabrics.c
@@ -2641,8 +2641,7 @@ static int nbft_discovery(struct nvme_global_ctx *ctx,
 		if (e->subtype == NVME_NQN_DISC) {
 			nvme_ctrl_t child;
 
-			ret = nvmf_connect_disc_entry(h, e,
-				nfctx.host_traddr, nfctx.host_iface,
+			ret = nvmf_connect_disc_entry(h, e, &nfctx,
 				defcfg, NULL, &child);
 			if (ret)
 				continue;

From f2773fe17ca9690eab247064bd627a7df706a3f1 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Tue, 24 Mar 2026 16:12:50 -0600
Subject: [PATCH 42/83] Fixing libnvme check-public-symbols test failures.
 (#81)

The new check-public-symbols tests fail due to not finding
implementations with the __public attribute for some of the methods
we've added to libnvme.ld.

- Added __public where needed.
- Moved windows POSIX implementations/stubs into platform/windows.h as
inline implementations and removed windows.c.
- Removed now-unused windows stubs.
---
 libnvme/src/libnvme.ld           |  10 -
 libnvme/src/meson.build          |   1 -
 libnvme/src/nvme/lib-windows.c   |   7 +-
 libnvme/src/nvme/windows-stubs.c | 436 ++++++-------------------------
 libnvme/src/platform/windows.c   | 116 --------
 libnvme/src/platform/windows.h   | 122 ++++++++-
 6 files changed, 203 insertions(+), 489 deletions(-)
 delete mode 100644 libnvme/src/platform/windows.c

diff --git a/libnvme/src/libnvme.ld b/libnvme/src/libnvme.ld
index 86f96026dd..7bd17433f6 100644
--- a/libnvme/src/libnvme.ld
+++ b/libnvme/src/libnvme.ld
@@ -1,13 +1,4 @@
 # SPDX-License-Identifier: LGPL-2.1-or-later
-LIBNVME_UNRELEASED {
-	global:
-		# Windows POSIX compatibility functions
-		getline;
-		reallocarray;
-		readlink;
-		open_memstream;
-		strsep;
-};
 
 LIBNVME_3 {
 	global:
@@ -204,7 +195,6 @@ LIBNVME_3 {
 		nvme_uuid_from_string;
 		nvme_random_uuid;
 		nvme_uuid_to_string;
-		platform_aligned_free;
 	local:
 		*;
 };
diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index 329ce02c38..947cb246b5 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -22,7 +22,6 @@ if is_windows
         'nvme/ioctl-windows.c',  # Windows stubs for Linux-specific ioctl functions
         'nvme/lib-windows.c',  # Windows implementations of lib.h functions
         'nvme/windows-stubs.c',  # Stubs for excluded functions
-        'platform/windows.c',  # POSIX compatibility implementations
     ]
 else
     sources += [
diff --git a/libnvme/src/nvme/lib-windows.c b/libnvme/src/nvme/lib-windows.c
index 8140d5e0ef..fd9c60716f 100644
--- a/libnvme/src/nvme/lib-windows.c
+++ b/libnvme/src/nvme/lib-windows.c
@@ -8,6 +8,7 @@
 
 #include "private.h"
 #include "nvme/lib.h"
+#include "compiler_attributes.h"
 
 
 static int __nvme_transport_handle_open_direct(struct nvme_transport_handle *hdl, const char *name)
@@ -62,7 +63,7 @@ static int __nvme_transport_handle_open_direct(struct nvme_transport_handle *hdl
 }
 
 /* Transport handle operations (linux.c) */
-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;
@@ -108,7 +109,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;
@@ -133,7 +134,7 @@ void nvme_close(struct nvme_transport_handle *hdl)
 }
 
 /* Platform-specific fstat wrapper for nvme_fd_t */
-int nvme_fstat(nvme_fd_t fd, struct stat *buf)
+__public int nvme_fstat(nvme_fd_t fd, struct stat *buf)
 {
 	BY_HANDLE_FILE_INFORMATION file_info;
 	ULARGE_INTEGER ull;
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 713a1365a9..4804e61c12 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -9,9 +9,12 @@
 
 #include <errno.h>
 #include <stdio.h>
+
 #include <nvme/linux.h>
 #include <nvme/types.h>
+
 #include "private.h"
+#include "compiler_attributes.h"
 
 /* Logging control for stub calls */
 static int stub_log_enabled = 0;
@@ -27,107 +30,6 @@ void nvme_stubs_set_debug(int enable)
 	stub_log_enabled = enable;
 }
 
-/*
- * Stub implementations for fabrics functions (fabrics.c)
- * These are not supported on Windows
- */
-
-/* Fabrics configuration stubs - just return errors */
-void nvmf_default_config(struct nvme_fabrics_config *cfg)
-{
-	stub_log(__func__);
-	(void)cfg;
-}
-
-void nvmf_update_config(nvme_ctrl_t c, const struct nvme_fabrics_config *cfg)
-{
-	stub_log(__func__);
-	(void)c;
-	(void)cfg;
-}
-
-int nvmf_add_ctrl(nvme_host_t h, nvme_ctrl_t c,
-		  const struct nvme_fabrics_config *cfg)
-{
-	stub_log(__func__);
-	(void)h;
-	(void)c;
-	(void)cfg;
-	errno = ENOTSUP;
-	return -1;
-}
-
-int nvmf_connect_ctrl(nvme_ctrl_t c)
-{
-	stub_log(__func__);
-	(void)c;
-	errno = ENOTSUP;
-	return -1;
-}
-
-int nvmf_get_discovery_log(nvme_ctrl_t c, struct nvmf_discovery_log **logp, int max_retries)
-{
-	stub_log(__func__);
-	(void)c;
-	(void)logp;
-	(void)max_retries;
-	errno = ENOTSUP;
-	return -1;
-}
-
-int nvmf_get_discovery_wargs(struct nvme_get_discovery_args *args, struct nvmf_discovery_log **logp)
-{
-	stub_log(__func__);
-	(void)args;
-	(void)logp;
-	errno = ENOTSUP;
-	return -1;
-}
-
-int nvmf_connect_disc_entry(void *h, void *e, const void *defcfg, int *discover, void **c)
-{
-	stub_log(__func__);
-	(void)h;
-	(void)e;
-	(void)defcfg;
-	(void)discover;
-	(void)c;
-	errno = ENOTSUP;
-	return -1;
-}
-
-bool nvmf_is_registration_supported(nvme_ctrl_t c)
-{
-	stub_log(__func__);
-	(void)c;
-	return false; /* Not supported */
-}
-
-int nvmf_register_ctrl(nvme_ctrl_t c, enum nvmf_dim_tas tas, __u32 *result)
-{
-	stub_log(__func__);
-	(void)c;
-	(void)tas;
-	(void)result;
-	errno = ENOTSUP;
-	return -1;
-}
-
-int nvme_parse_uri(const char *str, struct nvme_fabrics_uri **uri)
-{
-	stub_log(__func__);
-	(void)str;
-	(void)uri;
-	errno = ENOTSUP;
-	return -1;
-}
-
-void nvme_free_uri(struct nvme_fabrics_uri *uri)
-{
-	stub_log(__func__);
-	(void)uri;
-}
-
 /*
  * Stub implementations for tree functions (tree.c)
  * Minimal support - just return NULL/errors
@@ -138,52 +40,7 @@ void __nvme_free_host(struct nvme_host *h)
 	(void)h;
 }
 
-void nvme_release_fds(struct nvme_global_ctx *ctx)
-{
-	stub_log(__func__);
-	(void)ctx;
-}
-
-void *nvme_create_root(const char *config_file, int log_level)
-{
-	stub_log(__func__);
-	(void)config_file;
-	(void)log_level;
-	/* Return NULL - tree operations not supported on Windows */
-	return NULL;
-}
-
-void nvme_free_tree(void *r)
-{
-	stub_log(__func__);
-	(void)r;
-}
-
-const char *nvme_root_get_application(void *r)
-{
-	stub_log(__func__);
-	(void)r;
-	return "";
-}
-
-void nvme_root_set_application(void *r, const char *a)
-{
-	stub_log(__func__);
-	(void)r;
-	(void)a;
-}
-
-int nvme_scan(const char *config_file, struct nvme_global_ctx **ctx)
-{
-	stub_log(__func__);
-	(void)config_file;
-	(void)ctx;
-	/* Scanning not supported on Windows */
-	errno = ENOTSUP;
-	return -1;
-}
-
-int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name, nvme_ctrl_t *c)
+__public int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name, nvme_ctrl_t *c)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -193,7 +50,7 @@ int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name, nvme_ctrl_t *c
 	return -1;
 }
 
-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)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -203,14 +60,14 @@ int nvme_scan_topology(struct nvme_global_ctx *ctx, nvme_scan_filter_t f, void *
 	return -1;
 }
 
-nvme_host_t nvme_first_host(struct nvme_global_ctx *ctx)
+__public nvme_host_t nvme_first_host(struct nvme_global_ctx *ctx)
 {
 	stub_log(__func__);
 	(void)ctx;
 	return NULL;
 }
 
-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)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -227,23 +84,14 @@ nvme_host_t nvme_lookup_host(struct nvme_global_ctx *ctx, const char *hostnqn, c
 	return NULL;
 }
 
-int nvme_default_host(struct nvme_global_ctx *ctx, nvme_host_t *h)
-{
-	stub_log(__func__);
-	(void)ctx;
-	(void)h;
-	errno = ENOTSUP;
-	return -1;
-}
-
-nvme_subsystem_t nvme_first_subsystem(nvme_host_t h)
+__public nvme_subsystem_t nvme_first_subsystem(nvme_host_t h)
 {
 	stub_log(__func__);
 	(void)h;
 	return NULL;
 }
 
-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)
 {
 	stub_log(__func__);
 	(void)h;
@@ -260,21 +108,6 @@ nvme_subsystem_t nvme_lookup_subsystem(struct nvme_host *h, const char *name, co
 	return NULL;
 }
 
-void *nvme_first_ctrl(void *s)
-{
-	stub_log(__func__);
-	(void)s;
-	return NULL;
-}
-
-void *nvme_next_ctrl(void *s, void *c)
-{
-	stub_log(__func__);
-	(void)s;
-	(void)c;
-	return NULL;
-}
-
 nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s,
 			     struct nvmf_context *fctx,
 			     nvme_ctrl_t p)
@@ -286,14 +119,14 @@ nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s,
 	return NULL;
 }
 
-nvme_ns_t nvme_ctrl_first_ns(nvme_ctrl_t c)
+__public nvme_ns_t nvme_ctrl_first_ns(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-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)
 {
 	stub_log(__func__);
 	(void)c;
@@ -301,14 +134,14 @@ nvme_ns_t nvme_ctrl_next_ns(nvme_ctrl_t c, nvme_ns_t n)
 	return NULL;
 }
 
-nvme_path_t nvme_ctrl_first_path(nvme_ctrl_t c)
+__public nvme_path_t nvme_ctrl_first_path(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-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)
 {
 	stub_log(__func__);
 	(void)c;
@@ -316,64 +149,42 @@ nvme_path_t nvme_ctrl_next_path(nvme_ctrl_t c, nvme_path_t p)
 	return NULL;
 }
 
-void *nvme_subsys_first_ns(void *s)
-{
-	stub_log(__func__);
-	(void)s;
-	return NULL;
-}
-
-void *nvme_subsys_next_ns(void *s, void *ns)
-{
-	stub_log(__func__);
-	(void)s;
-	(void)ns;
-	return NULL;
-}
-
-nvme_subsystem_t nvme_ns_get_subsystem(nvme_ns_t n)
+__public nvme_subsystem_t nvme_ns_get_subsystem(nvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return NULL;
 }
 
-nvme_ctrl_t nvme_ns_get_ctrl(nvme_ns_t n)
+__public nvme_ctrl_t nvme_ns_get_ctrl(nvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return NULL;
 }
 
-int nvme_ns_get_fd(void *ns)
-{
-	stub_log(__func__);
-	(void)ns;
-	return -1;
-}
-
-enum nvme_csi nvme_ns_get_csi(nvme_ns_t n)
+__public enum nvme_csi nvme_ns_get_csi(nvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return 0;
 }
 
-const uint8_t *nvme_ns_get_eui64(nvme_ns_t n)
+__public const uint8_t *nvme_ns_get_eui64(nvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return NULL;
 }
 
-const uint8_t *nvme_ns_get_nguid(nvme_ns_t n)
+__public const uint8_t *nvme_ns_get_nguid(nvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return NULL;
 }
 
-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])
 {
 	stub_log(__func__);
 	(void)n;
@@ -389,7 +200,7 @@ int nvme_ns_get_transport_handle(nvme_ns_t n,
 	return -ENOTSUP;
 }
 
-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)
 {
 	stub_log(__func__);
 	(void)n;
@@ -398,76 +209,62 @@ int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns)
 	return -1;
 }
 
-const char *nvme_ns_get_generic_name(nvme_ns_t n)
+__public const char *nvme_ns_get_generic_name(nvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return "";
 }
 
-nvme_ctrl_t nvme_path_get_ctrl(nvme_path_t p)
+__public nvme_ctrl_t nvme_path_get_ctrl(nvme_path_t p)
 {
 	stub_log(__func__);
 	(void)p;
 	return NULL;
 }
 
-nvme_ns_t nvme_path_get_ns(nvme_path_t p)
+__public nvme_ns_t nvme_path_get_ns(nvme_path_t p)
 {
 	stub_log(__func__);
 	(void)p;
 	return NULL;
 }
 
-const char *nvme_ctrl_get_address(nvme_ctrl_t c)
-{
-	stub_log(__func__);
-	(void)c;
-	return "";
-}
-
-const char *nvme_ctrl_get_state(nvme_ctrl_t c)
+__public const char *nvme_ctrl_get_state(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return "";
 }
 
-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)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-int nvme_ctrl_get_fd(void *c)
-{
-	stub_log(__func__);
-	(void)c;
-	return -1;
-}
-
-nvme_subsystem_t nvme_ctrl_get_subsystem(nvme_ctrl_t c)
+__public nvme_subsystem_t nvme_ctrl_get_subsystem(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-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)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-void nvme_free_ctrl(struct nvme_ctrl *c)
+__public void nvme_free_ctrl(struct nvme_ctrl *c)
 {
 	stub_log(__func__);
 	(void)c;
 }
 
-int nvme_disconnect_ctrl(nvme_ctrl_t c)
+__public int nvme_disconnect_ctrl(nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
@@ -475,79 +272,51 @@ int nvme_disconnect_ctrl(nvme_ctrl_t c)
 	return -1;
 }
 
-void nvme_unlink_ctrl(struct nvme_ctrl *c)
+__public void nvme_unlink_ctrl(struct nvme_ctrl *c)
 {
 	stub_log(__func__);
 	(void)c;
 }
 
-const char *nvme_subsys_get_name(void *s)
+/* Subsystem functions (full name) - same as subsys */
+__public nvme_host_t nvme_subsystem_get_host(nvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)s;
-	return "";
+	return NULL;
 }
 
-const char *nvme_subsys_get_nqn(void *s)
+__public nvme_ctrl_t nvme_subsystem_first_ctrl(nvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)s;
-	return "";
+	return NULL;
 }
 
-const char *nvme_subsys_get_sysfs_dir(void *s)
+__public nvme_ctrl_t nvme_subsystem_next_ctrl(nvme_subsystem_t s, nvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)s;
-	return "";
+	(void)c;
+	return NULL;
 }
 
-void *nvme_subsys_get_host(void *s)
+__public nvme_ns_t nvme_subsystem_first_ns(nvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)s;
 	return NULL;
 }
 
-/* Subsystem functions (full name) - same as subsys */
-const char *nvme_subsystem_get_nqn(nvme_subsystem_t s)
-{
-	return nvme_subsys_get_nqn(s);
-}
-
-nvme_host_t nvme_subsystem_get_host(nvme_subsystem_t s)
-{
-	return nvme_subsys_get_host(s);
-}
-
-nvme_ctrl_t nvme_subsystem_first_ctrl(nvme_subsystem_t s)
-{
-	return nvme_first_ctrl(s);
-}
-
-nvme_ctrl_t nvme_subsystem_next_ctrl(nvme_subsystem_t s, nvme_ctrl_t c)
-{
-	return nvme_next_ctrl(s, c);
-}
-
-nvme_ns_t nvme_subsystem_first_ns(nvme_subsystem_t s)
-{
-	return nvme_subsys_first_ns(s);
-}
-
-nvme_ns_t nvme_subsystem_next_ns(nvme_subsystem_t s, nvme_ns_t n)
-{
-	return nvme_subsys_next_ns(s, n);
-}
-
-void *nvme_host_get_root(void *h)
+__public nvme_ns_t nvme_subsystem_next_ns(nvme_subsystem_t s, nvme_ns_t n)
 {
 	stub_log(__func__);
-	(void)h;
+	(void)s;
+	(void)n;
 	return NULL;
 }
 
-int nvme_dump_tree(struct nvme_global_ctx *ctx)
+__public int nvme_dump_tree(struct nvme_global_ctx *ctx)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -555,7 +324,7 @@ int nvme_dump_tree(struct nvme_global_ctx *ctx)
 	return -1;
 }
 
-int nvme_dump_config(struct nvme_global_ctx *ctx, int fd)
+__public int nvme_dump_config(struct nvme_global_ctx *ctx, int fd)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -578,28 +347,14 @@ int nvme_mi_admin_admin_passthru(struct nvme_transport_handle *hdl,
 	return -1;
 }
 
-void *nvme_mi_create_root(void *fp, int log_level)
-{
-	stub_log(__func__);
-	(void)fp;
-	(void)log_level;
-	return NULL;
-}
-
-void nvme_mi_free_root(void *root)
-{
-	stub_log(__func__);
-	(void)root;
-}
-
-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)
 {
 	stub_log(__func__);
 	(void)ctx;
 	return NULL;
 }
 
-nvme_mi_ep_t nvme_mi_next_endpoint(struct nvme_global_ctx *ctx, nvme_mi_ep_t e)
+__public nvme_mi_ep_t nvme_mi_next_endpoint(struct nvme_global_ctx *ctx, nvme_mi_ep_t e)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -607,7 +362,7 @@ nvme_mi_ep_t nvme_mi_next_endpoint(struct nvme_global_ctx *ctx, nvme_mi_ep_t e)
 	return NULL;
 }
 
-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)
 {
 	stub_log(__func__);
 	(void)ep;
@@ -632,26 +387,16 @@ struct nvme_transport_handle *nvme_mi_next_transport_handle(nvme_mi_ep_t ep,
 	return NULL;
 }
 
-void nvme_mi_close(nvme_mi_ep_t ep)
+__public void nvme_mi_close(nvme_mi_ep_t ep)
 {
 	stub_log(__func__);
 	(void)ep;
 }
 
-/*
- * Stub for Linux-specific includes
- */
-int nvme_linux_status_to_errno(int status)
-{
-	stub_log(__func__);
-	/* Simple passthrough - proper implementation would need status code mapping */
-	return status < 0 ? -status : status;
-}
-
 /*
  * TLS/PSK key management stubs (linux.c functions)
  */
-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 **identity)
@@ -667,7 +412,7 @@ int nvme_export_tls_key_versioned(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-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 **identity)
 {
 	stub_log(__func__);
@@ -679,7 +424,7 @@ int nvme_export_tls_key(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-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,
@@ -697,7 +442,7 @@ int nvme_import_tls_key_versioned(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-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 **key)
 {
 	stub_log(__func__);
@@ -713,37 +458,22 @@ int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encoded_key,
 /*
  * Additional stubs for nvme-cli linking
  */
-/* Subsystem property getters (tree.c) */
-const char *nvme_subsystem_get_fw_rev(nvme_subsystem_t s)
-{
-	stub_log(__func__);
-	(void)s;
-	return "";
-}
-
-const char *nvme_subsystem_get_type(nvme_subsystem_t s)
-{
-	stub_log(__func__);
-	(void)s;
-	return "";
-}
-
 /* Namespace property getters (tree.c) */
-const char *nvme_ns_get_firmware(nvme_ns_t n)
+__public const char *nvme_ns_get_firmware(nvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return "";
 }
 
-const char *nvme_ns_get_model(nvme_ns_t n)
+__public const char *nvme_ns_get_model(nvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return "";
 }
 
-const char *nvme_ns_get_serial(nvme_ns_t n)
+__public const char *nvme_ns_get_serial(nvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
@@ -751,14 +481,14 @@ const char *nvme_ns_get_serial(nvme_ns_t n)
 }
 
 /* Namespace path iteration (tree.c) */
-nvme_path_t nvme_namespace_first_path(nvme_ns_t ns)
+__public nvme_path_t nvme_namespace_first_path(nvme_ns_t ns)
 {
 	stub_log(__func__);
 	(void)ns;
 	return NULL;
 }
 
-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)
 {
 	stub_log(__func__);
 	(void)ns;
@@ -767,7 +497,7 @@ nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p)
 }
 
 /* MI status string (mi.c) */
-const char *nvme_mi_status_to_string(int status)
+__public const char *nvme_mi_status_to_string(int status)
 {
 	stub_log(__func__);
 	(void)status;
@@ -778,7 +508,7 @@ const char *nvme_mi_status_to_string(int status)
  * Linux keyring and TLS key management stubs (linux.c)
  * These are used by nvme-cli security commands
  */
-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)
 {
 	stub_log(__func__);
@@ -791,7 +521,7 @@ int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
 	return -1;
 }
 
-int nvme_lookup_keyring(struct nvme_global_ctx *ctx,
+__public int nvme_lookup_keyring(struct nvme_global_ctx *ctx,
 		const char *keyring, long *key)
 {
 	stub_log(__func__);
@@ -802,7 +532,7 @@ int nvme_lookup_keyring(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-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)
 {
@@ -818,7 +548,7 @@ int nvme_update_key(struct nvme_global_ctx *ctx, long keyring_id,
 	return -1;
 }
 
-int nvme_revoke_tls_key(struct nvme_global_ctx *ctx, const char *keyring,
+__public int nvme_revoke_tls_key(struct nvme_global_ctx *ctx, const char *keyring,
 		const char *key_type, const char *identity)
 {
 	stub_log(__func__);
@@ -830,7 +560,7 @@ int nvme_revoke_tls_key(struct nvme_global_ctx *ctx, const char *keyring,
 	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)
 {
 	stub_log(__func__);
@@ -842,7 +572,7 @@ int nvme_scan_tls_keys(struct nvme_global_ctx *ctx, const char *keyring,
 	return -1;
 }
 
-char *nvme_describe_key_serial(struct nvme_global_ctx *ctx,
+__public char *nvme_describe_key_serial(struct nvme_global_ctx *ctx,
 		long key_id)
 {
 	stub_log(__func__);
@@ -851,7 +581,7 @@ char *nvme_describe_key_serial(struct nvme_global_ctx *ctx,
 	return NULL;
 }
 
-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,
@@ -873,7 +603,7 @@ int nvme_insert_tls_key_versioned(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-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 **identity)
@@ -891,7 +621,7 @@ int nvme_generate_tls_key_identity_compat(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-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,
@@ -913,7 +643,7 @@ int nvme_insert_tls_key_compat(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-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,
@@ -932,14 +662,14 @@ int nvme_generate_tls_key_identity(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-char *nvme_read_hostnqn(void)
+__public char *nvme_read_hostnqn(void)
 {
 	stub_log(__func__);
 	/* No /etc/nvme/hostnqn equivalent on Windows */
 	return NULL;
 }
 
-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)
@@ -956,7 +686,7 @@ int nvme_gen_dhchap_key(struct nvme_global_ctx *ctx,
 }
 
 /* Hostnqn generation (fabrics.c) */
-char *nvme_generate_hostnqn(void)
+__public char *nvme_generate_hostnqn(void)
 {
 	stub_log(__func__);
 	/* Could implement UUID-based generation, but for now just fail */
@@ -964,7 +694,7 @@ char *nvme_generate_hostnqn(void)
 }
 
 /* Path property getters (tree.c) */
-int nvme_path_get_queue_depth(struct nvme_path *p)
+__public int nvme_path_get_queue_depth(struct nvme_path *p)
 {
 	stub_log(__func__);
 	(void)p;
@@ -972,63 +702,63 @@ int nvme_path_get_queue_depth(struct nvme_path *p)
 }
 
 /* Fabrics string conversion functions (fabrics.c) */
-const char *nvmf_trtype_str(__u8 trtype)
+__public const char *nvmf_trtype_str(__u8 trtype)
 {
 	stub_log(__func__);
 	(void)trtype;
 	return "unknown";
 }
 
-const char *nvmf_eflags_str(__u16 eflags)
+__public const char *nvmf_eflags_str(__u16 eflags)
 {
 	stub_log(__func__);
 	(void)eflags;
 	return "unknown";
 }
 
-const char *nvmf_sectype_str(__u8 sectype)
+__public const char *nvmf_sectype_str(__u8 sectype)
 {
 	stub_log(__func__);
 	(void)sectype;
 	return "unknown";
 }
 
-const char *nvmf_cms_str(__u8 cms)
+__public const char *nvmf_cms_str(__u8 cms)
 {
 	stub_log(__func__);
 	(void)cms;
 	return "unknown";
 }
 
-const char *nvmf_qptype_str(__u8 qptype)
+__public const char *nvmf_qptype_str(__u8 qptype)
 {
 	stub_log(__func__);
 	(void)qptype;
 	return "unknown";
 }
 
-const char *nvmf_prtype_str(__u8 prtype)
+__public const char *nvmf_prtype_str(__u8 prtype)
 {
 	stub_log(__func__);
 	(void)prtype;
 	return "unknown";
 }
 
-const char *nvmf_adrfam_str(__u8 adrfam)
+__public const char *nvmf_adrfam_str(__u8 adrfam)
 {
 	stub_log(__func__);
 	(void)adrfam;
 	return "unknown";
 }
 
-const char *nvmf_subtype_str(__u8 subtype)
+__public const char *nvmf_subtype_str(__u8 subtype)
 {
 	stub_log(__func__);
 	(void)subtype;
 	return "unknown";
 }
 
-const char *nvmf_treq_str(__u8 treq)
+__public const char *nvmf_treq_str(__u8 treq)
 {
 	stub_log(__func__);
 	(void)treq;
@@ -1036,7 +766,7 @@ const char *nvmf_treq_str(__u8 treq)
 }
 
 /* NBFT functions (nbft.c) */
-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 **nbft_list)
 {
 	stub_log(__func__);
@@ -1047,7 +777,7 @@ int nvmf_nbft_read_files(struct nvme_global_ctx *ctx, char *path,
 	return -1;
 }
 
-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)
 {
 	stub_log(__func__);
 	(void)ctx;
diff --git a/libnvme/src/platform/windows.c b/libnvme/src/platform/windows.c
deleted file mode 100644
index 656928e124..0000000000
--- a/libnvme/src/platform/windows.c
+++ /dev/null
@@ -1,116 +0,0 @@
-// SPDX-License-Identifier: LGPL-2.1-or-later
-/*
- * This file is part of libnvme.
- * Copyright (c) 2025 Micron Technology, Inc.
- *
- * Windows platform-specific function implementations.
- * Provides POSIX-compatible functions for Windows.
- */
-
-#include "platform/includes.h"
-#include <stdlib.h>
-#include <string.h>
-
-/* getline implementation for Windows */
-ssize_t getline(char **lineptr, size_t *n, FILE *stream) {
-	char *bufptr = NULL;
-	char *p = bufptr;
-	size_t size;
-	int c;
-
-	if (lineptr == NULL || stream == NULL || n == NULL) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	bufptr = *lineptr;
-	size = *n;
-
-	c = fgetc(stream);
-	if (c == EOF) {
-		return -1;
-	}
-
-	if (bufptr == NULL) {
-		bufptr = malloc(128);
-		if (bufptr == NULL) {
-			errno = ENOMEM;
-			return -1;
-		}
-		size = 128;
-	}
-
-	p = bufptr;
-	while (c != EOF) {
-		if ((size_t)(p - bufptr) + 1 >= size) {
-			size_t pos = (size_t)(p - bufptr);
-			size = size + 128;
-			bufptr = realloc(bufptr, size);
-			if (bufptr == NULL) {
-				errno = ENOMEM;
-				return -1;
-			}
-			p = bufptr + pos;
-		}
-		*p++ = c;
-		if (c == '\n') {
-			break;
-		}
-		c = fgetc(stream);
-	}
-
-	*p = '\0';
-	*lineptr = bufptr;
-	*n = size;
-
-	return p - bufptr;
-}
-
-/* strsep implementation for Windows */
-char *strsep(char **stringp, const char *delim) {
-	char *start = *stringp;
-	char *p;
-
-	if (start == NULL)
-		return NULL;
-
-	p = strpbrk(start, delim);
-	if (p) {
-		*p = '\0';
-		*stringp = p + 1;
-	} else {
-		*stringp = NULL;
-	}
-
-	return start;
-}
-
-/* reallocarray implementation for Windows */
-void *reallocarray(void *ptr, size_t nmemb, size_t size)
-{
-	size_t total_size;
-	
-	/* Check for multiplication overflow */
-	if (nmemb != 0 && size > SIZE_MAX / nmemb) {
-		errno = ENOMEM;
-		return NULL;
-	}
-	
-	total_size = nmemb * size;
-	return realloc(ptr, total_size);
-}
-
-/* readlink stub - Windows doesn't have symbolic links in the same way */
-int readlink(const char *path, char *buf, size_t bufsiz) {
-	(void)path; (void)buf; (void)bufsiz;
-	errno = EINVAL;
-	return -1;
-}
-
-/* open_memstream stub - returns a temporary file instead */
-FILE *open_memstream(char **ptr, size_t *sizeloc) {
-	FILE *f = tmpfile();
-	if (ptr) *ptr = NULL;
-	if (sizeloc) *sizeloc = 0;
-	return f;
-}
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 22c9a73e8a..447e116717 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -293,21 +293,131 @@ static inline int random_uuid(unsigned char *uuid, size_t len)
 /* If dirent.h is not available, we would define our own, but MinGW provides it */
 
 /* stdio.h POSIX extensions */
-ssize_t getline(char **lineptr, size_t *n, FILE *stream);
-FILE *open_memstream(char **ptr, size_t *sizeloc);
+
+/* getline implementation for Windows */
+static inline ssize_t getline(char **lineptr, size_t *n, FILE *stream)
+{
+	char *bufptr = NULL;
+	char *p = bufptr;
+	size_t size;
+	int c;
+
+	if (lineptr == NULL || stream == NULL || n == NULL) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	bufptr = *lineptr;
+	size = *n;
+
+	c = fgetc(stream);
+	if (c == EOF)
+		return -1;
+
+	if (bufptr == NULL) {
+		bufptr = (char *)malloc(128);
+		if (bufptr == NULL) {
+			errno = ENOMEM;
+			return -1;
+		}
+		size = 128;
+	}
+
+	p = bufptr;
+	while (c != EOF) {
+		if ((size_t)(p - bufptr) + 1 >= size) {
+			size_t pos = (size_t)(p - bufptr);
+
+			size = size + 128;
+			bufptr = (char *)realloc(bufptr, size);
+			if (bufptr == NULL) {
+				errno = ENOMEM;
+				return -1;
+			}
+			p = bufptr + pos;
+		}
+		*p++ = c;
+		if (c == '\n')
+			break;
+		c = fgetc(stream);
+	}
+
+	*p = '\0';
+	*lineptr = bufptr;
+	*n = size;
+
+	return p - bufptr;
+}
+
+/* open_memstream stub - returns a temporary file instead */
+static inline FILE *open_memstream(char **ptr, size_t *sizeloc)
+{
+	FILE *f = tmpfile();
+
+	if (ptr)
+		*ptr = NULL;
+	if (sizeloc)
+		*sizeloc = 0;
+	return f;
+}
 
 /* string.h POSIX extensions */
-char *strsep(char **stringp, const char *delim);
-void *reallocarray(void *ptr, size_t nmemb, size_t size);
+
+/* strsep implementation for Windows */
+static inline char *strsep(char **stringp, const char *delim)
+{
+	char *start = *stringp;
+	char *p;
+
+	if (start == NULL)
+		return NULL;
+
+	p = strpbrk(start, delim);
+	if (p) {
+		*p = '\0';
+		*stringp = p + 1;
+	} else {
+		*stringp = NULL;
+	}
+
+	return start;
+}
+
+/* reallocarray implementation for Windows */
+static inline void *reallocarray(void *ptr, size_t nmemb, size_t size)
+{
+	size_t total_size;
+
+	/* Check for multiplication overflow */
+	if (nmemb != 0 && size > SIZE_MAX / nmemb) {
+		errno = ENOMEM;
+		return NULL;
+	}
+
+	total_size = nmemb * size;
+	return realloc(ptr, total_size);
+}
 
 /* unistd.h POSIX functions */
-int readlink(const char *path, char *buf, size_t bufsiz);
+
+/*
+ * readlink stub - Windows doesn't have symbolic links in the same way
+ * NOTE: This is only used by micron-nvme.c, and can be removed once that
+ * has been refactored to not rely on Linux-specific sysfs paths.
+ */
+static inline int readlink(const char *path, char *buf, size_t bufsiz)
+{
+	(void)path;
+	(void)buf;
+	(void)bufsiz;
+	errno = EINVAL;
+	return -1;
+}
 
 /* unistd.h additions */
 #ifndef fsync
 #define fsync _commit
 #endif
-int readlink(const char *path, char *buf, size_t bufsiz);
 
 /* time.h POSIX compatibility */
 static inline struct tm *gmtime_r(const time_t *timep, struct tm *result) {

From a6bc95bdd6de9702178d316f5a7a174a32e44881 Mon Sep 17 00:00:00 2001
From: Brandon Capener <bcapener@micron.com>
Date: Wed, 25 Mar 2026 13:34:48 -0600
Subject: [PATCH 43/83] fix for last merge from master (#82)

Adds a missing macro to our windows.h
---
 libnvme/src/platform/windows.h | 117 +++++++++++++++++----------------
 1 file changed, 62 insertions(+), 55 deletions(-)

diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 447e116717..3a8c65d8b1 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -43,20 +43,26 @@
 
 /* Windows endian conversion macros */
 #if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-    #define htole16(x) __builtin_bswap16(x)
-    #define htole32(x) __builtin_bswap32(x)
-    #define htole64(x) __builtin_bswap64(x)
-    #define le16toh(x) __builtin_bswap16(x)
-    #define le32toh(x) __builtin_bswap32(x)
-    #define le64toh(x) __builtin_bswap64(x)
+	#define htobe16(x) (x)
+	#define htobe32(x) (x)
+	#define htobe64(x) (x)
+	#define htole16(x) __builtin_bswap16(x)
+	#define htole32(x) __builtin_bswap32(x)
+	#define htole64(x) __builtin_bswap64(x)
+	#define le16toh(x) __builtin_bswap16(x)
+	#define le32toh(x) __builtin_bswap32(x)
+	#define le64toh(x) __builtin_bswap64(x)
 #else
-    /* Little-endian (most common case for Windows) */
-    #define htole16(x) (x)
-    #define htole32(x) (x)
-    #define htole64(x) (x)
-    #define le16toh(x) (x)
-    #define le32toh(x) (x)
-    #define le64toh(x) (x)
+	/* Little-endian (most common case for Windows) */
+	#define htobe16(x) __builtin_bswap16(x)
+	#define htobe32(x) __builtin_bswap32(x)
+	#define htobe64(x) __builtin_bswap64(x)
+	#define htole16(x) (x)
+	#define htole32(x) (x)
+	#define htole64(x) (x)
+	#define le16toh(x) (x)
+	#define le32toh(x) (x)
+	#define le64toh(x) (x)
 #endif
 
 /* syslog.h stubs */
@@ -110,9 +116,9 @@ int nvme_fstat(nvme_fd_t fd, struct stat *buf);
 /* Windows ioctl stub functions */
 static inline int ioctl(nvme_fd_t fd, unsigned long request, ...)
 {
-    (void)fd; (void)request;
-    errno = ENOSYS;
-    return -1;
+	(void)fd; (void)request;
+	errno = ENOSYS;
+	return -1;
 }
 
 /* Windows file descriptors */
@@ -159,29 +165,29 @@ typedef unsigned int mode_t;
 
 /* Windows missing socket structures */
 struct msghdr {
-    void *msg_name;
-    socklen_t msg_namelen;
-    struct iovec *msg_iov;
-    size_t msg_iovlen;
-    void *msg_control;
-    size_t msg_controllen;
-    int msg_flags;
+	void *msg_name;
+	socklen_t msg_namelen;
+	struct iovec *msg_iov;
+	size_t msg_iovlen;
+	void *msg_control;
+	size_t msg_controllen;
+	int msg_flags;
 };
 
 struct iovec {
-    void *iov_base;
-    size_t iov_len;
+	void *iov_base;
+	size_t iov_len;
 };
 
 /* Windows missing network structures - ifaddrs.h stubs */
 struct ifaddrs {
-    struct ifaddrs *ifa_next;
-    char *ifa_name;
-    unsigned int ifa_flags;
-    struct sockaddr *ifa_addr;
-    struct sockaddr *ifa_netmask;
-    struct sockaddr *ifa_broadaddr;
-    void *ifa_data;
+	struct ifaddrs *ifa_next;
+	char *ifa_name;
+	unsigned int ifa_flags;
+	struct sockaddr *ifa_addr;
+	struct sockaddr *ifa_netmask;
+	struct sockaddr *ifa_broadaddr;
+	void *ifa_data;
 };
 static inline void freeifaddrs(struct ifaddrs *ifa) { (void)ifa; }
 
@@ -191,37 +197,38 @@ static inline void freeifaddrs(struct ifaddrs *ifa) { (void)ifa; }
 /* Windows missing POSIX functions */
 static inline int dprintf(int fd, const char *format, ...)
 {
-    va_list args;
-    char buffer[4096];
-    int result;
-    va_start(args, format);
-    result = vsnprintf(buffer, sizeof(buffer), format, args);
-    va_end(args);
-    if (fd == STDERR_FILENO) {
-        fputs(buffer, stderr);
-    } else if (fd == STDOUT_FILENO) {
-        fputs(buffer, stdout);
-    }
-    return result;
+	va_list args;
+	char buffer[4096];
+	int result;
+
+	va_start(args, format);
+	result = vsnprintf(buffer, sizeof(buffer), format, args);
+	va_end(args);
+	if (fd == STDERR_FILENO)
+		fputs(buffer, stderr);
+	else if (fd == STDOUT_FILENO)
+		fputs(buffer, stdout);
+	return result;
 }
 
 static inline DWORD getpagesize(void)
 {
-    SYSTEM_INFO si;
-    GetSystemInfo(&si);
-    return si.dwPageSize;
+	SYSTEM_INFO si;
+
+	GetSystemInfo(&si);
+	return si.dwPageSize;
 }
 
 /* Aligned memory allocation function, use platform_aligned_free to free. */
 static inline int posix_memalign(void **memptr, size_t alignment, size_t size)
 {
-    *memptr = _aligned_malloc(size, alignment);
-    return (*memptr == NULL) ? ENOMEM : 0;
+	*memptr = _aligned_malloc(size, alignment);
+	return (*memptr == NULL) ? ENOMEM : 0;
 }
 
 static inline size_t malloc_usable_size(void *ptr)
 {
-    return _msize(ptr);
+	return _msize(ptr);
 }
 
 /*
@@ -240,10 +247,10 @@ static inline void platform_aligned_free(void *p)
 #define _IOC_READ  2U
 
 #define _IOC(dir,type,nr,size) \
-    (((dir)  << 30) | \
-     ((type) << 8) | \
-     ((nr)   << 0) | \
-     ((size) << 16))
+	(((dir)  << 30) | \
+	 ((type) << 8) | \
+	 ((nr)   << 0) | \
+	 ((size) << 16))
 
 /* Only define if winsock2.h hasn't already defined them */
 #ifndef _IO
@@ -583,4 +590,4 @@ static inline ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t coun
 	return -1;
 }
 
-#endif /* _LIBNVME_PLATFORM_WINDOWS_H */
\ No newline at end of file
+#endif /* _LIBNVME_PLATFORM_WINDOWS_H */

From 34744b957b7c0681f5a4c5777ddf30919e324ece Mon Sep 17 00:00:00 2001
From: Brandon Busacker <bbusacker@micron.com>
Date: Wed, 25 Mar 2026 16:36:52 -0700
Subject: [PATCH 44/83] windows: enable json-c and fix OCP internal-log
 telemetry handling (#76)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary
Final update for the Windows json-c + OCP telemetry enablement branch.

This PR is now aligned on top of `mingw` and includes both the
Windows-specific telemetry/runtime fixes and the doc regeneration that
came with the branch sync.

## Scope Snapshot
- Diff vs `mingw`: **276 files changed**, **438 insertions**, **304
deletions**.
- Documentation refresh: **259 files** under `Documentation/*.html`.
- Non-doc code changes: **17 files** across `libnvme`, `plugins`, and
core CLI.

## Key Functional Changes
### Windows/json-c build and plugin wiring
- Enable json-c resolution in Windows build path.
- Ensure plugin gating/build behavior is compatible with Windows +
json-c.

### OCP telemetry path hardening
- Fix `ocp internal-log` flow and related OCP JSON/log handling paths.
- Ensure binary telemetry outputs are written in binary mode
(`O_BINARY`) to avoid CRLF corruption on Windows.
- Keep telemetry artifacts parsable/consistent
(`telemetry-log-telemetry.bin`, `telemetry-log-string.bin`,
`telemetry-log.json`).

### Platform and output safety improvements
- Add `nvme_init()` startup hook for platform init.
- Set stdout/stderr to binary mode on Windows at startup.
- Use binary-safe output path (`fwrite`) for raw output.
- Normalize socket/platform header usage in JSON print path.

### Windows libnvme compatibility/link fixes
- Update platform abstraction headers and Windows platform helpers.
- Add/adjust missing Windows stubs in `windows-stubs.c` for APIs
referenced by CLI/topology code (including accessor-related and
Linux-only helper entry points needed for linking).
- Keep accessor type include portable via platform types.

### Vendor plugin updates
- OCP plugin fixes in multiple files for build/runtime compatibility.
- Micron telemetry update to support Data Area 4 parsing path.

## Validation
- Reconfigured static build with:
  - `-Djson-c=enabled`
  - `-Ddefault_library=static`
  - `-Dwrap_mode=forcefallback`
- Full build on current `mingw-json` head succeeds (`meson compile -C
.build`, exit code 0).
- `nvme.exe` and test binaries link successfully on this branch.

## Notes
- This PR now contains substantial generated documentation updates from
branch sync/release doc regeneration in addition to the Windows
telemetry work.

---------

Signed-off-by: Tokunori Ikegami <ikegami.t@gmail.com>
Signed-off-by: Daniel Wagner <wagi@kernel.org>
Signed-off-by: Martin Belanger <martin.belanger@dell.com>
Signed-off-by: dependabot[bot] <support@github.com>
Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Michal Rábek <mrabek@redhat.com>
Signed-off-by: jeff-lien-sndk <jeff.lien@sandisk.com>
Signed-off-by: Martin George <marting@netapp.com>
Signed-off-by: Shaneal Findley <shaneal.findley@solidigm.com>
Signed-off-by: Zhen Wang <awz@amazon.com>
Co-authored-by: Tokunori Ikegami <ikegami.t@gmail.com>
Co-authored-by: Daniel Wagner <wagi@kernel.org>
Co-authored-by: Martin Belanger <martin.belanger@dell.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Michal Rábek <mrabek@redhat.com>
Co-authored-by: jeff-lien-sndk <jeff.lien@sandisk.com>
Co-authored-by: Martin George <marting@netapp.com>
Co-authored-by: sfindley102892 <shaneal.findley@solidigm.com>
Co-authored-by: Broc Going <bgoing@micron.com>
Co-authored-by: Zhen Wang <awz@amazon.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Brandon Capener <bcapener@micron.com>
---
 libnvme/src/nvme/lib-windows.c               | 14 +++++++-
 libnvme/src/nvme/tree.c                      |  2 ++
 libnvme/src/nvme/windows-stubs.c             | 11 ++++++
 libnvme/src/platform/linux.h                 |  8 +++++
 libnvme/src/platform/windows.h               | 12 +++++++
 meson.build                                  |  2 +-
 nvme-print-json.c                            |  7 ++--
 nvme.c                                       |  1 +
 plugins/meson.build                          |  2 +-
 plugins/micron/micron-nvme.c                 | 10 +++---
 plugins/ocp/ocp-fw-activation-history.c      |  3 +-
 plugins/ocp/ocp-hardware-component-log.c     |  3 +-
 plugins/ocp/ocp-nvme.c                       | 36 +++++++++++++-------
 plugins/ocp/ocp-smart-extended-log.c         |  3 +-
 plugins/solidigm/solidigm-internal-logs.c    | 10 +++---
 plugins/solidigm/solidigm-smart.c            |  4 +--
 plugins/solidigm/solidigm-workload-tracker.c | 14 ++++----
 17 files changed, 103 insertions(+), 39 deletions(-)

diff --git a/libnvme/src/nvme/lib-windows.c b/libnvme/src/nvme/lib-windows.c
index fd9c60716f..080b8ecd7b 100644
--- a/libnvme/src/nvme/lib-windows.c
+++ b/libnvme/src/nvme/lib-windows.c
@@ -138,6 +138,7 @@ __public int nvme_fstat(nvme_fd_t fd, struct stat *buf)
 {
 	BY_HANDLE_FILE_INFORMATION file_info;
 	ULARGE_INTEGER ull;
+	DWORD file_type;
 
 	if (!buf) {
 		errno = EINVAL;
@@ -150,8 +151,19 @@ __public int nvme_fstat(nvme_fd_t fd, struct stat *buf)
 		return -1;
 	}
 
-	/* Get file information from Windows handle */
+	/*
+	 * GetFileInformationByHandle() does not work for all device HANDLEs
+	 * (e.g. raw \\\\.\\PhysicalDriveN). For those, fall back to file type.
+	 */
 	if (!GetFileInformationByHandle(fd, &file_info)) {
+		file_type = GetFileType(fd);
+		if (file_type == FILE_TYPE_DISK || file_type == FILE_TYPE_CHAR) {
+			memset(buf, 0, sizeof(*buf));
+			buf->st_mode = S_IFBLK | 0600;
+			buf->st_nlink = 1;
+			return 0;
+		}
+
 		errno = EBADF;
 		return -1;
 	}
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index 960cece1e0..cf8dd56a41 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -385,6 +385,7 @@ __public struct nvme_global_ctx *nvme_host_get_global_ctx(nvme_host_t h)
 {
 	return h->ctx;
 }
+#endif /* _WIN32 */
 
 __public void nvme_host_set_pdc_enabled(nvme_host_t h, bool enabled)
 {
@@ -399,6 +400,7 @@ __public bool nvme_host_is_pdc_enabled(nvme_host_t h, bool fallback)
 	return fallback;
 }
 
+#ifndef _WIN32
 __public nvme_subsystem_t nvme_first_subsystem(nvme_host_t h)
 {
 	return list_top(&h->subsystems, struct nvme_subsystem, entry);
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 4804e61c12..ddfa049e5c 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -50,6 +50,17 @@ __public int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name, nvme_
 	return -1;
 }
 
+__public int nvme_scan_namespace(struct nvme_global_ctx *ctx,
+		const char *name, nvme_ns_t *ns)
+{
+	stub_log(__func__);
+	(void)ctx;
+	(void)name;
+	if (ns)
+		*ns = NULL;
+	return -ENOTSUP;
+}
+
 __public int nvme_scan_topology(struct nvme_global_ctx *ctx, nvme_scan_filter_t f, void *f_args)
 {
 	stub_log(__func__);
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index 2962cddc79..7e8983096e 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -41,12 +41,20 @@ typedef int nvme_fd_t;
 #define TEST_FD 0xFD
 #define INIT_FD -1
 
+/* O_BINARY is required on Windows, but not defined on Linux. */
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
 /* Platform-specific fstat wrapper for nvme_fd_t */
 static inline int nvme_fstat(nvme_fd_t fd, struct stat *buf)
 {
 	return fstat(fd, buf);
 }
 
+/* Platform initialization - no-op on Linux */
+static inline void nvme_init(void) {}
+
 /* Platform-specific UUID generation using /dev/urandom */
 static inline int random_uuid(unsigned char *uuid, size_t len)
 {
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 3a8c65d8b1..fcff456e92 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -25,6 +25,7 @@
 #include <io.h>
 #include <direct.h>
 #include <process.h>
+#include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <time.h>
@@ -578,6 +579,17 @@ static inline char *dlerror(void) {
 	return buf;
 }
 
+/*
+ * Set stdout and stderr to binary mode to prevent Windows text-mode
+ * translation from converting LF to CRLF and corrupting raw binary output.
+ * Called once at startup from main().
+ */
+static inline void nvme_init(void)
+{
+	_setmode(_fileno(stdout), O_BINARY);
+	_setmode(_fileno(stderr), O_BINARY);
+}
+
 /* Socket compatibility */
 #ifndef MSG_NOSIGNAL
 #define MSG_NOSIGNAL 0
diff --git a/meson.build b/meson.build
index d03a01ac28..788c38ecaa 100644
--- a/meson.build
+++ b/meson.build
@@ -138,7 +138,7 @@ if is_windows
 endif
 
 # Check for libjson-c availability
-if is_windows or get_option('json-c').disabled()
+if get_option('json-c').disabled()
     json_c_dep = dependency('', required: false)
 else
     json_c_dep = dependency(
diff --git a/nvme-print-json.c b/nvme-print-json.c
index 15ca6f4dd0..1798a9ec76 100644
--- a/nvme-print-json.c
+++ b/nvme-print-json.c
@@ -4,12 +4,11 @@
 #include <errno.h>
 #include <time.h>
 #include <sys/types.h>
-#include <sys/socket.h>
-#include <arpa/inet.h>
+
 #include <ccan/compiler/compiler.h>
 
 #include <libnvme.h>
-
+#include "platform/includes.h"
 #include "nvme-print.h"
 
 #include "util/json.h"
@@ -1867,7 +1866,7 @@ void nvme_json_pel_vendor_specific_event(void *pevent_log_info, __u32 offset,
 {
 	__u32 progress = 0;
 	__u16 vsedl;
-	uint i;
+	__u32 i;
 	struct nvme_vs_event_desc *vs_desc;
 	struct json_object *vs_events = json_create_array();
 
diff --git a/nvme.c b/nvme.c
index 20a0732124..5fe4b89d1f 100644
--- a/nvme.c
+++ b/nvme.c
@@ -11291,6 +11291,7 @@ int main(int argc, char **argv)
 {
 	int err;
 
+	nvme_init();
 	nvme.extensions->parent = &nvme;
 	if (argc < 2) {
 		general_help(&builtin, NULL);
diff --git a/plugins/meson.build b/plugins/meson.build
index 6508c5b17a..627f9e5c6b 100644
--- a/plugins/meson.build
+++ b/plugins/meson.build
@@ -59,7 +59,7 @@ if 'lm' in selected_plugins and not is_windows
   subdir('lm')
 endif
 
-if 'ocp' in selected_plugins
+if 'ocp' in selected_plugins and json_c_dep.found()
   subdir('ocp')
 endif
 
diff --git a/plugins/micron/micron-nvme.c b/plugins/micron/micron-nvme.c
index 2baaad56be..c2f069a379 100644
--- a/plugins/micron/micron-nvme.c
+++ b/plugins/micron/micron-nvme.c
@@ -2315,7 +2315,7 @@ static int micron_telemetry_log(struct nvme_transport_handle *hdl, __u8 type, __
 				int *logSize, int da)
 {
 	int err, bs = 512, offset = bs;
-	unsigned short data_area[4];
+	unsigned short data_area[5] = { 0 };
 	unsigned char  ctrl_init = (type == 0x8);
 
 	__u8 *buffer = (unsigned char *)calloc(bs, 1);
@@ -2336,8 +2336,10 @@ static int micron_telemetry_log(struct nvme_transport_handle *hdl, __u8 type, __
 	data_area[1] = buffer[9]  << 8 | buffer[8];
 	data_area[2] = buffer[11] << 8 | buffer[10];
 	data_area[3] = buffer[13] << 8 | buffer[12];
+	data_area[4] = buffer[15] << 8 | buffer[14];
 	data_area[0] = data_area[1] > data_area[2] ? data_area[1] : data_area[2];
 	data_area[0] = data_area[3] > data_area[0] ? data_area[3] : data_area[0];
+	data_area[0] = data_area[4] > data_area[0] ? data_area[4] : data_area[0];
 
 	if (!data_area[da]) {
 		fprintf(stderr, "Requested telemetry data for 0x%X is empty\n", type);
@@ -3649,7 +3651,7 @@ static int micron_internal_logs(int argc, char **argv, struct command *acmd,
 	const char *desc = "This retrieves the micron debug log package";
 	const char *package = "Log output data file name (required)";
 	const char *type = "telemetry log type - host or controller";
-	const char *data_area = "telemetry log data area 1, 2 or 3";
+	const char *data_area = "telemetry log data area 1, 2, 3, or 4";
 	unsigned char *dataBuffer = NULL;
 	int bSize = 0;
 	int maxSize = 0;
@@ -3687,8 +3689,8 @@ static int micron_internal_logs(int argc, char **argv, struct command *acmd,
 			goto out;
 		}
 
-		if (cfg.data_area <= 0 || cfg.data_area > 3) {
-			printf("data area must be selected using -d option ie --d=1,2,3\n");
+		if (cfg.data_area <= 0 || cfg.data_area > 4) {
+			printf("data area must be selected using -d option ie --d=1,2,3,4\n");
 			goto out;
 		}
 		telemetry_option = 1;
diff --git a/plugins/ocp/ocp-fw-activation-history.c b/plugins/ocp/ocp-fw-activation-history.c
index aed8f3c8c8..e72ff77176 100644
--- a/plugins/ocp/ocp-fw-activation-history.c
+++ b/plugins/ocp/ocp-fw-activation-history.c
@@ -70,7 +70,8 @@ int ocp_fw_activation_history_log(int argc, char **argv, struct command *acmd,
 		err = validate_output_format(nvme_args.output_format,
 			&print_flag);
 		if (err < 0) {
-			fprintf(stderr, "Error: Invalid output format.\n");
+			fprintf(stderr, "ERROR : OCP : invalid output-format. "
+				"Valid values: normal|json|binary|tabular.\n");
 			return err;
 		}
 
diff --git a/plugins/ocp/ocp-hardware-component-log.c b/plugins/ocp/ocp-hardware-component-log.c
index 861ba8940d..8d369bdca6 100644
--- a/plugins/ocp/ocp-hardware-component-log.c
+++ b/plugins/ocp/ocp-hardware-component-log.c
@@ -250,7 +250,8 @@ static int get_hwcomp_log(struct nvme_transport_handle *hdl, __u32 id, bool list
 
 	ret = validate_output_format(nvme_args.output_format, &fmt);
 	if (ret < 0) {
-		fprintf(stderr, "error: ocp: invalid output format\n");
+		fprintf(stderr, "ERROR : OCP : invalid output-format. "
+			"Valid values: normal|json|binary|tabular.\n");
 		return ret;
 	}
 
diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index af56ccbcf2..e04d23b351 100644
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -208,7 +208,8 @@ static int get_c3_log_page(struct nvme_transport_handle *hdl, char *format)
 
 	ret = validate_output_format(format, &fmt);
 	if (ret < 0) {
-		fprintf(stderr, "ERROR : OCP : invalid output format\n");
+		fprintf(stderr, "ERROR : OCP : invalid output-format. "
+			"Valid values: normal|json|binary|tabular.\n");
 		return ret;
 	}
 
@@ -1192,7 +1193,7 @@ static int get_telemetry_log_page_data(struct nvme_transport_handle *hdl,
 	}
 	memset(hdr, 0, bs);
 
-	fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+	fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
 	if (fd < 0) {
 		fprintf(stderr, "Failed to open output file %s: %s!\n",
 				output_file, nvme_strerror(errno));
@@ -1338,7 +1339,7 @@ static int get_c9_log_page_data(struct nvme_transport_handle *hdl,
 	}
 
 	if (save_bin) {
-		fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+		fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
 		if (fd < 0) {
 			fprintf(stderr, "Failed to open output file %s: %s!\n", output_file,
 				nvme_strerror(errno));
@@ -1406,7 +1407,8 @@ int parse_ocp_telemetry_log(struct ocp_telemetry_parse_options *options)
 
 	status = validate_output_format(options->output_format, &fmt);
 	if (status < 0) {
-		nvme_show_error("Invalid output format\n");
+		nvme_show_error("ERROR : OCP : invalid output-format. "
+			"Valid values: normal|json|binary|tabular.");
 		return status;
 	}
 
@@ -1439,7 +1441,7 @@ static int ocp_telemetry_log(int argc, char **argv, struct command *acmd, struct
 	char sn[21] = {0,};
 	struct nvme_id_ctrl ctrl;
 	bool is_support_telemetry_controller;
-	struct ocp_telemetry_parse_options opt;
+	struct ocp_telemetry_parse_options opt = {0};
 	int tele_type = 0;
 	int tele_area = 0;
 	char file_path_telemetry[PATH_MAX], file_path_string[PATH_MAX];
@@ -1566,8 +1568,12 @@ static int ocp_telemetry_log(int argc, char **argv, struct command *acmd, struct
 		opt.string_log = file_path_string;
 	}
 
+	if (argconfig_parse_seen(opts, "output-format"))
+		opt.output_format = nvme_args.output_format;
+
 	if (!opt.output_format) {
-		nvme_show_result("Missing format. Using default format - JSON.\n");
+		nvme_show_result("Missing output-format. Using default - json "
+				 "(valid: normal|json|binary|tabular).\n");
 		opt.output_format = DEFAULT_OUTPUT_FORMAT_JSON;
 	}
 
@@ -1636,7 +1642,8 @@ static int get_c5_log_page(struct nvme_transport_handle *hdl, char *format)
 
 	ret = validate_output_format(format, &fmt);
 	if (ret < 0) {
-		fprintf(stderr, "ERROR : OCP : invalid output format\n");
+		fprintf(stderr, "ERROR : OCP : invalid output-format. "
+			"Valid values: normal|json|binary|tabular.\n");
 		return ret;
 	}
 
@@ -1737,7 +1744,8 @@ static int get_c1_log_page(struct nvme_transport_handle *hdl, char *format)
 
 	ret = validate_output_format(format, &fmt);
 	if (ret < 0) {
-		fprintf(stderr, "ERROR : OCP : invalid output format\n");
+		fprintf(stderr, "ERROR : OCP : invalid output-format. "
+			"Valid values: normal|json|binary|tabular.\n");
 		return ret;
 	}
 
@@ -1837,7 +1845,8 @@ static int get_c4_log_page(struct nvme_transport_handle *hdl, char *format)
 
 	ret = validate_output_format(format, &fmt);
 	if (ret < 0) {
-		fprintf(stderr, "ERROR : OCP : invalid output format\n");
+		fprintf(stderr, "ERROR : OCP : invalid output-format. "
+			"Valid values: normal|json|binary|tabular.\n");
 		return ret;
 	}
 
@@ -2430,7 +2439,8 @@ static int get_c9_log_page(struct nvme_transport_handle *hdl,
 
 	ret = validate_output_format(format, &fmt);
 	if (ret < 0) {
-		fprintf(stderr, "ERROR : OCP : invalid output format\n");
+		fprintf(stderr, "ERROR : OCP : invalid output-format. "
+			"Valid values: normal|json|binary|tabular.\n");
 		return ret;
 	}
 
@@ -2518,7 +2528,8 @@ static int get_c7_log_page(struct nvme_transport_handle *hdl, char *format)
 
 	ret = validate_output_format(format, &fmt);
 	if (ret < 0) {
-		fprintf(stderr, "ERROR : OCP : invalid output format\n");
+		fprintf(stderr, "ERROR : OCP : invalid output-format. "
+			"Valid values: normal|json|binary|tabular.\n");
 		return ret;
 	}
 
@@ -2968,7 +2979,8 @@ static int ocp_get_persistent_event_log(int argc, char **argv,
 
 	err = validate_output_format(nvme_args.output_format, &flags);
 	if (err < 0) {
-		nvme_show_error("Invalid output format");
+		nvme_show_error("ERROR : OCP : invalid output-format. "
+			"Valid values: normal|json|binary|tabular.");
 		return err;
 	}
 
diff --git a/plugins/ocp/ocp-smart-extended-log.c b/plugins/ocp/ocp-smart-extended-log.c
index 0c9c28cac3..7107d7252e 100644
--- a/plugins/ocp/ocp-smart-extended-log.c
+++ b/plugins/ocp/ocp-smart-extended-log.c
@@ -38,7 +38,8 @@ static int get_c0_log_page(struct nvme_transport_handle *hdl, char *format,
 
 	ret = validate_output_format(format, &fmt);
 	if (ret < 0) {
-		fprintf(stderr, "ERROR : OCP : invalid output format\n");
+		fprintf(stderr, "ERROR : OCP : invalid output-format. "
+			"Valid values: normal|json|binary|tabular.\n");
 		return ret;
 	}
 
diff --git a/plugins/solidigm/solidigm-internal-logs.c b/plugins/solidigm/solidigm-internal-logs.c
index 6ed5e86ef1..0f8abd2ce2 100644
--- a/plugins/solidigm/solidigm-internal-logs.c
+++ b/plugins/solidigm/solidigm-internal-logs.c
@@ -242,7 +242,7 @@ static int ilog_dump_assert_logs(struct nvme_transport_handle *hdl, struct ilog
 	struct nvme_passthru_cmd cmd = {
 		.opcode = 0xd2,
 		.nsid = NVME_NSID_ALL,
-		.addr = (unsigned long)(void *)head_buf,
+		.addr = (__u64)(uintptr_t)head_buf,
 		.cdw12 = ASSERTLOG,
 		.cdw13 = 0,
 	};
@@ -265,7 +265,7 @@ static int ilog_dump_assert_logs(struct nvme_transport_handle *hdl, struct ilog
 		close(output);
 		return err;
 	}
-	cmd.addr = (unsigned long)(void *)buf;
+	cmd.addr = (__u64)(uintptr_t)buf;
 
 	if (ilog->cfg->verbose) {
 		printf("Assert Log, cores: %d log size: %d header size: %d\n", ad->header.numcores,
@@ -299,7 +299,7 @@ static int ilog_dump_event_logs(struct nvme_transport_handle *hdl, struct ilog *
 	struct nvme_passthru_cmd cmd = {
 		.opcode = 0xd2,
 		.nsid = NVME_NSID_ALL,
-		.addr = (unsigned long)(void *)head_buf,
+		.addr = (__u64)(uintptr_t)head_buf,
 		.cdw12 = EVENTLOG,
 		.cdw13 = 0,
 	};
@@ -322,7 +322,7 @@ static int ilog_dump_event_logs(struct nvme_transport_handle *hdl, struct ilog *
 		close(output);
 		return err;
 	}
-	cmd.addr = (unsigned long)(void *)buf;
+	cmd.addr = (__u64)(uintptr_t)buf;
 
 	if (ilog->cfg->verbose)
 		printf("Event Log, cores: %d log size: %d\n", core_num, ehdr->header.log_size * 4);
@@ -374,7 +374,7 @@ static int ilog_dump_nlogs(struct nvme_transport_handle *hdl, struct ilog *ilog,
 	struct nvme_passthru_cmd cmd = {
 		.opcode = 0xd2,
 		.nsid = NVME_NSID_ALL,
-		.addr = (unsigned long)(void *)buf
+		.addr = (__u64)(uintptr_t)buf
 	};
 
 	struct dump_select {
diff --git a/plugins/solidigm/solidigm-smart.c b/plugins/solidigm/solidigm-smart.c
index 5ad747e4cd..e08431d71e 100644
--- a/plugins/solidigm/solidigm-smart.c
+++ b/plugins/solidigm/solidigm-smart.c
@@ -148,12 +148,12 @@ static void smart_log_item_print(struct nvme_additional_smart_log_item *item)
 			le32_to_cpu(item->thermal_throttle.count));
 		return;
 	case 0xF3:
-		printf("gain0: %u, loss0: %u, gain1: %u, loss1: %u, legacy:%lu\n",
+		printf("gain0: %u, loss0: %u, gain1: %u, loss1: %u, legacy:%llu\n",
 			le16_to_cpu(pll_item->gainCount0),
 			le16_to_cpu(pll_item->lossCount0),
 			le16_to_cpu(pll_item->gainCount1),
 			le16_to_cpu(pll_item->lossCount1),
-			int48_to_long(item->raw));
+			(unsigned long long)int48_to_long(item->raw));
 		return;
 	default:
 		printf("%"PRIu64"\n", int48_to_long(item->raw));
diff --git a/plugins/solidigm/solidigm-workload-tracker.c b/plugins/solidigm/solidigm-workload-tracker.c
index 5c408f6930..ab4920bf5a 100644
--- a/plugins/solidigm/solidigm-workload-tracker.c
+++ b/plugins/solidigm/solidigm-workload-tracker.c
@@ -244,8 +244,10 @@ static void wltracker_print_header(struct wltracker *wlt)
 	printf("%-24s %u.%u\n", "Log page version:", le16_to_cpu(log->majorVersion),
 	       le16_to_cpu(log->minorVersion));
 	printf("%-24s %u\n", "Sample period(ms):", le32_to_cpu(log->samplePeriodInMilliseconds));
-	printf("%-24s %lu\n", "timestamp_lastChange:", le64_to_cpu(log->timestamp_lastEntry));
-	printf("%-24s %lu\n", "timestamp_triggered:", le64_to_cpu(log->timestamp_triggered));
+	printf("%-24s %llu\n", "timestamp_lastChange:",
+	       (unsigned long long)le64_to_cpu(log->timestamp_lastEntry));
+	printf("%-24s %llu\n", "timestamp_triggered:",
+	       (unsigned long long)le64_to_cpu(log->timestamp_triggered));
 	printf("%-24s 0x%x\n", "config:", le32_to_cpu(log->config.dword));
 	printf("%-24s %u\n", "Triggerthreshold:", le32_to_cpu(log->triggerthreshold));
 	printf("%-24s %u\n", "ValueTriggered:", le32_to_cpu(log->triggeredValue));
@@ -253,7 +255,7 @@ static void wltracker_print_header(struct wltracker *wlt)
 	printf("%-24s %u\n", "Total log page entries:", le32_to_cpu(log->workloadLogCount));
 	printf("%-24s %u\n", "Trigger count:", log->triggeredEvents);
 	if (nvme_args.verbose > 1)
-		printf("%-24s %ld\n", "Poll count:", wlt->poll_count);
+		printf("%-24s %zu\n", "Poll count:", wlt->poll_count);
 	if (wlt->poll_count != 0)
 		wltracker_print_field_names(wlt);
 }
@@ -436,7 +438,7 @@ void wltracker_run_time_update(struct wltracker *wlt)
 		printf("run_time: %lluus\n", wlt->run_time_us);
 }
 
-static int stricmp(char const *a, char const *b)
+static int sldgm_stricmp(char const *a, char const *b)
 {
 	if (!a || !b)
 		return 1;
@@ -449,7 +451,7 @@ static int stricmp(char const *a, char const *b)
 static int find_option(char const *list[], int size, const char *val)
 {
 	for (int i = 0; i < size; i++) {
-		if (!stricmp(val, list[i]))
+		if (!sldgm_stricmp(val, list[i]))
 			return i;
 	}
 	return -EINVAL;
@@ -467,7 +469,7 @@ static void join_options(char *dest, char const *list[], size_t list_size)
 static int find_field(struct field *fields, const char *val)
 {
 	for (int i = 0; i < MAX_FIELDS; i++) {
-		if (!stricmp(val, fields[i].name))
+		if (!sldgm_stricmp(val, fields[i].name))
 			return i;
 	}
 	return -EINVAL;

From 2ea6fa734f92171269ac937b8e39e76059e45fe6 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Wed, 1 Apr 2026 13:47:46 -0600
Subject: [PATCH 45/83] Adding nvme_create_raw_secret stub to fix Windows
 build. (#87)

A recent merge added a new method that needs a stub.
---
 libnvme/src/nvme/windows-stubs.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index ddfa049e5c..53e86da643 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -696,6 +696,13 @@ __public int nvme_gen_dhchap_key(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
+__public int nvme_create_raw_secret(struct nvme_global_ctx *ctx,
+		const char *secret, size_t key_len, unsigned char **raw_secret)
+{
+	stub_log(__func__);
+	return -ENOTSUP;
+}
+
 /* Hostnqn generation (fabrics.c) */
 __public char *nvme_generate_hostnqn(void)
 {

From 1f45429c11758727c4922d153588c42d4445dd22 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 3 Apr 2026 11:16:22 -0600
Subject: [PATCH 46/83] Cleanup of platform includes and platform include
 usage. (#88)

In preparation for upstream PR, cleaned up platform includes:
- Organized and alphabetized includes based on similar recent upstream
changes.
- Removed unneeded includes.
- Re-organized platform/windows.h for consistency and readability.
Grouped by compatibility target.
- Removed compatibility definitions and methods that are no longer
needed.
- Cleaned up usages of platform/includes.h for consistency and to match
upstream header reorganization.
---
 common.h                        |   2 +-
 libnvme/src/nvme/cleanup.h      |   2 +-
 libnvme/src/nvme/cmds.c         |   2 -
 libnvme/src/nvme/cmds.h         |   2 +
 libnvme/src/nvme/lib.h          |   2 +-
 libnvme/src/nvme/log.c          |   2 +-
 libnvme/src/nvme/mi-mctp.c      |   2 +-
 libnvme/src/nvme/mi.h           |   2 +-
 libnvme/src/nvme/nbft.c         |   3 +-
 libnvme/src/nvme/tree.c         |   5 +-
 libnvme/src/nvme/types.h        |   2 +-
 libnvme/src/nvme/util.c         |   5 +-
 libnvme/src/platform/includes.h |   5 +-
 libnvme/src/platform/linux.h    |  36 ++-
 libnvme/src/platform/types.h    |  10 +-
 libnvme/src/platform/windows.h  | 411 ++++++++++++--------------------
 nvme-models.c                   |   1 -
 nvme-print-json.c               |   2 +-
 nvme-print-stdout.c             |   5 +-
 nvme.h                          |   3 +-
 util/mem.c                      |   2 +-
 util/sighdl.c                   |   3 +-
 util/table.c                    |   4 +-
 23 files changed, 203 insertions(+), 310 deletions(-)

diff --git a/common.h b/common.h
index d24893e9a5..e798ffc7d6 100644
--- a/common.h
+++ b/common.h
@@ -9,7 +9,7 @@
 
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
 
-/* On Windows, min/max may be provided by libnvme but ensure they exist */
+/* On Windows, min/max may already be defined */
 #ifndef min
 #define min(x, y) ((x) > (y) ? (y) : (x))
 #endif
diff --git a/libnvme/src/nvme/cleanup.h b/libnvme/src/nvme/cleanup.h
index bacbc61499..096cfbf5b5 100644
--- a/libnvme/src/nvme/cleanup.h
+++ b/libnvme/src/nvme/cleanup.h
@@ -6,7 +6,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "platform/includes.h"
+#include <platform/includes.h>
 
 #include "fabrics.h"
 #include "private.h"
diff --git a/libnvme/src/nvme/cmds.c b/libnvme/src/nvme/cmds.c
index 921b36f39b..d5de75ca5d 100644
--- a/libnvme/src/nvme/cmds.c
+++ b/libnvme/src/nvme/cmds.c
@@ -12,8 +12,6 @@
 
 #include <libnvme.h>
 
-#include "platform/includes.h"
-
 #include "cleanup.h"
 #include "private.h"
 #include "compiler_attributes.h"
diff --git a/libnvme/src/nvme/cmds.h b/libnvme/src/nvme/cmds.h
index b8f0c5fa79..66969368e3 100644
--- a/libnvme/src/nvme/cmds.h
+++ b/libnvme/src/nvme/cmds.h
@@ -13,6 +13,8 @@
 #include <errno.h>
 #include <string.h>
 
+#include <platform/includes.h>
+
 #include <nvme/ioctl.h>
 #include <nvme/types.h>
 
diff --git a/libnvme/src/nvme/lib.h b/libnvme/src/nvme/lib.h
index 3106a5c627..102f66c4b4 100644
--- a/libnvme/src/nvme/lib.h
+++ b/libnvme/src/nvme/lib.h
@@ -11,7 +11,7 @@
 #include <stdbool.h>
 #include <stdio.h>
 
-#include "platform/includes.h"
+#include <platform/includes.h>
 
 #include <nvme/lib-types.h>
 
diff --git a/libnvme/src/nvme/log.c b/libnvme/src/nvme/log.c
index aafe3894b4..18cfc02531 100644
--- a/libnvme/src/nvme/log.c
+++ b/libnvme/src/nvme/log.c
@@ -12,7 +12,7 @@
 #include <stdbool.h>
 #include <time.h>
 
-#include "platform/includes.h"
+#include <platform/includes.h>
 
 #include <libnvme.h>
 
diff --git a/libnvme/src/nvme/mi-mctp.c b/libnvme/src/nvme/mi-mctp.c
index 56ab2910f8..b90c392bc8 100644
--- a/libnvme/src/nvme/mi-mctp.c
+++ b/libnvme/src/nvme/mi-mctp.c
@@ -13,7 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "platform/includes.h"
+#include <platform/includes.h>
 
 #if HAVE_LINUX_MCTP_H
 #include <linux/mctp.h>
diff --git a/libnvme/src/nvme/mi.h b/libnvme/src/nvme/mi.h
index 668b6fc398..d131476654 100644
--- a/libnvme/src/nvme/mi.h
+++ b/libnvme/src/nvme/mi.h
@@ -84,7 +84,7 @@
 
 #include <stdint.h>
 
-#include "platform/includes.h"
+#include <platform/includes.h>
 
 #include <nvme/tree.h>
 
diff --git a/libnvme/src/nvme/nbft.c b/libnvme/src/nvme/nbft.c
index b3fd851cf5..3a30258ac4 100644
--- a/libnvme/src/nvme/nbft.c
+++ b/libnvme/src/nvme/nbft.c
@@ -10,8 +10,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <platform/includes.h>
+
 #include <ccan/endian/endian.h>
-#include "platform/includes.h"
 
 #include <libnvme.h>
 
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index df002b2550..9596dcc0dd 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -15,7 +15,10 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "platform/includes.h"
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <platform/includes.h>
 
 #include <ccan/endian/endian.h>
 #include <ccan/list/list.h>
diff --git a/libnvme/src/nvme/types.h b/libnvme/src/nvme/types.h
index 2dab7a5aa2..9f78b88ad6 100644
--- a/libnvme/src/nvme/types.h
+++ b/libnvme/src/nvme/types.h
@@ -12,7 +12,7 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include "platform/includes.h"
+#include <platform/types.h>
 
 /**
  * DOC: types.h
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 160bb611f2..9ad03a1c36 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -16,7 +16,10 @@
 #include <string.h>
 #include <unistd.h>
 
-#include "platform/includes.h"
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <platform/includes.h>
 
 #include <ccan/endian/endian.h>
 #include <ccan/minmax/minmax.h>
diff --git a/libnvme/src/platform/includes.h b/libnvme/src/platform/includes.h
index 841314cb9c..8c14fb905b 100644
--- a/libnvme/src/platform/includes.h
+++ b/libnvme/src/platform/includes.h
@@ -6,8 +6,7 @@
  * Common platform-specific includes and definitions.
  */
 
-#ifndef _LIBNVME_PLATFORM_INCLUDES_H
-#define _LIBNVME_PLATFORM_INCLUDES_H
+#pragma once
 
 #include "platform/types.h"
 
@@ -17,5 +16,3 @@
 #else
     #include "platform/linux.h"
 #endif
-
-#endif /* _LIBNVME_PLATFORM_INCLUDES_H */
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index 7e8983096e..48c406f828 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -1,38 +1,34 @@
 // SPDX-License-Identifier: LGPL-2.1-or-later
 /*
  * This file is part of libnvme.
- * Copyright (c) 2025 Micron Technology, Inc.
+ * Copyright (c) 2026 Micron Technology, Inc.
  *
  * Linux platform-specific definitions and includes.
  */
 
-#ifndef _LIBNVME_PLATFORM_LINUX_H
-#define _LIBNVME_PLATFORM_LINUX_H
+#pragma once
 
-/* Linux includes */
+/* Linux-specific includes */
+#include <dirent.h>
+#include <endian.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/stat.h>
+
+#include <syslog.h>
 #include <sys/ioctl.h>
-#include <sys/socket.h>
 #include <sys/mman.h>
 #include <sys/param.h>
-#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
 #include <sys/uio.h>
-#include <netinet/in.h>
+
 #include <arpa/inet.h>
-#include <netdb.h>
 #include <ifaddrs.h>
-#include <poll.h>
-#include <syslog.h>
-#include <dirent.h>
-#include <endian.h>
-
-/* Linux cleanup attribute */
-#define __nvme_cleanup(fn) __attribute__((__cleanup__(fn)))
+#include <netdb.h>
+#include <netinet/in.h>
 
 /* Extract IPv4 from IPv6 mapped address */
 #define ipv4_from_in6_addr(addr) &(addr.s6_addr32[3])
@@ -83,5 +79,3 @@ static inline void platform_aligned_free(void *p)
 {
 	free(p);
 }
-
-#endif /* _LIBNVME_PLATFORM_LINUX_H */
diff --git a/libnvme/src/platform/types.h b/libnvme/src/platform/types.h
index 3cd9842994..b51427b2e4 100644
--- a/libnvme/src/platform/types.h
+++ b/libnvme/src/platform/types.h
@@ -1,15 +1,17 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
+ * This file is part of libnvme.
+ * Copyright (c) 2026 Micron Technology, Inc.
+ *
  * Platform compatibility for linux/types.h
  */
-#ifndef _PLATFORM_TYPES_H
-#define _PLATFORM_TYPES_H
+#pragma once
 
 #ifdef _WIN32
 
 #include <stdint.h>
 
-/* Windows type definitions to replace linux/types.h */
+/* Standard type definitions for linux/types.h compatibility */
 typedef uint8_t  __u8;
 typedef uint16_t __u16;
 typedef uint32_t __u32;
@@ -40,5 +42,3 @@ typedef __s64    __be64s;
 #include <linux/types.h>
 
 #endif
-
-#endif /* _PLATFORM_TYPES_H */
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index fcff456e92..838ab37551 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -6,8 +6,7 @@
  * Windows platform-specific definitions and includes.
  */
 
-#ifndef _LIBNVME_PLATFORM_WINDOWS_H
-#define _LIBNVME_PLATFORM_WINDOWS_H
+#pragma once
 
 /* Windows-specific includes - winsock2 before windows.h to avoid warnings */
 #define WIN32_LEAN_AND_MEAN
@@ -15,34 +14,39 @@
 #include <ws2tcpip.h>
 #include <windows.h>
 #undef WIN32_LEAN_AND_MEAN
-#include <winioctl.h>
-#include <ntddstor.h>
+
 #include <bcrypt.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <stdarg.h>
+#include <direct.h>
 #include <errno.h>
+#include <fcntl.h>
 #include <io.h>
-#include <direct.h>
 #include <process.h>
-#include <fcntl.h>
+#include <signal.h>
+#include <stdio.h>
 #include <sys/stat.h>
-#include <sys/time.h>
 #include <time.h>
-#include <libgen.h>
 
-/* Prevent conflicts with Windows min/max macros */
-#ifdef min
-#undef min
-#endif
-#ifdef max  
-#undef max
-#endif
 
-/* Windows cleanup - no-op since Windows doesn't have cleanup attribute */
-#define __nvme_cleanup(fn) /* No cleanup attribute on Windows */
+/* Platform compatibility helper types and methods */
+
+typedef HANDLE nvme_fd_t;
+#define TEST_FD INVALID_HANDLE_VALUE
+#define INIT_FD nullptr
+
+/*
+ * Set stdout and stderr to binary mode to prevent Windows text-mode
+ * translation from converting LF to CRLF and corrupting raw binary output.
+ * Called once at startup from main().
+ */
+static inline void nvme_init(void)
+{
+	_setmode(_fileno(stdout), O_BINARY);
+	_setmode(_fileno(stderr), O_BINARY);
+}
+
+
+/* endian.h compatibility */
 
-/* Windows endian conversion macros */
 #if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 	#define htobe16(x) (x)
 	#define htobe32(x) (x)
@@ -66,9 +70,11 @@
 	#define le64toh(x) (x)
 #endif
 
-/* syslog.h stubs */
+
+/* syslog.h compatibility */
+
 #define LOG_EMERG   0
-#define LOG_ALERT   1  
+#define LOG_ALERT   1
 #define LOG_CRIT    2
 #define LOG_ERR     3
 #define LOG_WARNING 4
@@ -79,40 +85,17 @@ static inline void syslog(int priority, const char *format, ...) { (void)priorit
 static inline void openlog(const char *ident, int option, int facility) { (void)ident; (void)option; (void)facility; }
 static inline void closelog(void) { }
 
-/* poll.h stubs - winsock2.h provides struct pollfd */
-#ifndef POLLIN
-#define POLLIN  0x001
-#endif
-#ifndef POLLOUT
-#define POLLOUT 0x004
-#endif
-#ifndef POLLERR
-#define POLLERR 0x008
-#endif
-#ifndef POLLHUP
-#define POLLHUP 0x010
-#endif
-#ifndef POLLNVAL
-#define POLLNVAL 0x020
-#endif
+
+/* poll.h compatibility (winsock2.h provides additional compatibility) */
+
+typedef unsigned long nfds_t;
+
 
 /* sys/ioctl.h stubs */
-#define IOCTL_STORAGE_QUERY_PROPERTY CTL_CODE(IOCTL_STORAGE_BASE, 0x0500, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
 /* Linux ioctl constants - stubs for block device operations */
-#ifndef BLKBSZSET
 #define BLKBSZSET 0x40081271
-#endif
-#ifndef BLKRRPART
 #define BLKRRPART 0x125F
-#endif
-
-typedef HANDLE nvme_fd_t;
-#define TEST_FD INVALID_HANDLE_VALUE
-#define INIT_FD nullptr
-
-/* Platform-specific fstat wrapper for nvme_fd_t */
-int nvme_fstat(nvme_fd_t fd, struct stat *buf);
 
 /* Windows ioctl stub functions */
 static inline int ioctl(nvme_fd_t fd, unsigned long request, ...)
@@ -122,49 +105,24 @@ static inline int ioctl(nvme_fd_t fd, unsigned long request, ...)
 	return -1;
 }
 
-/* Windows file descriptors */
-#ifndef STDERR_FILENO
-#define STDERR_FILENO 2
-#endif
-#ifndef STDOUT_FILENO  
-#define STDOUT_FILENO 1
-#endif
-#ifndef STDIN_FILENO
-#define STDIN_FILENO 0
-#endif
 
-/* Windows sys/param.h compatibility */
-#ifndef MAXPATHLEN
-#define MAXPATHLEN 260  /* Windows MAX_PATH */
-#endif
+/* sys/param.h compatibility */
+
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+
+/* errno.h compatibility */
 
-/* Windows missing error codes */
-#ifndef EREMOTEIO
 #define EREMOTEIO 121
-#endif
-#ifndef EDQUOT
-#define EDQUOT 122
-#endif
-#ifndef ERESTART
-#define ERESTART 85
-#endif
-#ifndef ENOTBLK
-#define ENOTBLK 15
-#endif
-#ifndef ENAVAIL
-#define ENAVAIL 119
-#endif
+#define EDQUOT    122
+#define ERESTART  85
+#define ENOTBLK   15
+#define ENAVAIL   119
 
-/* Windows missing socket types */
-typedef unsigned long nfds_t;
 
-/* Windows missing mode_t */
-#ifndef _MODE_T_
-#define _MODE_T_
-typedef unsigned int mode_t;
-#endif
+/* socket.h compatibility */
 
-/* Windows missing socket structures */
 struct msghdr {
 	void *msg_name;
 	socklen_t msg_namelen;
@@ -180,7 +138,12 @@ struct iovec {
 	size_t iov_len;
 };
 
-/* Windows missing network structures - ifaddrs.h stubs */
+/* Extract IPv4 from IPv6 mapped address (in6_addr) */
+#define ipv4_from_in6_addr(addr) &(addr.u.Byte[12])
+
+
+/* ifaddrs.h compatibility */
+
 struct ifaddrs {
 	struct ifaddrs *ifa_next;
 	char *ifa_name;
@@ -190,93 +153,8 @@ struct ifaddrs {
 	struct sockaddr *ifa_broadaddr;
 	void *ifa_data;
 };
-static inline void freeifaddrs(struct ifaddrs *ifa) { (void)ifa; }
-
-/* Extract IPv4 from IPv6 mapped address */
-#define ipv4_from_in6_addr(addr) &(addr.u.Byte[12])
-
-/* Windows missing POSIX functions */
-static inline int dprintf(int fd, const char *format, ...)
-{
-	va_list args;
-	char buffer[4096];
-	int result;
-
-	va_start(args, format);
-	result = vsnprintf(buffer, sizeof(buffer), format, args);
-	va_end(args);
-	if (fd == STDERR_FILENO)
-		fputs(buffer, stderr);
-	else if (fd == STDOUT_FILENO)
-		fputs(buffer, stdout);
-	return result;
-}
-
-static inline DWORD getpagesize(void)
-{
-	SYSTEM_INFO si;
-
-	GetSystemInfo(&si);
-	return si.dwPageSize;
-}
 
-/* Aligned memory allocation function, use platform_aligned_free to free. */
-static inline int posix_memalign(void **memptr, size_t alignment, size_t size)
-{
-	*memptr = _aligned_malloc(size, alignment);
-	return (*memptr == NULL) ? ENOMEM : 0;
-}
-
-static inline size_t malloc_usable_size(void *ptr)
-{
-	return _msize(ptr);
-}
-
-/*
- * Platform-specific free for aligned memory allocations.
- * Use when posix_memalign is used to allocate memory.
- */
-static inline void platform_aligned_free(void *p)
-{
-	_aligned_free(p);
-}
-
-/* Windows ioctl macros - only define if not already defined by winsock */
-#ifndef _IOC_NONE
-#define _IOC_NONE  0U
-#define _IOC_WRITE 1U
-#define _IOC_READ  2U
-
-#define _IOC(dir,type,nr,size) \
-	(((dir)  << 30) | \
-	 ((type) << 8) | \
-	 ((nr)   << 0) | \
-	 ((size) << 16))
-
-/* Only define if winsock2.h hasn't already defined them */
-#ifndef _IO
-#define _IO(type,nr)        _IOC(_IOC_NONE,(type),(nr),0)
-#endif
-#ifndef _IOR  
-#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),sizeof(size))
-#endif
-#ifndef _IOW
-#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
-#endif
-#ifndef _IOWR
-#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
-#endif
-#endif /* _IOC_NONE */
-
-/* MIN/min macros for Windows */
-#ifndef __cplusplus
-#ifndef MIN
-#define MIN(a,b) ((a) < (b) ? (a) : (b))
-#endif
-#ifndef min
-#define min(a,b) ((a) < (b) ? (a) : (b))
-#endif
-#endif /* __cplusplus */
+static inline void freeifaddrs(struct ifaddrs *ifa) { (void)ifa; }
 
 /* Platform-specific UUID generation using BCryptGenRandom */
 static inline int random_uuid(unsigned char *uuid, size_t len)
@@ -291,16 +169,25 @@ static inline int random_uuid(unsigned char *uuid, size_t len)
 	return 0;
 }
 
-/* ========== POSIX Compatibility Layer ========== */
 
-/* dirent.h emulation for Windows - only if not provided by compiler */
-#if !defined(_DIRENT_H_) && !defined(_DIRENT_H)
-#include <dirent.h>
-#endif
+/* stdio.h POSIX extensions */
 
-/* If dirent.h is not available, we would define our own, but MinGW provides it */
+/* dprintf implementation for Windows */
+static inline int dprintf(int fd, const char *format, ...)
+{
+	va_list args;
+	char buffer[4096];
+	int result;
 
-/* stdio.h POSIX extensions */
+	va_start(args, format);
+	result = vsnprintf(buffer, sizeof(buffer), format, args);
+	va_end(args);
+	if (fd == STDERR_FILENO)
+		fputs(buffer, stderr);
+	else if (fd == STDOUT_FILENO)
+		fputs(buffer, stdout);
+	return result;
+}
 
 /* getline implementation for Windows */
 static inline ssize_t getline(char **lineptr, size_t *n, FILE *stream)
@@ -357,7 +244,7 @@ static inline ssize_t getline(char **lineptr, size_t *n, FILE *stream)
 	return p - bufptr;
 }
 
-/* open_memstream stub - returns a temporary file instead */
+/* open_memstream workaround for Windows - returns a temporary file instead */
 static inline FILE *open_memstream(char **ptr, size_t *sizeloc)
 {
 	FILE *f = tmpfile();
@@ -369,6 +256,7 @@ static inline FILE *open_memstream(char **ptr, size_t *sizeloc)
 	return f;
 }
 
+
 /* string.h POSIX extensions */
 
 /* strsep implementation for Windows */
@@ -391,6 +279,25 @@ static inline char *strsep(char **stringp, const char *delim)
 	return start;
 }
 
+
+/* stdlib.h compatibility */
+
+/* Aligned memory allocation function, use platform_aligned_free to free. */
+static inline int posix_memalign(void **memptr, size_t alignment, size_t size)
+{
+	*memptr = _aligned_malloc(size, alignment);
+	return (*memptr == NULL) ? ENOMEM : 0;
+}
+
+/*
+ * Platform-specific free for aligned memory allocations.
+ * Use when posix_memalign is used to allocate memory.
+ */
+static inline void platform_aligned_free(void *p)
+{
+	_aligned_free(p);
+}
+
 /* reallocarray implementation for Windows */
 static inline void *reallocarray(void *ptr, size_t nmemb, size_t size)
 {
@@ -406,7 +313,29 @@ static inline void *reallocarray(void *ptr, size_t nmemb, size_t size)
 	return realloc(ptr, total_size);
 }
 
-/* unistd.h POSIX functions */
+
+/* malloc.h compatibility*/
+
+static inline size_t malloc_usable_size(void *ptr)
+{
+	return _msize(ptr);
+}
+
+
+/* unistd.h POSIX compatibility */
+
+#define STDERR_FILENO 2
+#define STDOUT_FILENO 1
+#define STDIN_FILENO  0
+
+/* getpagesize implementation for Windows */
+static inline DWORD getpagesize(void)
+{
+	SYSTEM_INFO si;
+
+	GetSystemInfo(&si);
+	return si.dwPageSize;
+}
 
 /*
  * readlink stub - Windows doesn't have symbolic links in the same way
@@ -422,22 +351,24 @@ static inline int readlink(const char *path, char *buf, size_t bufsiz)
 	return -1;
 }
 
-/* unistd.h additions */
-#ifndef fsync
-#define fsync _commit
-#endif
+/* fsync implementation for Windows */
+static inline int fsync(int fd)
+{
+	return _commit(fd);
+}
+
 
 /* time.h POSIX compatibility */
-static inline struct tm *gmtime_r(const time_t *timep, struct tm *result) {
+
+static inline struct tm *gmtime_r(const time_t *timep, struct tm *result)
+{
 	if (gmtime_s(result, timep) == 0)
 		return result;
 	return NULL;
 }
 
+
 /* signal.h POSIX compatibility - Windows doesn't have sigaction */
-#ifndef _SIGACTION_DEFINED
-#define _SIGACTION_DEFINED
-#include <signal.h>
 
 struct sigaction {
 	void (*sa_handler)(int);
@@ -445,14 +376,19 @@ struct sigaction {
 	int sa_mask;  /* simplified - normally sigset_t */
 };
 
-#define SA_RESTART 0x10000000
-
-static inline int sigemptyset(int *set) {
+static inline int sigemptyset(int *set)
+{
 	*set = 0;
 	return 0;
 }
 
-static inline int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact) {
+/*
+ * Simplified signal handling using Windows signal() function
+ * This is sufficient for handling SIGINT with no mask or flags.
+ */
+static inline int sigaction(int signum, const struct sigaction *act,
+			struct sigaction *oldact)
+{
 	(void)oldact; /* ignore old action for simplicity */
 	if (act && act->sa_handler) {
 		signal(signum, act->sa_handler);
@@ -461,9 +397,9 @@ static inline int sigaction(int signum, const struct sigaction *act, struct siga
 	return -1;
 }
 
-#endif /* _SIGACTION_DEFINED */
 
-/* fnmatch.h POSIX compatibility */
+/* fnmatch.h POSIX compatibility - Only used by fabrics - consider removing */
+
 #define FNM_NOMATCH 1
 #define FNM_PATHNAME 0x01
 
@@ -514,92 +450,53 @@ static inline int fnmatch(const char *pattern, const char *string, int flags)
 	return *string ? FNM_NOMATCH : 0;
 }
 
-/* limits.h additions */
+
+/* limits.h compatibility */
+
 #ifndef NAME_MAX
 #define NAME_MAX 260
 #endif
 
+
 /* sys/stat.h compatibility */
+
+/* Window stub - always returning 0 */
 #ifndef S_ISBLK
 #define S_ISBLK(m) (0)
 #endif
 
-/* mkdir compatibility - Windows _mkdir doesn't take mode parameter */
-#ifndef mkdir
+/* Windows _mkdir doesn't take mode parameter */
 #define mkdir(path, mode) _mkdir(path)
-#endif
 
-/* Memory mapping stubs - not fully supported on Windows */
+/* Platform-specific fstat wrapper for nvme_fd_t */
+int nvme_fstat(nvme_fd_t fd, struct stat *buf);
+
+
+/* mman.h memory mapping stubs - not supported on Windows */
+
 #define PROT_READ  0x1
 #define PROT_WRITE 0x2
 #define MAP_SHARED 0x01
-#define MAP_PRIVATE 0x02
-#define MAP_ANONYMOUS 0x20
-#define MAP_HUGETLB 0x40000
 #define MAP_FAILED ((void *) -1)
-#define MADV_HUGEPAGE 14
 
-static inline void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset) {
+static inline void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
+{
 	(void)addr; (void)length; (void)prot; (void)flags; (void)fd; (void)offset;
 	errno = ENOSYS;
 	return MAP_FAILED;
 }
 
-static inline int munmap(void *addr, size_t length) {
+static inline int munmap(void *addr, size_t length)
+{
 	(void)addr; (void)length;
 	errno = ENOSYS;
 	return -1;
 }
 
-static inline int madvise(void *addr, size_t length, int advice) {
-	(void)addr; (void)length; (void)advice;
-	errno = ENOSYS;
-	return -1;
-}
-
-/* DLL loading compatibility */
-#define RTLD_LAZY 0
-static inline void *dlopen(const char *filename, int flag) {
-	(void)flag;
-	return (void *)LoadLibraryA(filename);
-}
-
-static inline void *dlsym(void *handle, const char *symbol) {
-	return (void *)GetProcAddress((HMODULE)handle, symbol);
-}
 
-static inline int dlclose(void *handle) {
-	return FreeLibrary((HMODULE)handle) ? 0 : -1;
-}
+/* dlfcn.h compatibility */
 
-static inline char *dlerror(void) {
-	static char buf[256];
-	DWORD err = GetLastError();
-	snprintf(buf, sizeof(buf), "Error %lu", err);
-	return buf;
-}
-
-/*
- * Set stdout and stderr to binary mode to prevent Windows text-mode
- * translation from converting LF to CRLF and corrupting raw binary output.
- * Called once at startup from main().
- */
-static inline void nvme_init(void)
+static inline void *dlsym(void *handle, const char *symbol)
 {
-	_setmode(_fileno(stdout), O_BINARY);
-	_setmode(_fileno(stderr), O_BINARY);
-}
-
-/* Socket compatibility */
-#ifndef MSG_NOSIGNAL
-#define MSG_NOSIGNAL 0
-#endif
-
-/* sendfile stub */
-static inline ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count) {
-	(void)out_fd; (void)in_fd; (void)offset; (void)count;
-	errno = ENOSYS;
-	return -1;
+	return (void *)GetProcAddress((HMODULE)handle, symbol);
 }
-
-#endif /* _LIBNVME_PLATFORM_WINDOWS_H */
diff --git a/nvme-models.c b/nvme-models.c
index a8b655ee0c..eafbb629f1 100644
--- a/nvme-models.c
+++ b/nvme-models.c
@@ -11,7 +11,6 @@
 #include <sys/types.h>
 #include "nvme-models.h"
 #include "nvme.h"
-#include "platform/includes.h"
 
 static char *_fmt1 = "/sys/class/nvme/nvme%d/device/subsystem_vendor";
 static char *_fmt2 = "/sys/class/nvme/nvme%d/device/subsystem_device";
diff --git a/nvme-print-json.c b/nvme-print-json.c
index 3e2322b918..40ebb7fd9d 100644
--- a/nvme-print-json.c
+++ b/nvme-print-json.c
@@ -4,11 +4,11 @@
 #include <errno.h>
 #include <time.h>
 #include <sys/types.h>
+#include <platform/includes.h>
 
 #include <ccan/compiler/compiler.h>
 
 #include <libnvme.h>
-#include "platform/includes.h"
 #include "nvme-print.h"
 
 #include "util/json.h"
diff --git a/nvme-print-stdout.c b/nvme-print-stdout.c
index 36fcee2750..1cb1281a80 100644
--- a/nvme-print-stdout.c
+++ b/nvme-print-stdout.c
@@ -5,8 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
-#include <sys/stat.h>
-#include <sys/types.h>
+#include <platform/includes.h>
 #include <ccan/strset/strset.h>
 #include <ccan/htable/htable_type.h>
 #include <ccan/htable/htable.h>
@@ -14,8 +13,6 @@
 
 #include <libnvme.h>
 
-#include "platform/includes.h"
-
 #include "nvme.h"
 #include "nvme-print.h"
 #include "nvme-models.h"
diff --git a/nvme.h b/nvme.h
index ad44009468..6a1940cbc5 100644
--- a/nvme.h
+++ b/nvme.h
@@ -22,7 +22,8 @@
 
 #include <sys/stat.h>
 
-#include "platform/includes.h"
+#include <sys/stat.h>
+#include <sys/time.h>
 
 #include <libnvme-mi.h>
 
diff --git a/util/mem.c b/util/mem.c
index 0f677d5c1d..6facb3ced6 100644
--- a/util/mem.c
+++ b/util/mem.c
@@ -3,7 +3,7 @@
 #include <malloc.h>
 #include <string.h>
 
-#include "platform/includes.h"
+#include <platform/includes.h>
 
 #include "mem.h"
 
diff --git a/util/sighdl.c b/util/sighdl.c
index 9cbf3c3d66..3f7bfa5f1e 100644
--- a/util/sighdl.c
+++ b/util/sighdl.c
@@ -3,9 +3,10 @@
 #include <errno.h>
 #include <stddef.h>
 
+#include <platform/includes.h>
+
 #include "sighdl.h"
 
-#include "platform/includes.h"
 
 bool nvme_sigint_received;
 
diff --git a/util/table.c b/util/table.c
index 4936f41439..f9fc82c1c0 100644
--- a/util/table.c
+++ b/util/table.c
@@ -20,9 +20,9 @@
 #include <errno.h>
 #include <string.h>
 
-#include "table.h"
+#include <platform/includes.h>
 
-#include "platform/includes.h"
+#include "table.h"
 
 static int table_get_value_width(struct value *v)
 {

From e111b5eca43cb0ddb6045d1d34d5f075c533fbc6 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Mon, 6 Apr 2026 13:08:25 -0600
Subject: [PATCH 47/83] Copying libnvme dll into the root build folder during
 build. (#89)

To help with testing, copying the libnvme dll build output to the same
folder as nvme.exe during the build.
---
 meson.build | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/meson.build b/meson.build
index 0f9ee61a67..d71baca565 100644
--- a/meson.build
+++ b/meson.build
@@ -544,7 +544,7 @@ if want_nvme
         link_args_list = ['-ldl']
     endif
 
-    executable(
+    nvme_exe = executable(
         'nvme',
         sources,
         dependencies: link_deps,
@@ -553,6 +553,19 @@ if want_nvme
         install_dir: sbindir,
     )
 
+    if host_system == 'windows' and want_libnvme and not is_static
+        # Copy libnvme DLL next to nvme.exe so it can be found at
+        # runtime without modifying PATH.
+        cp = find_program('cp')
+        custom_target('copy-libnvme-dll',
+            input: libnvme,
+            output: fs.name(libnvme.full_path()),
+            command: [cp, '@INPUT@', '@OUTPUT@'],
+            depends: [libnvme, nvme_exe],
+            build_by_default: true,
+        )
+    endif
+
     if host_system != 'windows'
         subdir('unit')
     endif

From 538b17bb9944daea9e824e9cee82b09aafa1c7ac Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Mon, 6 Apr 2026 13:09:27 -0600
Subject: [PATCH 48/83] Updating copilot instructions for SPDX license headers.
 (#90)

Checkpatch requires /* */ comment style for license header.
Checked Daniel's latest new files that he added upstream,
and he used the /* */ comment style.
Updating the copilot instructions accordingly.
---
 .github/copilot-instructions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 9d1cb78184..bbe21b712c 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -181,7 +181,7 @@ You're currently working on Windows implementation (`libnvme/src/nvme/ioctl-wind
   - **Single-line standalone comments**: Use `/* */` format: `/* Single line comment */`
   - **Inline comments** (end-of-line): Use `/* */` format: `/* Inline comment */`
   - **TODO comments**: Use C++ style: `// TODO: description`
-  - **SPDX license headers**: Use C++ style: `// SPDX-License-Identifier: ...`
+  - **SPDX license headers**: Use C style: `/* SPDX-License-Identifier: ... */`
 - **Type declarations**: Prefer kernel types (`__u32`, `__le16`) for hardware structures
 
 See the Linux kernel [coding style documentation](https://www.kernel.org/doc/html/latest/process/coding-style.html) for complete details.

From de6afa3ac3b5a90b5b50e04c7eaf903a10ff61d5 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Tue, 7 Apr 2026 10:40:46 -0600
Subject: [PATCH 49/83] Removed windows-specific definition of S_ISBLK. (#92)

This macro is not needed, since S_ISBLK is available when building with
MSYS2. The value it was returning was also incorrect.
---
 libnvme/src/platform/windows.h | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 838ab37551..2a1a7ff1ce 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -458,13 +458,6 @@ static inline int fnmatch(const char *pattern, const char *string, int flags)
 #endif
 
 
-/* sys/stat.h compatibility */
-
-/* Window stub - always returning 0 */
-#ifndef S_ISBLK
-#define S_ISBLK(m) (0)
-#endif
-
 /* Windows _mkdir doesn't take mode parameter */
 #define mkdir(path, mode) _mkdir(path)
 

From a8986cefb950d111375755717a4c63012ec3f4db Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Tue, 7 Apr 2026 10:41:56 -0600
Subject: [PATCH 50/83] Refactoring to remove raw ioctl calls from nvme.c.
 (#91)

Added a method to ioctl.h that wraps the ioctl calls that were still
being issued directly from nvme.c.
A windows implementation can be added later if the equivalent
functionality is needed on Windows.
---
 libnvme/src/libnvme.ld           |  1 +
 libnvme/src/nvme/ioctl-windows.c | 10 +++++++++-
 libnvme/src/nvme/ioctl.c         | 21 +++++++++++++++++++++
 libnvme/src/nvme/ioctl.h         | 12 ++++++++++++
 libnvme/src/platform/windows.h   | 15 ---------------
 nvme.c                           | 17 +++--------------
 6 files changed, 46 insertions(+), 30 deletions(-)

diff --git a/libnvme/src/libnvme.ld b/libnvme/src/libnvme.ld
index 076d42d767..8545de4aa1 100644
--- a/libnvme/src/libnvme.ld
+++ b/libnvme/src/libnvme.ld
@@ -193,6 +193,7 @@ LIBNVME_3 {
 		nvme_transport_handle_set_submit_entry;
 		nvme_transport_handle_set_submit_exit;
 		nvme_unlink_ctrl;
+		nvme_update_block_size;
 		nvme_update_key;
 		nvme_uuid_from_string;
 		nvme_uuid_to_string;
diff --git a/libnvme/src/nvme/ioctl-windows.c b/libnvme/src/nvme/ioctl-windows.c
index 111cfaad28..fb9fabc4a0 100644
--- a/libnvme/src/nvme/ioctl-windows.c
+++ b/libnvme/src/nvme/ioctl-windows.c
@@ -111,7 +111,7 @@ __public int nvme_reset_ctrl(struct nvme_transport_handle *hdl)
 __public int nvme_rescan_ns(struct nvme_transport_handle *hdl)
 {
 	(void)hdl;
-	return -ENOTSUP;
+	return 0;	// NOP on Windows
 }
 
 __public int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
@@ -129,6 +129,14 @@ __public int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
 	return 0;
 }
 
+__public int nvme_update_block_size(struct nvme_transport_handle *hdl,
+		int block_size)
+{
+	(void)hdl;
+	(void)block_size;
+	return 0;	// NOP on Windows
+}
+
 /*
  * IOCTL_STORAGE_PROTOCOL_COMMAND pass-through implementation used for
  * VU commands and a small subset of other admin and IO commands.
diff --git a/libnvme/src/nvme/ioctl.c b/libnvme/src/nvme/ioctl.c
index 915b88eb79..4e5c5de471 100644
--- a/libnvme/src/nvme/ioctl.c
+++ b/libnvme/src/nvme/ioctl.c
@@ -12,6 +12,10 @@
 #include <stdlib.h>
 #include <string.h>
 
+#ifndef _WIN32
+#include <linux/fs.h>
+#endif
+
 #include <ccan/build_assert/build_assert.h>
 #include <ccan/endian/endian.h>
 #include <ccan/minmax/minmax.h>
@@ -89,6 +93,23 @@ __public int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
 	*nsid = tmp;
 	return 0;
 }
+
+__public int nvme_update_block_size(struct nvme_transport_handle *hdl,
+		int block_size)
+{
+	int ret;
+	nvme_fd_t fd = nvme_transport_handle_get_fd(hdl);
+
+	ret = ioctl(fd, BLKBSZSET, &block_size);
+	if (ret < 0)
+		return -errno;
+
+	ret = ioctl(fd, BLKRRPART);
+	if (ret < 0)
+		return -errno;
+
+	return 0;
+}
 #endif
 
 void *__nvme_submit_entry(struct nvme_transport_handle *hdl,
diff --git a/libnvme/src/nvme/ioctl.h b/libnvme/src/nvme/ioctl.h
index 197c94cd4b..e438708e36 100644
--- a/libnvme/src/nvme/ioctl.h
+++ b/libnvme/src/nvme/ioctl.h
@@ -96,3 +96,15 @@ int nvme_rescan_ns(struct nvme_transport_handle *hdl);
  * Return: 0 if @nsid was set successfully or -1 with errno set otherwise.
  */
 int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid);
+
+/**
+ * nvme_update_block_size() - Update the block size
+ * @hdl:	Transport handle
+ * @block_size:	New block size
+ *
+ * Notify the kernel blkdev to update its block size after a block size change.
+ * This should only be used for namespace handles, not controllers.
+ *
+ * Return: 0 if the block size was updated or a negative error code otherwise.
+ */
+int nvme_update_block_size(struct nvme_transport_handle *hdl, int block_size);
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 2a1a7ff1ce..593f61f7bf 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -91,21 +91,6 @@ static inline void closelog(void) { }
 typedef unsigned long nfds_t;
 
 
-/* sys/ioctl.h stubs */
-
-/* Linux ioctl constants - stubs for block device operations */
-#define BLKBSZSET 0x40081271
-#define BLKRRPART 0x125F
-
-/* Windows ioctl stub functions */
-static inline int ioctl(nvme_fd_t fd, unsigned long request, ...)
-{
-	(void)fd; (void)request;
-	errno = ENOSYS;
-	return -1;
-}
-
-
 /* sys/param.h compatibility */
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
diff --git a/nvme.c b/nvme.c
index 94fbc8bb65..5f9903f4a6 100644
--- a/nvme.c
+++ b/nvme.c
@@ -39,10 +39,6 @@
 #include <string.h>
 #include <unistd.h>
 
-#ifndef _WIN32
-#include <linux/fs.h>
-#endif
-
 #include <sys/stat.h>
 #include <sys/types.h>
 
@@ -6815,19 +6811,12 @@ static int format_cmd(int argc, char **argv, struct command *acmd, struct plugin
 			 * to the given one because blkdev will not
 			 * update by itself without re-opening fd.
 			 */
-			if (ioctl(nvme_transport_handle_get_fd(hdl), BLKBSZSET,
-				  &block_size) < 0) {
+			err = nvme_update_block_size(hdl, block_size);
+			if (err < 0) {
 				nvme_show_error(
 				    "failed to set block size to %d",
 				    block_size);
-				return -errno;
-			}
-
-			if (ioctl(nvme_transport_handle_get_fd(hdl),
-				  BLKRRPART) < 0) {
-				nvme_show_error(
-				    "failed to re-read partition table");
-				return -errno;
+				return err;
 			}
 		}
 	}

From 8322f8ff6c887a407a13f159b2e07cd99a3a1df0 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Wed, 8 Apr 2026 12:18:31 -0700
Subject: [PATCH 51/83] Adding file missed in merge.

---
 libnvme/src/nvme/ioctl.c | 82 ++++++++++++++++++++++++----------------
 1 file changed, 50 insertions(+), 32 deletions(-)

diff --git a/libnvme/src/nvme/ioctl.c b/libnvme/src/nvme/ioctl.c
index 4e5c5de471..69f6771c9e 100644
--- a/libnvme/src/nvme/ioctl.c
+++ b/libnvme/src/nvme/ioctl.c
@@ -26,7 +26,7 @@
 #include "compiler_attributes.h"
 
 #ifndef _WIN32
-static int nvme_verify_chr(struct nvme_transport_handle *hdl)
+static int nvme_verify_chr(struct libnvme_transport_handle *hdl)
 {
 	static struct stat nvme_stat;
 	int err = nvme_fstat(hdl->fd, &nvme_stat);
@@ -39,7 +39,7 @@ static int nvme_verify_chr(struct nvme_transport_handle *hdl)
 	return 0;
 }
 
-__public int nvme_reset_subsystem(struct nvme_transport_handle *hdl)
+__public int libnvme_reset_subsystem(struct libnvme_transport_handle *hdl)
 {
 	int ret;
 
@@ -47,13 +47,13 @@ __public int nvme_reset_subsystem(struct nvme_transport_handle *hdl)
 	if (ret)
 		return ret;
 
-	ret = ioctl(hdl->fd, NVME_IOCTL_SUBSYS_RESET);
+	ret = ioctl(hdl->fd, LIBNVME_IOCTL_SUBSYS_RESET);
 	if (ret < 0)
 		return -errno;
 	return ret;
 }
 
-__public int nvme_reset_ctrl(struct nvme_transport_handle *hdl)
+__public int libnvme_reset_ctrl(struct libnvme_transport_handle *hdl)
 {
 	int ret;
 
@@ -61,13 +61,13 @@ __public int nvme_reset_ctrl(struct nvme_transport_handle *hdl)
 	if (ret)
 		return ret;
 
-	ret = ioctl(hdl->fd, NVME_IOCTL_RESET);
+	ret = ioctl(hdl->fd, LIBNVME_IOCTL_RESET);
 	if (ret < 0)
 		return -errno;
 	return ret;
 }
 
-__public int nvme_rescan_ns(struct nvme_transport_handle *hdl)
+__public int libnvme_rescan_ns(struct libnvme_transport_handle *hdl)
 {
 	int ret;
 
@@ -75,18 +75,18 @@ __public int nvme_rescan_ns(struct nvme_transport_handle *hdl)
 	if (ret)
 		return ret;
 
-	ret = ioctl(hdl->fd, NVME_IOCTL_RESCAN);
+	ret = ioctl(hdl->fd, LIBNVME_IOCTL_RESCAN);
 	if (ret < 0)
 		return -errno;
 	return ret;
 }
 
-__public int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
+__public int libnvme_get_nsid(struct libnvme_transport_handle *hdl, __u32 *nsid)
 {
 	__u32 tmp;
 
 	errno = 0;
-	tmp = ioctl(hdl->fd, NVME_IOCTL_ID);
+	tmp = ioctl(hdl->fd, LIBNVME_IOCTL_ID);
 	if (errno)
 		return -errno;
 
@@ -94,6 +94,23 @@ __public int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
 	return 0;
 }
 
+__public int nvme_update_block_size(struct nvme_transport_handle *hdl,
+		int block_size)
+{
+	int ret;
+	nvme_fd_t fd = nvme_transport_handle_get_fd(hdl);
+
+	ret = ioctl(fd, BLKBSZSET, &block_size);
+	if (ret < 0)
+		return -errno;
+
+	ret = ioctl(fd, BLKRRPART);
+	if (ret < 0)
+		return -errno;
+
+	return 0;
+}
+
 __public int nvme_update_block_size(struct nvme_transport_handle *hdl,
 		int block_size)
 {
@@ -112,19 +129,19 @@ __public int nvme_update_block_size(struct nvme_transport_handle *hdl,
 }
 #endif
 
-void *__nvme_submit_entry(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+void *__libnvme_submit_entry(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	return NULL;
 }
 
-void __nvme_submit_exit(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd, int err, void *user_data)
+void __libnvme_submit_exit(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd, int err, void *user_data)
 {
 }
 
-bool __nvme_decide_retry(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd, int err)
+bool __libnvme_decide_retry(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd, int err)
 {
 	return false;
 }
@@ -134,8 +151,8 @@ bool __nvme_decide_retry(struct nvme_transport_handle *hdl,
  * The 64 bit version is the preferred version to use, but for backwards
  * compatibility keep a 32 version.
  */
-static int nvme_submit_passthru32(struct nvme_transport_handle *hdl,
-		unsigned long ioctl_cmd, struct nvme_passthru_cmd *cmd)
+static int libnvme_submit_passthru32(struct libnvme_transport_handle *hdl,
+		unsigned long ioctl_cmd, struct libnvme_passthru_cmd *cmd)
 {
 	struct linux_passthru_cmd32 cmd32;
 	void *user_data;
@@ -165,8 +182,8 @@ static int nvme_submit_passthru32(struct nvme_transport_handle *hdl,
  * supported since kernel 5.4, see
  * 65e68edce0db ("nvme: allow 64-bit results in passthru commands")
  */
-static int nvme_submit_passthru64(struct nvme_transport_handle *hdl,
-		unsigned long ioctl_cmd, struct nvme_passthru_cmd *cmd)
+static int libnvme_submit_passthru64(struct libnvme_transport_handle *hdl,
+		unsigned long ioctl_cmd, struct libnvme_passthru_cmd *cmd)
 {
 	void *user_data;
 	int err = 0;
@@ -191,28 +208,29 @@ static int nvme_submit_passthru64(struct nvme_transport_handle *hdl,
 	return err;
 }
 
-__public int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+__public int libnvme_submit_io_passthru(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	if (hdl->ioctl_io64)
-		return nvme_submit_passthru64(hdl, NVME_IOCTL_IO64_CMD, cmd);
-	return nvme_submit_passthru32(hdl, NVME_IOCTL_IO_CMD, cmd);
+		return libnvme_submit_passthru64(hdl,
+			LIBNVME_IOCTL_IO64_CMD, cmd);
+	return libnvme_submit_passthru32(hdl, LIBNVME_IOCTL_IO_CMD, cmd);
 }
 
-__public int nvme_submit_admin_passthru(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+__public int libnvme_submit_admin_passthru(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	switch (hdl->type) {
-	case NVME_TRANSPORT_HANDLE_TYPE_DIRECT:
+	case LIBNVME_TRANSPORT_HANDLE_TYPE_DIRECT:
 		if (hdl->ioctl_admin64)
-			return nvme_submit_passthru64(hdl,
-				NVME_IOCTL_ADMIN64_CMD, cmd);
+			return libnvme_submit_passthru64(hdl,
+				LIBNVME_IOCTL_ADMIN64_CMD, cmd);
 		if (cmd->opcode == nvme_admin_fabrics)
 			return -ENOTSUP;
-		return nvme_submit_passthru32(hdl,
-				NVME_IOCTL_ADMIN_CMD, cmd);
-	case NVME_TRANSPORT_HANDLE_TYPE_MI:
-		return nvme_mi_admin_admin_passthru(hdl, cmd);
+		return libnvme_submit_passthru32(hdl,
+				LIBNVME_IOCTL_ADMIN_CMD, cmd);
+	case LIBNVME_TRANSPORT_HANDLE_TYPE_MI:
+		return libnvme_mi_admin_admin_passthru(hdl, cmd);
 	default:
 		break;
 	}

From 63c4c6af8398e0851ef789e0a2ca0c4a2ba734bd Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Wed, 8 Apr 2026 14:39:28 -0600
Subject: [PATCH 52/83] Update Windows libnvme method name prefixes to match
 upstream changes. (#93)

The latest merge from upstream changed all the of method names and
library-specific types to use libnvme_ instead of nvme_ as the prefix to
their names. Updated Windows implementations and new methods and types
added during Windows development to match.

Also fixed duplicate method from last upstream merge.

Fixes build issues on both Linux and Windows.
---
 libnvme/src/libnvme.ld           |   4 +-
 libnvme/src/nvme/cleanup.h       |   2 +-
 libnvme/src/nvme/fabrics.c       |   4 +-
 libnvme/src/nvme/ioctl-windows.c | 126 ++++++++++++------------
 libnvme/src/nvme/ioctl.c         |  23 +----
 libnvme/src/nvme/ioctl.h         |   4 +-
 libnvme/src/nvme/lib-windows.c   |  34 +++----
 libnvme/src/nvme/lib.c           |   2 +-
 libnvme/src/nvme/lib.h           |   2 +-
 libnvme/src/nvme/mi-types.h      |   3 +-
 libnvme/src/nvme/private.h       |   4 +-
 libnvme/src/nvme/util.c          |   4 +-
 libnvme/src/nvme/windows-stubs.c | 164 +++++++++++++++----------------
 libnvme/src/platform/linux.h     |   8 +-
 libnvme/src/platform/windows.h   |   8 +-
 libnvme/test/ioctl/mock.c        |  12 +--
 libnvme/test/ioctl/mock.h        |   2 +-
 nvme.c                           |   4 +-
 plugins/ocp/ocp-nvme.c           |   4 +-
 19 files changed, 198 insertions(+), 216 deletions(-)

diff --git a/libnvme/src/libnvme.ld b/libnvme/src/libnvme.ld
index 16118ce1c7..74d7cef29f 100644
--- a/libnvme/src/libnvme.ld
+++ b/libnvme/src/libnvme.ld
@@ -41,7 +41,7 @@ LIBNVME_3 {
 		libnvme_free_nbft;
 		libnvme_free_ns;
 		libnvme_free_subsystem;
-		nvme_fstat;
+		libnvme_fstat;
 		libnvme_gen_dhchap_key;
 		libnvme_generate_hostid;
 		libnvme_generate_hostnqn;
@@ -194,7 +194,7 @@ LIBNVME_3 {
 		libnvme_transport_handle_set_submit_entry;
 		libnvme_transport_handle_set_submit_exit;
 		libnvme_unlink_ctrl;
-		nvme_update_block_size;
+		libnvme_update_block_size;
 		libnvme_update_key;
 		libnvme_uuid_from_string;
 		libnvme_uuid_to_string;
diff --git a/libnvme/src/nvme/cleanup.h b/libnvme/src/nvme/cleanup.h
index 56a51f43ea..dedc8ef8a8 100644
--- a/libnvme/src/nvme/cleanup.h
+++ b/libnvme/src/nvme/cleanup.h
@@ -31,7 +31,7 @@ static inline void freep(void *p)
 
 static inline void nvme_freep(void *p)
 {
-	__nvme_free(*(void **)p);
+	__libnvme_free(*(void **)p);
 }
 #define _cleanup_nvme_free_ __cleanup__(nvme_freep)
 
diff --git a/libnvme/src/nvme/fabrics.c b/libnvme/src/nvme/fabrics.c
index b583249182..ec3e695a6f 100644
--- a/libnvme/src/nvme/fabrics.c
+++ b/libnvme/src/nvme/fabrics.c
@@ -1336,7 +1336,7 @@ static int nvme_discovery_log(const struct libnvme_get_discovery_args *args,
 		if (numrec == 0)
 			break;
 
-		__nvme_free(log);
+		__libnvme_free(log);
 		entries_size = sizeof(*log->entries) * numrec;
 		log = __libnvme_alloc(sizeof(*log) + entries_size);
 		if (!log) {
@@ -1393,7 +1393,7 @@ static int nvme_discovery_log(const struct libnvme_get_discovery_args *args,
 	}
 
 out_free_log:
-	__nvme_free(log);
+	__libnvme_free(log);
 	return err;
 }
 
diff --git a/libnvme/src/nvme/ioctl-windows.c b/libnvme/src/nvme/ioctl-windows.c
index fb9fabc4a0..131d6867fd 100644
--- a/libnvme/src/nvme/ioctl-windows.c
+++ b/libnvme/src/nvme/ioctl-windows.c
@@ -96,25 +96,25 @@ static bool get_is_win_pe(void)
 	return false;
 }
 
-__public int nvme_reset_subsystem(struct nvme_transport_handle *hdl)
+__public int libnvme_reset_subsystem(struct libnvme_transport_handle *hdl)
 {
 	(void)hdl;
 	return -ENOTSUP;
 }
 
-__public int nvme_reset_ctrl(struct nvme_transport_handle *hdl)
+__public int libnvme_reset_ctrl(struct libnvme_transport_handle *hdl)
 {
 	(void)hdl;
 	return -ENOTSUP;
 }
 
-__public int nvme_rescan_ns(struct nvme_transport_handle *hdl)
+__public int libnvme_rescan_ns(struct libnvme_transport_handle *hdl)
 {
 	(void)hdl;
 	return 0;	// NOP on Windows
 }
 
-__public int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
+__public int libnvme_get_nsid(struct libnvme_transport_handle *hdl, __u32 *nsid)
 {
 	/* Get the SCSI LUN, which corresponds to NSID - 1. */
 	SCSI_ADDRESS addr = {0};
@@ -129,7 +129,7 @@ __public int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
 	return 0;
 }
 
-__public int nvme_update_block_size(struct nvme_transport_handle *hdl,
+__public int libnvme_update_block_size(struct libnvme_transport_handle *hdl,
 		int block_size)
 {
 	(void)hdl;
@@ -141,9 +141,9 @@ __public int nvme_update_block_size(struct nvme_transport_handle *hdl,
  * IOCTL_STORAGE_PROTOCOL_COMMAND pass-through implementation used for
  * VU commands and a small subset of other admin and IO commands.
  */
-static int nvme_submit_storage_protocol_command(
-		struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_storage_protocol_command(
+		struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	PSTORAGE_PROTOCOL_COMMAND protocol_command = NULL;
 	ULONG buffer_len = 0;
@@ -278,8 +278,8 @@ static int nvme_submit_storage_protocol_command(
 #define SCSIOP_READ16 0x88
 #define SCSIOP_WRITE16 0x8A
 
-static int nvme_submit_io_flush(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_io_flush(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	PSCSI_PASS_THROUGH pass_through = NULL;
 	ULONG buffer_len = 0;
@@ -379,7 +379,7 @@ static __u8 nvme_prinfo_to_scsi_wrrdprotect(__u8 prinfo)
  *
  * See NVM Express: SCSI Translation Reference documentation.
  */
-static void fill_scsi_rw16_cdb(struct nvme_passthru_cmd *cmd, UCHAR cdb[16])
+static void fill_scsi_rw16_cdb(struct libnvme_passthru_cmd *cmd, UCHAR cdb[16])
 {
 	__u8 opcode = (cmd->opcode == nvme_cmd_read) ?
 			SCSIOP_READ16 : SCSIOP_WRITE16;
@@ -414,8 +414,8 @@ static void fill_scsi_rw16_cdb(struct nvme_passthru_cmd *cmd, UCHAR cdb[16])
 	cdb[15] = 0;
 }
 
-static int nvme_submit_io_write(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_io_write(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	PSCSI_PASS_THROUGH pass_through = NULL;
 	ULONG buffer_len = 0;
@@ -496,8 +496,8 @@ static int nvme_submit_io_write(struct nvme_transport_handle *hdl,
 	return err;
 }
 
-static int nvme_submit_io_read(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_io_read(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	PSCSI_PASS_THROUGH pass_through = NULL;
 	ULONG buffer_len = 0;
@@ -583,8 +583,8 @@ static int nvme_submit_io_read(struct nvme_transport_handle *hdl,
  * Windows-specific admin command implementations.
  */
 
-static int nvme_submit_admin_get_log_page(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_admin_get_log_page(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	PSTORAGE_PROPERTY_QUERY query = NULL;
 	PSTORAGE_PROTOCOL_SPECIFIC_DATA protocol_data = NULL;
@@ -697,8 +697,8 @@ static int nvme_submit_admin_get_log_page(struct nvme_transport_handle *hdl,
 	return err;
 }
 
-static int nvme_submit_admin_identify(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_admin_identify(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	PSTORAGE_PROPERTY_QUERY query = NULL;
 	PSTORAGE_PROTOCOL_SPECIFIC_DATA protocol_data = NULL;
@@ -795,8 +795,8 @@ static int nvme_submit_admin_identify(struct nvme_transport_handle *hdl,
 	return err;
 }
 
-static int nvme_submit_admin_set_features(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_admin_set_features(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	PSTORAGE_PROPERTY_SET set_property = NULL;
 	PSTORAGE_PROTOCOL_SPECIFIC_DATA_EXT protocol_data = NULL;
@@ -886,8 +886,8 @@ static int nvme_submit_admin_set_features(struct nvme_transport_handle *hdl,
 	return err;
 }
 
-static int nvme_submit_admin_get_features(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_admin_get_features(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	PSTORAGE_PROPERTY_QUERY query = NULL;
 	PSTORAGE_PROTOCOL_SPECIFIC_DATA protocol_data = NULL;
@@ -1019,8 +1019,8 @@ typedef struct _STORAGE_HW_FIRMWARE_DOWNLOAD {
 
 #endif
 
-static int nvme_submit_admin_fw_commit(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_admin_fw_commit(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	PSTORAGE_HW_FIRMWARE_ACTIVATE firmware_activate = NULL;
 	ULONG buffer_len = 0;
@@ -1110,8 +1110,8 @@ static int nvme_submit_admin_fw_commit(struct nvme_transport_handle *hdl,
 	return err;
 }
 
-static int nvme_submit_admin_fw_download(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_admin_fw_download(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	PSTORAGE_HW_FIRMWARE_DOWNLOAD firmware_download = NULL;
 	ULONG buffer_len = 0;
@@ -1210,9 +1210,9 @@ static int nvme_submit_admin_fw_download(struct nvme_transport_handle *hdl,
 /* SCSI operation code for sanitize command - from ddk/scsi.h */
 #define SCSIOP_SANITIZE 0x48
 
-static int nvme_submit_admin_format_nvm_user_data_erase(
-		struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_admin_format_nvm_user_data_erase(
+		struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	/*
 	 * User Data Erase: Use IOCTL_SCSI_PASS_THROUGH with SCSIOP_SANITIZE
@@ -1309,9 +1309,9 @@ static int nvme_submit_admin_format_nvm_user_data_erase(
 	return err;
 }
 
-static int nvme_submit_admin_format_nvm_crypto_erase(
-		struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_admin_format_nvm_crypto_erase(
+		struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	BOOL result = FALSE;
 	ULONG returned_len = 0;
@@ -1349,14 +1349,14 @@ static int nvme_submit_admin_format_nvm_crypto_erase(
 	return err;
 }
 
-static int nvme_submit_admin_format_nvm(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_admin_format_nvm(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	__u8 ses;
 
 	/* For WinPE, use storage protocol command. */
 	if (get_is_win_pe())
-		return nvme_submit_storage_protocol_command(hdl, cmd);
+		return submit_storage_protocol_command(hdl, cmd);
 
 	/* Namespace-specific format is not supported on Windows */
 	if (cmd->nsid != NVME_NSID_ALL)
@@ -1380,9 +1380,9 @@ static int nvme_submit_admin_format_nvm(struct nvme_transport_handle *hdl,
 	case NVME_FORMAT_SES_NONE:
 		return -ENOTSUP;	/* Not supported on Windows */
 	case NVME_FORMAT_SES_USER_DATA_ERASE:
-		return nvme_submit_admin_format_nvm_user_data_erase(hdl, cmd);
+		return submit_admin_format_nvm_user_data_erase(hdl, cmd);
 	case NVME_FORMAT_SES_CRYPTO_ERASE:
-		return nvme_submit_admin_format_nvm_crypto_erase(hdl, cmd);
+		return submit_admin_format_nvm_crypto_erase(hdl, cmd);
 	default:
 		return -EINVAL;
 	}
@@ -1392,9 +1392,9 @@ static int nvme_submit_admin_format_nvm(struct nvme_transport_handle *hdl,
 #define SCSIOP_SECURITY_PROTOCOL_IN      0xA2
 #define SCSIOP_SECURITY_PROTOCOL_OUT     0xB5
 
-static int nvme_submit_admin_security_send_receive(
-		struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+static int submit_admin_security_send_receive(
+		struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	PSCSI_PASS_THROUGH pass_through = NULL;
 	ULONG buffer_len = 0;
@@ -1521,27 +1521,27 @@ static int nvme_submit_admin_security_send_receive(
  * For supported commands and a mapping to the required IOCTLs, see:
  * https://learn.microsoft.com/en-us/windows-hardware/drivers/storage/stornvme-command-set-support
  */
-__public int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+__public int libnvme_submit_io_passthru(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	if (!hdl || !cmd)
 		return -EINVAL;
 
 	switch (cmd->opcode) {
 	case nvme_cmd_flush:
-		return nvme_submit_io_flush(hdl, cmd);
+		return submit_io_flush(hdl, cmd);
 	case nvme_cmd_write:
-		return nvme_submit_io_write(hdl, cmd);
+		return submit_io_write(hdl, cmd);
 	case nvme_cmd_read:
-		return nvme_submit_io_read(hdl, cmd);
+		return submit_io_read(hdl, cmd);
 	case nvme_cmd_compare:
 		/* Only supported on WinPE */
 		if (get_is_win_pe())
-			return nvme_submit_storage_protocol_command(hdl, cmd);
+			return submit_storage_protocol_command(hdl, cmd);
 		else
 			return -ENOTSUP;
 	case 0x80 ... 0xFF: /* vendor-specific commands */
-		return nvme_submit_storage_protocol_command(hdl, cmd);
+		return submit_storage_protocol_command(hdl, cmd);
 	default:
 		return -ENOTSUP;
 	}
@@ -1557,46 +1557,46 @@ __public int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
  * For supported commands and a mapping to the required IOCTLs, see:
  * https://learn.microsoft.com/en-us/windows-hardware/drivers/storage/stornvme-command-set-support
  */
-__public int nvme_submit_admin_passthru(struct nvme_transport_handle *hdl,
-		struct nvme_passthru_cmd *cmd)
+__public int libnvme_submit_admin_passthru(struct libnvme_transport_handle *hdl,
+		struct libnvme_passthru_cmd *cmd)
 {
 	if (!hdl || !cmd)
 		return -EINVAL;
 
-	if (hdl->type != NVME_TRANSPORT_HANDLE_TYPE_DIRECT)
+	if (hdl->type != LIBNVME_TRANSPORT_HANDLE_TYPE_DIRECT)
 		return -ENOTSUP;
 
 	switch (cmd->opcode) {
 	case nvme_admin_get_log_page:
-		return nvme_submit_admin_get_log_page(hdl, cmd);
+		return submit_admin_get_log_page(hdl, cmd);
 	case nvme_admin_identify:
-		return nvme_submit_admin_identify(hdl, cmd);
+		return submit_admin_identify(hdl, cmd);
 	case nvme_admin_set_features:
-		return nvme_submit_admin_set_features(hdl, cmd);
+		return submit_admin_set_features(hdl, cmd);
 	case nvme_admin_get_features:
-		return nvme_submit_admin_get_features(hdl, cmd);
+		return submit_admin_get_features(hdl, cmd);
 	case nvme_admin_ns_mgmt:
 	case nvme_admin_ns_attach:
 		/* Only supported on WinPE */
 		if (get_is_win_pe())
-			return nvme_submit_storage_protocol_command(hdl, cmd);
+			return submit_storage_protocol_command(hdl, cmd);
 		else
 			return -ENOTSUP;
 	case nvme_admin_fw_commit:
-		return nvme_submit_admin_fw_commit(hdl, cmd);
+		return submit_admin_fw_commit(hdl, cmd);
 	case nvme_admin_fw_download:
-		return nvme_submit_admin_fw_download(hdl, cmd);
+		return submit_admin_fw_download(hdl, cmd);
 	case nvme_admin_dev_self_test:
-		return nvme_submit_storage_protocol_command(hdl, cmd);
+		return submit_storage_protocol_command(hdl, cmd);
 	case nvme_admin_format_nvm:
-		return nvme_submit_admin_format_nvm(hdl, cmd);
+		return submit_admin_format_nvm(hdl, cmd);
 	case nvme_admin_security_send:
 	case nvme_admin_security_recv:
-		return nvme_submit_admin_security_send_receive(hdl, cmd);
+		return submit_admin_security_send_receive(hdl, cmd);
 	case nvme_admin_sanitize_nvm:
-		return nvme_submit_storage_protocol_command(hdl, cmd);
+		return submit_storage_protocol_command(hdl, cmd);
 	case 0xC0 ... 0xFF: /* vendor-specific commands */
-		return nvme_submit_storage_protocol_command(hdl, cmd);
+		return submit_storage_protocol_command(hdl, cmd);
 	default:
 		return -ENOTSUP;
 	}
diff --git a/libnvme/src/nvme/ioctl.c b/libnvme/src/nvme/ioctl.c
index 69f6771c9e..9b403bc015 100644
--- a/libnvme/src/nvme/ioctl.c
+++ b/libnvme/src/nvme/ioctl.c
@@ -29,7 +29,7 @@
 static int nvme_verify_chr(struct libnvme_transport_handle *hdl)
 {
 	static struct stat nvme_stat;
-	int err = nvme_fstat(hdl->fd, &nvme_stat);
+	int err = libnvme_fstat(hdl->fd, &nvme_stat);
 
 	if (err < 0)
 		return -errno;
@@ -94,28 +94,11 @@ __public int libnvme_get_nsid(struct libnvme_transport_handle *hdl, __u32 *nsid)
 	return 0;
 }
 
-__public int nvme_update_block_size(struct nvme_transport_handle *hdl,
+__public int libnvme_update_block_size(struct libnvme_transport_handle *hdl,
 		int block_size)
 {
 	int ret;
-	nvme_fd_t fd = nvme_transport_handle_get_fd(hdl);
-
-	ret = ioctl(fd, BLKBSZSET, &block_size);
-	if (ret < 0)
-		return -errno;
-
-	ret = ioctl(fd, BLKRRPART);
-	if (ret < 0)
-		return -errno;
-
-	return 0;
-}
-
-__public int nvme_update_block_size(struct nvme_transport_handle *hdl,
-		int block_size)
-{
-	int ret;
-	nvme_fd_t fd = nvme_transport_handle_get_fd(hdl);
+	libnvme_fd_t fd = libnvme_transport_handle_get_fd(hdl);
 
 	ret = ioctl(fd, BLKBSZSET, &block_size);
 	if (ret < 0)
diff --git a/libnvme/src/nvme/ioctl.h b/libnvme/src/nvme/ioctl.h
index 84822a5ccc..cbdb5d5a3d 100644
--- a/libnvme/src/nvme/ioctl.h
+++ b/libnvme/src/nvme/ioctl.h
@@ -98,7 +98,7 @@ int libnvme_rescan_ns(struct libnvme_transport_handle *hdl);
 int libnvme_get_nsid(struct libnvme_transport_handle *hdl, __u32 *nsid);
 
 /**
- * nvme_update_block_size() - Update the block size
+ * libnvme_update_block_size() - Update the block size
  * @hdl:	Transport handle
  * @block_size:	New block size
  *
@@ -107,4 +107,4 @@ int libnvme_get_nsid(struct libnvme_transport_handle *hdl, __u32 *nsid);
  *
  * Return: 0 if the block size was updated or a negative error code otherwise.
  */
-int nvme_update_block_size(struct nvme_transport_handle *hdl, int block_size);
+int libnvme_update_block_size(struct libnvme_transport_handle *hdl, int block_size);
diff --git a/libnvme/src/nvme/lib-windows.c b/libnvme/src/nvme/lib-windows.c
index 080b8ecd7b..a6b5529341 100644
--- a/libnvme/src/nvme/lib-windows.c
+++ b/libnvme/src/nvme/lib-windows.c
@@ -11,13 +11,13 @@
 #include "compiler_attributes.h"
 
 
-static int __nvme_transport_handle_open_direct(struct nvme_transport_handle *hdl, const char *name)
+static int __nvme_transport_handle_open_direct(struct libnvme_transport_handle *hdl, const char *name)
 {
 	char device_path[MAX_PATH];
 	HANDLE h;
 
 	/* Parse and open direct device */
-	hdl->type = NVME_TRANSPORT_HANDLE_TYPE_DIRECT;
+	hdl->type = LIBNVME_TRANSPORT_HANDLE_TYPE_DIRECT;
 
 	/* Convert device name to Windows path */
 	if (strncmp(name, "\\\\.\\", 4) == 0) {
@@ -53,7 +53,7 @@ static int __nvme_transport_handle_open_direct(struct nvme_transport_handle *hdl
 
 	hdl->fd = h;
 
-	nvme_fstat(hdl->fd, &hdl->stat);
+	libnvme_fstat(hdl->fd, &hdl->stat);
 
 	/* Windows doesn't distinguish 32/64-bit ioctl, assume 64-bit capable */
 	hdl->ioctl_admin64 = true;
@@ -63,13 +63,13 @@ static int __nvme_transport_handle_open_direct(struct nvme_transport_handle *hdl
 }
 
 /* Transport handle operations (linux.c) */
-__public int nvme_open(struct nvme_global_ctx *ctx, const char *name,
-	      struct nvme_transport_handle **hdlp)
+__public int libnvme_open(struct libnvme_global_ctx *ctx, const char *name,
+	      struct libnvme_transport_handle **hdlp)
 {
-	struct nvme_transport_handle *hdl;
+	struct libnvme_transport_handle *hdl;
 	int ret;
 
-	hdl = __nvme_create_transport_handle(ctx);
+	hdl = __libnvme_create_transport_handle(ctx);
 	if (!hdl)
 		return -ENOMEM;
 
@@ -81,7 +81,7 @@ __public int nvme_open(struct nvme_global_ctx *ctx, const char *name,
 
 	/* Handle test devices */
 	if (!strncmp(name, "NVME_TEST_FD", 12)) {
-		hdl->type = NVME_TRANSPORT_HANDLE_TYPE_DIRECT;
+		hdl->type = LIBNVME_TRANSPORT_HANDLE_TYPE_DIRECT;
 		hdl->fd = TEST_FD;
 
 		if (!strcmp(name, "NVME_TEST_FD64"))
@@ -93,14 +93,14 @@ __public int nvme_open(struct nvme_global_ctx *ctx, const char *name,
 
 	/* MI transport not supported on Windows */
 	if (!strncmp(name, "mctp:", strlen("mctp:"))) {
-		nvme_close(hdl);
+		libnvme_close(hdl);
 		return -ENOTSUP;
 	} else {
 		ret = __nvme_transport_handle_open_direct(hdl, name);
 	}
 
 	if (ret) {
-		nvme_close(hdl);
+		libnvme_close(hdl);
 		return ret;
 	}
 
@@ -109,7 +109,7 @@ __public int nvme_open(struct nvme_global_ctx *ctx, const char *name,
 	return 0;
 }
 
-__public void nvme_close(struct nvme_transport_handle *hdl)
+__public void libnvme_close(struct libnvme_transport_handle *hdl)
 {
 	if (!hdl)
 		return;
@@ -117,24 +117,24 @@ __public void nvme_close(struct nvme_transport_handle *hdl)
 	free(hdl->name);
 
 	switch (hdl->type) {
-	case NVME_TRANSPORT_HANDLE_TYPE_DIRECT:
+	case LIBNVME_TRANSPORT_HANDLE_TYPE_DIRECT:
 		/* Close Windows HANDLE if valid */
 		if (hdl->fd && hdl->fd != TEST_FD)
 			CloseHandle(hdl->fd);
 		free(hdl);
 		break;
-	case NVME_TRANSPORT_HANDLE_TYPE_MI:
+	case LIBNVME_TRANSPORT_HANDLE_TYPE_MI:
 		/* MI not supported on Windows */
 		free(hdl);
 		break;
-	case NVME_TRANSPORT_HANDLE_TYPE_UNKNOWN:
+	case LIBNVME_TRANSPORT_HANDLE_TYPE_UNKNOWN:
 		free(hdl);
 		break;
 	}
 }
 
-/* Platform-specific fstat wrapper for nvme_fd_t */
-__public int nvme_fstat(nvme_fd_t fd, struct stat *buf)
+/* Platform-specific fstat wrapper for libnvme_fd_t */
+__public int libnvme_fstat(libnvme_fd_t fd, struct stat *buf)
 {
 	BY_HANDLE_FILE_INFORMATION file_info;
 	ULARGE_INTEGER ull;
@@ -174,7 +174,7 @@ __public int nvme_fstat(nvme_fd_t fd, struct stat *buf)
 	/* Convert Windows file attributes to stat mode */
 	if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DEVICE)
 		/* Windows device files should be marked as block devices */
-		/* This is used by nvme_verify_chr to check device type */
+		/* This is used by libnvme_verify_chr to check device type */
 		buf->st_mode = S_IFBLK | 0600;
 	else if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 		buf->st_mode = S_IFDIR | 0755;
diff --git a/libnvme/src/nvme/lib.c b/libnvme/src/nvme/lib.c
index 75a4f1d26d..ea82d9fb93 100644
--- a/libnvme/src/nvme/lib.c
+++ b/libnvme/src/nvme/lib.c
@@ -267,7 +267,7 @@ __public void libnvme_close(struct libnvme_transport_handle *hdl)
 }
 #endif /* !_WIN32 */
 
-__public nvme_fd_t libnvme_transport_handle_get_fd(struct libnvme_transport_handle *hdl)
+__public libnvme_fd_t libnvme_transport_handle_get_fd(struct libnvme_transport_handle *hdl)
 {
 	return hdl->fd;
 }
diff --git a/libnvme/src/nvme/lib.h b/libnvme/src/nvme/lib.h
index 75c9b5bef6..99768a17d4 100644
--- a/libnvme/src/nvme/lib.h
+++ b/libnvme/src/nvme/lib.h
@@ -97,7 +97,7 @@ void libnvme_close(struct libnvme_transport_handle *hdl);
  * Return: File descriptor for an IOCTL based transport handle,
  * otherwise INIT_FD.
  */
-nvme_fd_t libnvme_transport_handle_get_fd(struct libnvme_transport_handle *hdl);
+libnvme_fd_t libnvme_transport_handle_get_fd(struct libnvme_transport_handle *hdl);
 
 /**
  * libnvme_transport_handle_get_name - Return name of the device
diff --git a/libnvme/src/nvme/mi-types.h b/libnvme/src/nvme/mi-types.h
index 3c5f0566c5..d9c20a2608 100644
--- a/libnvme/src/nvme/mi-types.h
+++ b/libnvme/src/nvme/mi-types.h
@@ -7,8 +7,7 @@
  */
 #pragma once
 
-#include <endian.h>
-#include <stdint.h>
+#include<platform/includes.h>
 
 #include <nvme/types.h>
 
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index 4ae906d352..d83062c061 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -107,7 +107,7 @@ struct libnvme_transport_handle {
 			struct libnvme_passthru_cmd *cmd, int err);
 
 	/* direct */
-	nvme_fd_t fd;
+	libnvme_fd_t fd;
 	struct stat stat;
 	bool ioctl_admin64;
 	bool ioctl_io64;
@@ -389,7 +389,7 @@ void *__libnvme_alloc(size_t len);
 
 void *__libnvme_realloc(void *p, size_t len);
 
-void __nvme_free(void *p);
+void __libnvme_free(void *p);
 
 libnvme_host_t libnvme_lookup_host(struct libnvme_global_ctx *ctx,
 		const char *hostnqn, const char *hostid);
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index bbe862b6d7..1db50d619a 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -964,13 +964,13 @@ void *__libnvme_realloc(void *p, size_t len)
 
 	if (p && result) {
 		memcpy(result, p, min(old_len, len));
-		__nvme_free(p);
+		__libnvme_free(p);
 	}
 
 	return result;
 }
 
-void __nvme_free(void *p)
+void __libnvme_free(void *p)
 {
 	platform_aligned_free(p);
 }
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 53e86da643..7531052c88 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -25,7 +25,7 @@ static void stub_log(const char *func)
 		fprintf(stderr, "libnvme-stub: %s() called (not supported on Windows)\n", func);
 }
 
-void nvme_stubs_set_debug(int enable)
+void libnvme_stubs_set_debug(int enable)
 {
 	stub_log_enabled = enable;
 }
@@ -34,13 +34,13 @@ void nvme_stubs_set_debug(int enable)
  * Stub implementations for tree functions (tree.c)
  * Minimal support - just return NULL/errors
  */
-void __nvme_free_host(struct nvme_host *h)
+void __libnvme_free_host(struct libnvme_host *h)
 {
 	stub_log(__func__);
 	(void)h;
 }
 
-__public int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name, nvme_ctrl_t *c)
+__public int libnvme_scan_ctrl(struct libnvme_global_ctx *ctx, const char *name, libnvme_ctrl_t *c)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -50,8 +50,8 @@ __public int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name, nvme_
 	return -1;
 }
 
-__public int nvme_scan_namespace(struct nvme_global_ctx *ctx,
-		const char *name, nvme_ns_t *ns)
+__public int libnvme_scan_namespace(struct libnvme_global_ctx *ctx,
+		const char *name, libnvme_ns_t *ns)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -61,7 +61,7 @@ __public int nvme_scan_namespace(struct nvme_global_ctx *ctx,
 	return -ENOTSUP;
 }
 
-__public int nvme_scan_topology(struct nvme_global_ctx *ctx, nvme_scan_filter_t f, void *f_args)
+__public int libnvme_scan_topology(struct libnvme_global_ctx *ctx, libnvme_scan_filter_t f, void *f_args)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -71,14 +71,14 @@ __public int nvme_scan_topology(struct nvme_global_ctx *ctx, nvme_scan_filter_t
 	return -1;
 }
 
-__public nvme_host_t nvme_first_host(struct nvme_global_ctx *ctx)
+__public libnvme_host_t libnvme_first_host(struct libnvme_global_ctx *ctx)
 {
 	stub_log(__func__);
 	(void)ctx;
 	return NULL;
 }
 
-__public nvme_host_t nvme_next_host(struct nvme_global_ctx *ctx, nvme_host_t h)
+__public libnvme_host_t libnvme_next_host(struct libnvme_global_ctx *ctx, libnvme_host_t h)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -86,7 +86,7 @@ __public nvme_host_t nvme_next_host(struct nvme_global_ctx *ctx, nvme_host_t h)
 	return NULL;
 }
 
-nvme_host_t nvme_lookup_host(struct nvme_global_ctx *ctx, const char *hostnqn, const char *hostid)
+libnvme_host_t libnvme_lookup_host(struct libnvme_global_ctx *ctx, const char *hostnqn, const char *hostid)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -95,14 +95,14 @@ nvme_host_t nvme_lookup_host(struct nvme_global_ctx *ctx, const char *hostnqn, c
 	return NULL;
 }
 
-__public nvme_subsystem_t nvme_first_subsystem(nvme_host_t h)
+__public libnvme_subsystem_t libnvme_first_subsystem(libnvme_host_t h)
 {
 	stub_log(__func__);
 	(void)h;
 	return NULL;
 }
 
-__public nvme_subsystem_t nvme_next_subsystem(nvme_host_t h, nvme_subsystem_t s)
+__public libnvme_subsystem_t libnvme_next_subsystem(libnvme_host_t h, libnvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)h;
@@ -110,7 +110,7 @@ __public nvme_subsystem_t nvme_next_subsystem(nvme_host_t h, nvme_subsystem_t s)
 	return NULL;
 }
 
-nvme_subsystem_t nvme_lookup_subsystem(struct nvme_host *h, const char *name, const char *subsysnqn)
+libnvme_subsystem_t libnvme_lookup_subsystem(struct libnvme_host *h, const char *name, const char *subsysnqn)
 {
 	stub_log(__func__);
 	(void)h;
@@ -119,9 +119,9 @@ nvme_subsystem_t nvme_lookup_subsystem(struct nvme_host *h, const char *name, co
 	return NULL;
 }
 
-nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s,
+libnvme_ctrl_t libnvme_lookup_ctrl(libnvme_subsystem_t s,
 			     struct nvmf_context *fctx,
-			     nvme_ctrl_t p)
+			     libnvme_ctrl_t p)
 {
 	stub_log(__func__);
 	(void)s;
@@ -130,14 +130,14 @@ nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s,
 	return NULL;
 }
 
-__public nvme_ns_t nvme_ctrl_first_ns(nvme_ctrl_t c)
+__public libnvme_ns_t libnvme_ctrl_first_ns(libnvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-__public nvme_ns_t nvme_ctrl_next_ns(nvme_ctrl_t c, nvme_ns_t n)
+__public libnvme_ns_t libnvme_ctrl_next_ns(libnvme_ctrl_t c, libnvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)c;
@@ -145,14 +145,14 @@ __public nvme_ns_t nvme_ctrl_next_ns(nvme_ctrl_t c, nvme_ns_t n)
 	return NULL;
 }
 
-__public nvme_path_t nvme_ctrl_first_path(nvme_ctrl_t c)
+__public libnvme_path_t libnvme_ctrl_first_path(libnvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-__public nvme_path_t nvme_ctrl_next_path(nvme_ctrl_t c, nvme_path_t p)
+__public libnvme_path_t libnvme_ctrl_next_path(libnvme_ctrl_t c, libnvme_path_t p)
 {
 	stub_log(__func__);
 	(void)c;
@@ -160,50 +160,50 @@ __public nvme_path_t nvme_ctrl_next_path(nvme_ctrl_t c, nvme_path_t p)
 	return NULL;
 }
 
-__public nvme_subsystem_t nvme_ns_get_subsystem(nvme_ns_t n)
+__public libnvme_subsystem_t libnvme_ns_get_subsystem(libnvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return NULL;
 }
 
-__public nvme_ctrl_t nvme_ns_get_ctrl(nvme_ns_t n)
+__public libnvme_ctrl_t libnvme_ns_get_ctrl(libnvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return NULL;
 }
 
-__public enum nvme_csi nvme_ns_get_csi(nvme_ns_t n)
+__public enum nvme_csi libnvme_ns_get_csi(libnvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return 0;
 }
 
-__public const uint8_t *nvme_ns_get_eui64(nvme_ns_t n)
+__public const uint8_t *libnvme_ns_get_eui64(libnvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return NULL;
 }
 
-__public const uint8_t *nvme_ns_get_nguid(nvme_ns_t n)
+__public const uint8_t *libnvme_ns_get_nguid(libnvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return NULL;
 }
 
-__public void nvme_ns_get_uuid(nvme_ns_t n, unsigned char out[NVME_UUID_LEN])
+__public void libnvme_ns_get_uuid(libnvme_ns_t n, unsigned char out[NVME_UUID_LEN])
 {
 	stub_log(__func__);
 	(void)n;
 	(void)out;
 }
 
-int nvme_ns_get_transport_handle(nvme_ns_t n,
-		struct nvme_transport_handle **hdl)
+int libnvme_ns_get_transport_handle(libnvme_ns_t n,
+		struct libnvme_transport_handle **hdl)
 {
 	stub_log(__func__);
 	(void)n;
@@ -211,7 +211,7 @@ int nvme_ns_get_transport_handle(nvme_ns_t n,
 	return -ENOTSUP;
 }
 
-__public int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns)
+__public int libnvme_ns_identify(libnvme_ns_t n, struct nvme_id_ns *ns)
 {
 	stub_log(__func__);
 	(void)n;
@@ -220,62 +220,62 @@ __public int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns)
 	return -1;
 }
 
-__public const char *nvme_ns_get_generic_name(nvme_ns_t n)
+__public const char *libnvme_ns_get_generic_name(libnvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return "";
 }
 
-__public nvme_ctrl_t nvme_path_get_ctrl(nvme_path_t p)
+__public libnvme_ctrl_t libnvme_path_get_ctrl(libnvme_path_t p)
 {
 	stub_log(__func__);
 	(void)p;
 	return NULL;
 }
 
-__public nvme_ns_t nvme_path_get_ns(nvme_path_t p)
+__public libnvme_ns_t libnvme_path_get_ns(libnvme_path_t p)
 {
 	stub_log(__func__);
 	(void)p;
 	return NULL;
 }
 
-__public const char *nvme_ctrl_get_state(nvme_ctrl_t c)
+__public const char *libnvme_ctrl_get_state(libnvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return "";
 }
 
-__public struct nvme_fabrics_config *nvme_ctrl_get_config(nvme_ctrl_t c)
+__public struct libnvme_fabrics_config *libnvme_ctrl_get_config(libnvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-__public nvme_subsystem_t nvme_ctrl_get_subsystem(nvme_ctrl_t c)
+__public libnvme_subsystem_t libnvme_ctrl_get_subsystem(libnvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-__public struct nvme_transport_handle *nvme_ctrl_get_transport_handle(nvme_ctrl_t c)
+__public struct libnvme_transport_handle *libnvme_ctrl_get_transport_handle(libnvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
 	return NULL;
 }
 
-__public void nvme_free_ctrl(struct nvme_ctrl *c)
+__public void libnvme_free_ctrl(struct libnvme_ctrl *c)
 {
 	stub_log(__func__);
 	(void)c;
 }
 
-__public int nvme_disconnect_ctrl(nvme_ctrl_t c)
+__public int libnvme_disconnect_ctrl(libnvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)c;
@@ -283,28 +283,28 @@ __public int nvme_disconnect_ctrl(nvme_ctrl_t c)
 	return -1;
 }
 
-__public void nvme_unlink_ctrl(struct nvme_ctrl *c)
+__public void libnvme_unlink_ctrl(struct libnvme_ctrl *c)
 {
 	stub_log(__func__);
 	(void)c;
 }
 
 /* Subsystem functions (full name) - same as subsys */
-__public nvme_host_t nvme_subsystem_get_host(nvme_subsystem_t s)
+__public libnvme_host_t libnvme_subsystem_get_host(libnvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)s;
 	return NULL;
 }
 
-__public nvme_ctrl_t nvme_subsystem_first_ctrl(nvme_subsystem_t s)
+__public libnvme_ctrl_t libnvme_subsystem_first_ctrl(libnvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)s;
 	return NULL;
 }
 
-__public nvme_ctrl_t nvme_subsystem_next_ctrl(nvme_subsystem_t s, nvme_ctrl_t c)
+__public libnvme_ctrl_t libnvme_subsystem_next_ctrl(libnvme_subsystem_t s, libnvme_ctrl_t c)
 {
 	stub_log(__func__);
 	(void)s;
@@ -312,14 +312,14 @@ __public nvme_ctrl_t nvme_subsystem_next_ctrl(nvme_subsystem_t s, nvme_ctrl_t c)
 	return NULL;
 }
 
-__public nvme_ns_t nvme_subsystem_first_ns(nvme_subsystem_t s)
+__public libnvme_ns_t libnvme_subsystem_first_ns(libnvme_subsystem_t s)
 {
 	stub_log(__func__);
 	(void)s;
 	return NULL;
 }
 
-__public nvme_ns_t nvme_subsystem_next_ns(nvme_subsystem_t s, nvme_ns_t n)
+__public libnvme_ns_t libnvme_subsystem_next_ns(libnvme_subsystem_t s, libnvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)s;
@@ -327,7 +327,7 @@ __public nvme_ns_t nvme_subsystem_next_ns(nvme_subsystem_t s, nvme_ns_t n)
 	return NULL;
 }
 
-__public int nvme_dump_tree(struct nvme_global_ctx *ctx)
+__public int libnvme_dump_tree(struct libnvme_global_ctx *ctx)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -335,7 +335,7 @@ __public int nvme_dump_tree(struct nvme_global_ctx *ctx)
 	return -1;
 }
 
-__public int nvme_dump_config(struct nvme_global_ctx *ctx, int fd)
+__public int libnvme_dump_config(struct libnvme_global_ctx *ctx, int fd)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -348,8 +348,8 @@ __public int nvme_dump_config(struct nvme_global_ctx *ctx, int fd)
  * Stub implementations for MI functions (mi.c and mi-mctp.c)
  */
 
-int nvme_mi_admin_admin_passthru(struct nvme_transport_handle *hdl,
-				 struct nvme_passthru_cmd *cmd)
+int libnvme_mi_admin_admin_passthru(struct libnvme_transport_handle *hdl,
+				 struct libnvme_passthru_cmd *cmd)
 {
 	stub_log(__func__);
 	(void)hdl;
@@ -358,14 +358,14 @@ int nvme_mi_admin_admin_passthru(struct nvme_transport_handle *hdl,
 	return -1;
 }
 
-__public nvme_mi_ep_t nvme_mi_first_endpoint(struct nvme_global_ctx *ctx)
+__public libnvme_mi_ep_t libnvme_mi_first_endpoint(struct libnvme_global_ctx *ctx)
 {
 	stub_log(__func__);
 	(void)ctx;
 	return NULL;
 }
 
-__public nvme_mi_ep_t nvme_mi_next_endpoint(struct nvme_global_ctx *ctx, nvme_mi_ep_t e)
+__public libnvme_mi_ep_t libnvme_mi_next_endpoint(struct libnvme_global_ctx *ctx, libnvme_mi_ep_t e)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -373,7 +373,7 @@ __public nvme_mi_ep_t nvme_mi_next_endpoint(struct nvme_global_ctx *ctx, nvme_mi
 	return NULL;
 }
 
-__public int nvme_mi_scan_ep(nvme_mi_ep_t ep, bool force_rescan)
+__public int libnvme_mi_scan_ep(libnvme_mi_ep_t ep, bool force_rescan)
 {
 	stub_log(__func__);
 	(void)ep;
@@ -382,15 +382,15 @@ __public int nvme_mi_scan_ep(nvme_mi_ep_t ep, bool force_rescan)
 	return -1;
 }
 
-struct nvme_transport_handle *nvme_mi_first_transport_handle(nvme_mi_ep_t ep)
+struct libnvme_transport_handle *libnvme_mi_first_transport_handle(libnvme_mi_ep_t ep)
 {
 	stub_log(__func__);
 	(void)ep;
 	return NULL;
 }
 
-struct nvme_transport_handle *nvme_mi_next_transport_handle(nvme_mi_ep_t ep,
-	struct nvme_transport_handle *hdl)
+struct libnvme_transport_handle *libnvme_mi_next_transport_handle(libnvme_mi_ep_t ep,
+	struct libnvme_transport_handle *hdl)
 {
 	stub_log(__func__);
 	(void)ep;
@@ -398,7 +398,7 @@ struct nvme_transport_handle *nvme_mi_next_transport_handle(nvme_mi_ep_t ep,
 	return NULL;
 }
 
-__public void nvme_mi_close(nvme_mi_ep_t ep)
+__public void libnvme_mi_close(libnvme_mi_ep_t ep)
 {
 	stub_log(__func__);
 	(void)ep;
@@ -407,7 +407,7 @@ __public void nvme_mi_close(nvme_mi_ep_t ep)
 /*
  * TLS/PSK key management stubs (linux.c functions)
  */
-__public int nvme_export_tls_key_versioned(struct nvme_global_ctx *ctx,
+__public int libnvme_export_tls_key_versioned(struct libnvme_global_ctx *ctx,
 				  unsigned char version, unsigned char hmac,
 				  const unsigned char *key_data,
 				  size_t key_len, char **identity)
@@ -423,7 +423,7 @@ __public int nvme_export_tls_key_versioned(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-__public int nvme_export_tls_key(struct nvme_global_ctx *ctx,
+__public int libnvme_export_tls_key(struct libnvme_global_ctx *ctx,
 	const unsigned char *key_data, int key_len, char **identity)
 {
 	stub_log(__func__);
@@ -435,7 +435,7 @@ __public int nvme_export_tls_key(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-__public int nvme_import_tls_key_versioned(struct nvme_global_ctx *ctx,
+__public int libnvme_import_tls_key_versioned(struct libnvme_global_ctx *ctx,
 				  const char *encoded_key,
 				  unsigned char *version,
 				  unsigned char *hmac,
@@ -453,7 +453,7 @@ __public int nvme_import_tls_key_versioned(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-__public int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encoded_key,
+__public int libnvme_import_tls_key(struct libnvme_global_ctx *ctx, const char *encoded_key,
 			int *key_len, unsigned int *hmac, unsigned char **key)
 {
 	stub_log(__func__);
@@ -470,21 +470,21 @@ __public int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encode
  * Additional stubs for nvme-cli linking
  */
 /* Namespace property getters (tree.c) */
-__public const char *nvme_ns_get_firmware(nvme_ns_t n)
+__public const char *libnvme_ns_get_firmware(libnvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return "";
 }
 
-__public const char *nvme_ns_get_model(nvme_ns_t n)
+__public const char *libnvme_ns_get_model(libnvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
 	return "";
 }
 
-__public const char *nvme_ns_get_serial(nvme_ns_t n)
+__public const char *libnvme_ns_get_serial(libnvme_ns_t n)
 {
 	stub_log(__func__);
 	(void)n;
@@ -492,14 +492,14 @@ __public const char *nvme_ns_get_serial(nvme_ns_t n)
 }
 
 /* Namespace path iteration (tree.c) */
-__public nvme_path_t nvme_namespace_first_path(nvme_ns_t ns)
+__public libnvme_path_t libnvme_namespace_first_path(libnvme_ns_t ns)
 {
 	stub_log(__func__);
 	(void)ns;
 	return NULL;
 }
 
-__public nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p)
+__public libnvme_path_t libnvme_namespace_next_path(libnvme_ns_t ns, libnvme_path_t p)
 {
 	stub_log(__func__);
 	(void)ns;
@@ -508,7 +508,7 @@ __public nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p)
 }
 
 /* MI status string (mi.c) */
-__public const char *nvme_mi_status_to_string(int status)
+__public const char *libnvme_mi_status_to_string(int status)
 {
 	stub_log(__func__);
 	(void)status;
@@ -519,7 +519,7 @@ __public const char *nvme_mi_status_to_string(int status)
  * Linux keyring and TLS key management stubs (linux.c)
  * These are used by nvme-cli security commands
  */
-__public int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
+__public int libnvme_read_key(struct libnvme_global_ctx *ctx, long keyring_id,
 		long key_id, int *len, unsigned char **key)
 {
 	stub_log(__func__);
@@ -532,7 +532,7 @@ __public int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
 	return -1;
 }
 
-__public int nvme_lookup_keyring(struct nvme_global_ctx *ctx,
+__public int libnvme_lookup_keyring(struct libnvme_global_ctx *ctx,
 		const char *keyring, long *key)
 {
 	stub_log(__func__);
@@ -543,7 +543,7 @@ __public int nvme_lookup_keyring(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-__public int nvme_update_key(struct nvme_global_ctx *ctx, long keyring_id,
+__public int libnvme_update_key(struct libnvme_global_ctx *ctx, long keyring_id,
 		const char *key_type, const char *identity,
 		unsigned char *key_data, int key_len, long *key)
 {
@@ -559,7 +559,7 @@ __public int nvme_update_key(struct nvme_global_ctx *ctx, long keyring_id,
 	return -1;
 }
 
-__public int nvme_revoke_tls_key(struct nvme_global_ctx *ctx, const char *keyring,
+__public int libnvme_revoke_tls_key(struct libnvme_global_ctx *ctx, const char *keyring,
 		const char *key_type, const char *identity)
 {
 	stub_log(__func__);
@@ -571,8 +571,8 @@ __public int nvme_revoke_tls_key(struct nvme_global_ctx *ctx, const char *keyrin
 	return -1;
 }
 
-__public int nvme_scan_tls_keys(struct nvme_global_ctx *ctx, const char *keyring,
-		nvme_scan_tls_keys_cb_t cb, void *data)
+__public int libnvme_scan_tls_keys(struct libnvme_global_ctx *ctx, const char *keyring,
+		libnvme_scan_tls_keys_cb_t cb, void *data)
 {
 	stub_log(__func__);
 	(void)ctx;
@@ -583,7 +583,7 @@ __public int nvme_scan_tls_keys(struct nvme_global_ctx *ctx, const char *keyring
 	return -1;
 }
 
-__public char *nvme_describe_key_serial(struct nvme_global_ctx *ctx,
+__public char *libnvme_describe_key_serial(struct libnvme_global_ctx *ctx,
 		long key_id)
 {
 	stub_log(__func__);
@@ -592,7 +592,7 @@ __public char *nvme_describe_key_serial(struct nvme_global_ctx *ctx,
 	return NULL;
 }
 
-__public int nvme_insert_tls_key_versioned(struct nvme_global_ctx *ctx,
+__public int libnvme_insert_tls_key_versioned(struct libnvme_global_ctx *ctx,
 		const char *keyring, const char *key_type,
 		const char *hostnqn, const char *subsysnqn,
 		int version, int hmac,
@@ -614,7 +614,7 @@ __public int nvme_insert_tls_key_versioned(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-__public int nvme_generate_tls_key_identity_compat(struct nvme_global_ctx *ctx,
+__public int libnvme_generate_tls_key_identity_compat(struct libnvme_global_ctx *ctx,
 		const char *hostnqn, const char *subsysnqn,
 		int version, int hmac, unsigned char *configured_key,
 		int key_len, char **identity)
@@ -632,7 +632,7 @@ __public int nvme_generate_tls_key_identity_compat(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-__public int nvme_insert_tls_key_compat(struct nvme_global_ctx *ctx,
+__public int libnvme_insert_tls_key_compat(struct libnvme_global_ctx *ctx,
 		const char *keyring, const char *key_type,
 		const char *hostnqn, const char *subsysnqn,
 		int version, int hmac,
@@ -654,7 +654,7 @@ __public int nvme_insert_tls_key_compat(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-__public int nvme_generate_tls_key_identity(struct nvme_global_ctx *ctx,
+__public int libnvme_generate_tls_key_identity(struct libnvme_global_ctx *ctx,
 		const char *hostnqn, const char *subsysnqn,
 		int version, int hmac,
 		unsigned char *configured_key, int key_len,
@@ -673,15 +673,15 @@ __public int nvme_generate_tls_key_identity(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-__public char *nvme_read_hostnqn(void)
+__public char *libnvme_read_hostnqn(void)
 {
 	stub_log(__func__);
 	/* No /etc/nvme/hostnqn equivalent on Windows */
 	return NULL;
 }
 
-__public int nvme_gen_dhchap_key(struct nvme_global_ctx *ctx,
-		char *hostnqn, enum nvme_hmac_alg hmac,
+__public int libnvme_gen_dhchap_key(struct libnvme_global_ctx *ctx,
+		char *hostnqn, enum libnvme_hmac_alg hmac,
 		unsigned int key_len, unsigned char *secret,
 		unsigned char *key)
 {
@@ -696,7 +696,7 @@ __public int nvme_gen_dhchap_key(struct nvme_global_ctx *ctx,
 	return -1;
 }
 
-__public int nvme_create_raw_secret(struct nvme_global_ctx *ctx,
+__public int libnvme_create_raw_secret(struct libnvme_global_ctx *ctx,
 		const char *secret, size_t key_len, unsigned char **raw_secret)
 {
 	stub_log(__func__);
@@ -704,7 +704,7 @@ __public int nvme_create_raw_secret(struct nvme_global_ctx *ctx,
 }
 
 /* Hostnqn generation (fabrics.c) */
-__public char *nvme_generate_hostnqn(void)
+__public char *libnvme_generate_hostnqn(void)
 {
 	stub_log(__func__);
 	/* Could implement UUID-based generation, but for now just fail */
@@ -712,7 +712,7 @@ __public char *nvme_generate_hostnqn(void)
 }
 
 /* Path property getters (tree.c) */
-__public int nvme_path_get_queue_depth(struct nvme_path *p)
+__public int libnvme_path_get_queue_depth(struct libnvme_path *p)
 {
 	stub_log(__func__);
 	(void)p;
@@ -784,7 +784,7 @@ __public const char *nvmf_treq_str(__u8 treq)
 }
 
 /* NBFT functions (nbft.c) */
-__public int nvmf_nbft_read_files(struct nvme_global_ctx *ctx, char *path,
+__public int nvmf_nbft_read_files(struct libnvme_global_ctx *ctx, char *path,
 			  struct nbft_file_entry **nbft_list)
 {
 	stub_log(__func__);
@@ -795,7 +795,7 @@ __public int nvmf_nbft_read_files(struct nvme_global_ctx *ctx, char *path,
 	return -1;
 }
 
-__public void nvmf_nbft_free(struct nvme_global_ctx *ctx, struct nbft_file_entry *head)
+__public void nvmf_nbft_free(struct libnvme_global_ctx *ctx, struct nbft_file_entry *head)
 {
 	stub_log(__func__);
 	(void)ctx;
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index 48c406f828..130c4f13a1 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -33,7 +33,7 @@
 /* Extract IPv4 from IPv6 mapped address */
 #define ipv4_from_in6_addr(addr) &(addr.s6_addr32[3])
 
-typedef int nvme_fd_t;
+typedef int libnvme_fd_t;
 #define TEST_FD 0xFD
 #define INIT_FD -1
 
@@ -42,14 +42,14 @@ typedef int nvme_fd_t;
 #define O_BINARY 0
 #endif
 
-/* Platform-specific fstat wrapper for nvme_fd_t */
-static inline int nvme_fstat(nvme_fd_t fd, struct stat *buf)
+/* Platform-specific fstat wrapper for libnvme_fd_t */
+static inline int libnvme_fstat(libnvme_fd_t fd, struct stat *buf)
 {
 	return fstat(fd, buf);
 }
 
 /* Platform initialization - no-op on Linux */
-static inline void nvme_init(void) {}
+static inline void libnvme_init(void) {}
 
 /* Platform-specific UUID generation using /dev/urandom */
 static inline int random_uuid(unsigned char *uuid, size_t len)
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 593f61f7bf..5b5b7f5a16 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -29,7 +29,7 @@
 
 /* Platform compatibility helper types and methods */
 
-typedef HANDLE nvme_fd_t;
+typedef HANDLE libnvme_fd_t;
 #define TEST_FD INVALID_HANDLE_VALUE
 #define INIT_FD nullptr
 
@@ -38,7 +38,7 @@ typedef HANDLE nvme_fd_t;
  * translation from converting LF to CRLF and corrupting raw binary output.
  * Called once at startup from main().
  */
-static inline void nvme_init(void)
+static inline void libnvme_init(void)
 {
 	_setmode(_fileno(stdout), O_BINARY);
 	_setmode(_fileno(stderr), O_BINARY);
@@ -446,8 +446,8 @@ static inline int fnmatch(const char *pattern, const char *string, int flags)
 /* Windows _mkdir doesn't take mode parameter */
 #define mkdir(path, mode) _mkdir(path)
 
-/* Platform-specific fstat wrapper for nvme_fd_t */
-int nvme_fstat(nvme_fd_t fd, struct stat *buf);
+/* Platform-specific fstat wrapper for libnvme_fd_t */
+int libnvme_fstat(libnvme_fd_t fd, struct stat *buf);
 
 
 /* mman.h memory mapping stubs - not supported on Windows */
diff --git a/libnvme/test/ioctl/mock.c b/libnvme/test/ioctl/mock.c
index b8d0569b2b..a656b2c804 100644
--- a/libnvme/test/ioctl/mock.c
+++ b/libnvme/test/ioctl/mock.c
@@ -21,7 +21,7 @@ struct mock_cmds {
 	size_t remaining_cmds;
 };
 
-static nvme_fd_t mock_fd = INIT_FD;
+static libnvme_fd_t mock_fd = INIT_FD;
 static struct mock_cmds mock_admin_cmds = {.name = "admin"};
 static struct mock_cmds mock_io_cmds = {.name = "IO"};
 
@@ -39,7 +39,7 @@ static void mock_cmds_done(const struct mock_cmds *mock_cmds)
 	      mock_cmds->remaining_cmds, mock_cmds->name);
 }
 
-void set_mock_fd(nvme_fd_t fd)
+void set_mock_fd(libnvme_fd_t fd)
 {
 	mock_fd = fd;
 }
@@ -122,11 +122,11 @@ void end_mock_cmds(void)
 })
 
 #if defined(HAVE_GLIBC_IOCTL) && HAVE_GLIBC_IOCTL == 1
-typedef int (*ioctl_func_t)(nvme_fd_t, unsigned long, void *);
-int ioctl(nvme_fd_t fd, unsigned long request, ...)
+typedef int (*ioctl_func_t)(libnvme_fd_t, unsigned long, void *);
+int ioctl(libnvme_fd_t fd, unsigned long request, ...)
 #else
-typedef int (*ioctl_func_t)(nvme_fd_t, int, void *);
-int ioctl(nvme_fd_t fd, int request, ...)
+typedef int (*ioctl_func_t)(libnvme_fd_t, int, void *);
+int ioctl(libnvme_fd_t fd, int request, ...)
 #endif
 {
 	ioctl_func_t real_ioctl = NULL;
diff --git a/libnvme/test/ioctl/mock.h b/libnvme/test/ioctl/mock.h
index 8e2af7cab6..8304f76921 100644
--- a/libnvme/test/ioctl/mock.h
+++ b/libnvme/test/ioctl/mock.h
@@ -61,7 +61,7 @@ struct mock_cmd {
  * set_mock_fd() - sets the expected file descriptor for NVMe passthru ioctls()
  * @fd: file descriptor expected to be passed to ioctl()
  */
-void set_mock_fd(nvme_fd_t fd);
+void set_mock_fd(libnvme_fd_t fd);
 
 /**
  * set_mock_admin_cmds() - mocks NVMe admin passthru ioctl() invocations
diff --git a/nvme.c b/nvme.c
index 2916e2bef5..8fc856a00f 100644
--- a/nvme.c
+++ b/nvme.c
@@ -6811,7 +6811,7 @@ static int format_cmd(int argc, char **argv, struct command *acmd, struct plugin
 			 * to the given one because blkdev will not
 			 * update by itself without re-opening fd.
 			 */
-			err = nvme_update_block_size(hdl, block_size);
+			err = libnvme_update_block_size(hdl, block_size);
 			if (err < 0) {
 				nvme_show_error(
 				    "failed to set block size to %d",
@@ -11288,7 +11288,7 @@ int main(int argc, char **argv)
 {
 	int err;
 
-	nvme_init();
+	libnvme_init();
 	nvme.extensions->parent = &nvme;
 	if (argc < 2) {
 		general_help(&builtin, NULL);
diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index bbcc890b4e..2c8d0e022d 100644
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -349,7 +349,7 @@ int ocp_set_latency_monitor_feature(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = nvme_fstat(libnvme_transport_handle_get_fd(hdl), &nvme_stat);
+	err = libnvme_fstat(libnvme_transport_handle_get_fd(hdl), &nvme_stat);
 	if (err < 0)
 		return err;
 
@@ -1463,7 +1463,7 @@ static int ocp_telemetry_log(int argc, char **argv, struct command *acmd, struct
 	if (opt.telemetry_type == 0)
 		opt.telemetry_type = "host";
 
-	err = nvme_fstat(libnvme_transport_handle_get_fd(hdl), &nvme_stat);
+	err = libnvme_fstat(libnvme_transport_handle_get_fd(hdl), &nvme_stat);
 	if (err < 0)
 		return err;
 

From 4e0494e64c72bfb7d30d4ab747134b85098f5963 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Tue, 14 Apr 2026 16:29:54 -0600
Subject: [PATCH 53/83] Build fix: Updated libnvme_lookup_ctrl stub to match
 new signature. (#95)

A recent merge from master changed the signature of libnvme_lookup_ctrl,
breaking the mingw build.
---
 libnvme/src/nvme/windows-stubs.c | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 7531052c88..1ba475dc51 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -120,7 +120,7 @@ libnvme_subsystem_t libnvme_lookup_subsystem(struct libnvme_host *h, const char
 }
 
 libnvme_ctrl_t libnvme_lookup_ctrl(libnvme_subsystem_t s,
-			     struct nvmf_context *fctx,
+			     struct libnvmf_context *fctx,
 			     libnvme_ctrl_t p)
 {
 	stub_log(__func__);
@@ -720,63 +720,63 @@ __public int libnvme_path_get_queue_depth(struct libnvme_path *p)
 }
 
 /* Fabrics string conversion functions (fabrics.c) */
-__public const char *nvmf_trtype_str(__u8 trtype)
+__public const char *libnvmf_trtype_str(__u8 trtype)
 {
 	stub_log(__func__);
 	(void)trtype;
 	return "unknown";
 }
 
-__public const char *nvmf_eflags_str(__u16 eflags)
+__public const char *libnvmf_eflags_str(__u16 eflags)
 {
 	stub_log(__func__);
 	(void)eflags;
 	return "unknown";
 }
 
-__public const char *nvmf_sectype_str(__u8 sectype)
+__public const char *libnvmf_sectype_str(__u8 sectype)
 {
 	stub_log(__func__);
 	(void)sectype;
 	return "unknown";
 }
 
-__public const char *nvmf_cms_str(__u8 cms)
+__public const char *libnvmf_cms_str(__u8 cms)
 {
 	stub_log(__func__);
 	(void)cms;
 	return "unknown";
 }
 
-__public const char *nvmf_qptype_str(__u8 qptype)
+__public const char *libnvmf_qptype_str(__u8 qptype)
 {
 	stub_log(__func__);
 	(void)qptype;
 	return "unknown";
 }
 
-__public const char *nvmf_prtype_str(__u8 prtype)
+__public const char *libnvmf_prtype_str(__u8 prtype)
 {
 	stub_log(__func__);
 	(void)prtype;
 	return "unknown";
 }
 
-__public const char *nvmf_adrfam_str(__u8 adrfam)
+__public const char *libnvmf_adrfam_str(__u8 adrfam)
 {
 	stub_log(__func__);
 	(void)adrfam;
 	return "unknown";
 }
 
-__public const char *nvmf_subtype_str(__u8 subtype)
+__public const char *libnvmf_subtype_str(__u8 subtype)
 {
 	stub_log(__func__);
 	(void)subtype;
 	return "unknown";
 }
 
-__public const char *nvmf_treq_str(__u8 treq)
+__public const char *libnvmf_treq_str(__u8 treq)
 {
 	stub_log(__func__);
 	(void)treq;
@@ -784,7 +784,7 @@ __public const char *nvmf_treq_str(__u8 treq)
 }
 
 /* NBFT functions (nbft.c) */
-__public int nvmf_nbft_read_files(struct libnvme_global_ctx *ctx, char *path,
+__public int libnvmf_nbft_read_files(struct libnvme_global_ctx *ctx, char *path,
 			  struct nbft_file_entry **nbft_list)
 {
 	stub_log(__func__);
@@ -795,7 +795,7 @@ __public int nvmf_nbft_read_files(struct libnvme_global_ctx *ctx, char *path,
 	return -1;
 }
 
-__public void nvmf_nbft_free(struct libnvme_global_ctx *ctx, struct nbft_file_entry *head)
+__public void libnvmf_nbft_free(struct libnvme_global_ctx *ctx, struct nbft_file_entry *head)
 {
 	stub_log(__func__);
 	(void)ctx;

From a53f7bed7e50016c25c730583ae3b38db9a4ad2b Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Tue, 14 Apr 2026 16:47:29 -0600
Subject: [PATCH 54/83] Added better support for more Windows ioctl error
 codes. (#94)

Testing ran into some error conditions that returned the default -EIO
from ioctl-windows because the actual error types they were returning
weren't being handled.
---
 libnvme/src/nvme/ioctl-windows.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/libnvme/src/nvme/ioctl-windows.c b/libnvme/src/nvme/ioctl-windows.c
index 131d6867fd..ef94ae6b36 100644
--- a/libnvme/src/nvme/ioctl-windows.c
+++ b/libnvme/src/nvme/ioctl-windows.c
@@ -35,9 +35,12 @@ static int get_last_error_as_errno(void)
 	switch (error) {
 	case ERROR_INVALID_PARAMETER:
 		return -EINVAL;
+	case ERROR_CALL_NOT_IMPLEMENTED:
+	case ERROR_INVALID_FUNCTION:
 	case ERROR_NOT_SUPPORTED:
 		return -ENOTSUP;
 	case ERROR_INSUFFICIENT_BUFFER:
+	case ERROR_NO_SYSTEM_RESOURCES:
 		return -ENOMEM;
 	case ERROR_IO_DEVICE:
 		return -EIO;

From 202ad68a85f72c49fc01bc4970f338a503ed5746 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Wed, 15 Apr 2026 09:08:47 -0700
Subject: [PATCH 55/83] Fixed Linux build post merge.

_cleanup_nvme_free_ in nvme/cleanup.h needed to be updated.
---
 libnvme/src/nvme/cleanup.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libnvme/src/nvme/cleanup.h b/libnvme/src/nvme/cleanup.h
index bf337e061a..59904135cc 100644
--- a/libnvme/src/nvme/cleanup.h
+++ b/libnvme/src/nvme/cleanup.h
@@ -33,7 +33,7 @@ static inline void nvme_freep(void *p)
 {
 	__libnvme_free(*(void **)p);
 }
-#define _cleanup_nvme_free_ __cleanup__(nvme_freep)
+#define __cleanup_nvme_free __cleanup(nvme_freep)
 
 static inline DEFINE_CLEANUP_FUNC(cleanup_file, FILE *, fclose)
 #define __cleanup_file __cleanup(cleanup_file)

From 083bae34fcd29aa5ed9e54a95e4affb7bf289f2a Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Wed, 15 Apr 2026 11:57:13 -0700
Subject: [PATCH 56/83] Missed merge file.

---
 plugins/memblaze/memblaze-nvme.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/plugins/memblaze/memblaze-nvme.c b/plugins/memblaze/memblaze-nvme.c
index beb503fbec..137b418d42 100644
--- a/plugins/memblaze/memblaze-nvme.c
+++ b/plugins/memblaze/memblaze-nvme.c
@@ -13,7 +13,6 @@
 #include "nvme-cmds.h"
 #include "nvme-print.h"
 #include "nvme.h"
-#include "platform/types.h"
 #include "plugin.h"
 
 #define CREATE_CMD

From 07ec65480bf05826885a13e458bc413d1d7db68b Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Wed, 15 Apr 2026 12:10:12 -0700
Subject: [PATCH 57/83] Post-merge build fixes.

---
 libnvme/src/nvme/ioctl-windows.c |  2 +-
 libnvme/src/nvme/lib-windows.c   |  2 +-
 libnvme/src/nvme/lib.c           |  4 +++
 libnvme/src/nvme/lib.h           |  2 ++
 libnvme/src/nvme/private.h       |  2 ++
 libnvme/src/nvme/windows-stubs.c | 62 +-------------------------------
 6 files changed, 11 insertions(+), 63 deletions(-)

diff --git a/libnvme/src/nvme/ioctl-windows.c b/libnvme/src/nvme/ioctl-windows.c
index ef94ae6b36..cdc90e3211 100644
--- a/libnvme/src/nvme/ioctl-windows.c
+++ b/libnvme/src/nvme/ioctl-windows.c
@@ -21,7 +21,7 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
-#include "compiler_attributes.h"
+#include "compiler-attributes.h"
 
 /* Definitions not yet included in mingw's winerror.h */
 #define STG_E_FIRMWARE_SLOT_INVALID      _HRESULT_TYPEDEF_(0x80030208L)
diff --git a/libnvme/src/nvme/lib-windows.c b/libnvme/src/nvme/lib-windows.c
index a6b5529341..cbf54628ca 100644
--- a/libnvme/src/nvme/lib-windows.c
+++ b/libnvme/src/nvme/lib-windows.c
@@ -8,7 +8,7 @@
 
 #include "private.h"
 #include "nvme/lib.h"
-#include "compiler_attributes.h"
+#include "compiler-attributes.h"
 
 
 static int __nvme_transport_handle_open_direct(struct libnvme_transport_handle *hdl, const char *name)
diff --git a/libnvme/src/nvme/lib.c b/libnvme/src/nvme/lib.c
index a88a0da7a4..795df12768 100644
--- a/libnvme/src/nvme/lib.c
+++ b/libnvme/src/nvme/lib.c
@@ -22,7 +22,11 @@
 #include "cleanup.h"
 #include "cleanup-linux.h"
 #include "private.h"
+
+#ifdef CONFIG_MI
 #include "private-mi.h"
+#endif
+
 #include "compiler-attributes.h"
 
 static bool libnvme_mi_probe_enabled_default(void)
diff --git a/libnvme/src/nvme/lib.h b/libnvme/src/nvme/lib.h
index 86492541a3..b61afe01e1 100644
--- a/libnvme/src/nvme/lib.h
+++ b/libnvme/src/nvme/lib.h
@@ -13,6 +13,8 @@
 
 #include <nvme/lib-types.h>
 
+#include <platform/includes.h> /* for libnvme_fd_t */
+
 enum libnvme_log_level {
 	LIBNVME_LOG_ERR	  = 0,
 	LIBNVME_LOG_WARN  = 1,
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index fb264ac6bb..3e58c0c4d8 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -10,6 +10,8 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
+#include <platform/includes.h> /* for libnvme_fd_t */
+
 #include <ccan/list/list.h>
 
 #include <nvme/fabrics.h>
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 1ba475dc51..a62ba09cdc 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -14,7 +14,7 @@
 #include <nvme/types.h>
 
 #include "private.h"
-#include "compiler_attributes.h"
+#include "compiler-attributes.h"
 
 /* Logging control for stub calls */
 static int stub_log_enabled = 0;
@@ -344,66 +344,6 @@ __public int libnvme_dump_config(struct libnvme_global_ctx *ctx, int fd)
 	return -1;
 }
 
-/*
- * Stub implementations for MI functions (mi.c and mi-mctp.c)
- */
-
-int libnvme_mi_admin_admin_passthru(struct libnvme_transport_handle *hdl,
-				 struct libnvme_passthru_cmd *cmd)
-{
-	stub_log(__func__);
-	(void)hdl;
-	(void)cmd;
-	errno = ENOTSUP;
-	return -1;
-}
-
-__public libnvme_mi_ep_t libnvme_mi_first_endpoint(struct libnvme_global_ctx *ctx)
-{
-	stub_log(__func__);
-	(void)ctx;
-	return NULL;
-}
-
-__public libnvme_mi_ep_t libnvme_mi_next_endpoint(struct libnvme_global_ctx *ctx, libnvme_mi_ep_t e)
-{
-	stub_log(__func__);
-	(void)ctx;
-	(void)e;
-	return NULL;
-}
-
-__public int libnvme_mi_scan_ep(libnvme_mi_ep_t ep, bool force_rescan)
-{
-	stub_log(__func__);
-	(void)ep;
-	(void)force_rescan;
-	errno = ENOTSUP;
-	return -1;
-}
-
-struct libnvme_transport_handle *libnvme_mi_first_transport_handle(libnvme_mi_ep_t ep)
-{
-	stub_log(__func__);
-	(void)ep;
-	return NULL;
-}
-
-struct libnvme_transport_handle *libnvme_mi_next_transport_handle(libnvme_mi_ep_t ep,
-	struct libnvme_transport_handle *hdl)
-{
-	stub_log(__func__);
-	(void)ep;
-	(void)hdl;
-	return NULL;
-}
-
-__public void libnvme_mi_close(libnvme_mi_ep_t ep)
-{
-	stub_log(__func__);
-	(void)ep;
-}
-
 /*
  * TLS/PSK key management stubs (linux.c functions)
  */

From 468884001729a49a64e8b57a404949763eaad0c2 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Thu, 16 Apr 2026 15:43:19 -0600
Subject: [PATCH 58/83] Cleaned up remaining MI and Fabrics stubs and
 compatibility and removed platform/types.h (#96)

Recent upstream changes removed the need for platform/types.h and made
MI and Fabrics only compile if supported, which they aren't on windows.
Cleaning up our Windows support based on these changes.

- Removed platform/types.h
- Removed platform/includes.h support that is no longer needed
  - Removed functionality only used by MI and fabrics
- Removed endian and log support that is not needed due to upstream
refactoring
 - Removed MI and Fabrics stubs
 - Restored nbft.c to match master since it only builds with fabrics
---
 libnvme/src/meson.build          |  1 -
 libnvme/src/nvme/nbft.c          |  8 +--
 libnvme/src/nvme/windows-stubs.c | 95 +-------------------------------
 libnvme/src/platform/includes.h  |  2 -
 libnvme/src/platform/linux.h     |  2 -
 libnvme/src/platform/types.h     | 44 ---------------
 libnvme/src/platform/windows.h   | 67 ----------------------
 windows-stubs.c                  | 49 ----------------
 8 files changed, 6 insertions(+), 262 deletions(-)
 delete mode 100644 libnvme/src/platform/types.h

diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index 1562bb68ea..3e6a47b8c3 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -198,7 +198,6 @@ install_headers([
         'platform/includes.h',
         'platform/linux.h',
         'platform/windows.h',
-        'platform/types.h'
     ],
     subdir: 'platform',
     install_mode: mode,
diff --git a/libnvme/src/nvme/nbft.c b/libnvme/src/nvme/nbft.c
index b66d7e653e..575707f689 100644
--- a/libnvme/src/nvme/nbft.c
+++ b/libnvme/src/nvme/nbft.c
@@ -10,7 +10,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include <platform/includes.h>
+#include <arpa/inet.h>
 
 #include <ccan/endian/endian.h>
 
@@ -36,7 +36,7 @@ static void format_ip_addr(char *buf, size_t buflen, __u8 *addr)
 	memcpy(&addr_ipv6, addr, sizeof(addr_ipv6));
 	if (IN6_IS_ADDR_V4MAPPED(&addr_ipv6))
 		/* ipv4 */
-		inet_ntop(AF_INET, ipv4_from_in6_addr(addr_ipv6), buf, buflen);
+		inet_ntop(AF_INET, &addr_ipv6.s6_addr32[3], buf, buflen);
 	else
 		/* ipv6 */
 		inet_ntop(AF_INET6, &addr_ipv6, buf, buflen);
@@ -102,9 +102,9 @@ static int __get_heap_obj(struct libnvme_global_ctx *ctx,
 		if (strnlen(*output, le16_to_cpu(obj.length) + 1) <
 				le16_to_cpu(obj.length)) {
 			libnvme_msg(ctx, LIBNVME_LOG_DEBUG,
-				"file %s: string '%s' in descriptor '%s' is shorter (%u) than specified length (%u)\n",
+				"file %s: string '%s' in descriptor '%s' is shorter (%zd) than specified length (%d)\n",
 				filename, fieldname, descriptorname,
-				(unsigned int)strnlen(*output, le16_to_cpu(obj.length) + 1),
+				strnlen(*output, le16_to_cpu(obj.length) + 1),
 					le16_to_cpu(obj.length));
 		} else if (strnlen(*output, le16_to_cpu(obj.length) + 1) >
 				le16_to_cpu(obj.length)) {
diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index a62ba09cdc..3f9dda98b7 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -4,7 +4,7 @@
  * Copyright (c) 2025 Micron Technology, Inc.
  *
  * Windows stub implementations for Linux-specific functionality
- * that is excluded from the Windows build (fabrics, MI, tree, filters, etc.)
+ * that is excluded from the Windows build (tree, filters, etc.)
  */
 
 #include <errno.h>
@@ -447,14 +447,6 @@ __public libnvme_path_t libnvme_namespace_next_path(libnvme_ns_t ns, libnvme_pat
 	return NULL;
 }
 
-/* MI status string (mi.c) */
-__public const char *libnvme_mi_status_to_string(int status)
-{
-	stub_log(__func__);
-	(void)status;
-	return "MI not supported on Windows";
-}
-
 /*
  * Linux keyring and TLS key management stubs (linux.c)
  * These are used by nvme-cli security commands
@@ -643,7 +635,7 @@ __public int libnvme_create_raw_secret(struct libnvme_global_ctx *ctx,
 	return -ENOTSUP;
 }
 
-/* Hostnqn generation (fabrics.c) */
+/* Hostnqn generation */
 __public char *libnvme_generate_hostnqn(void)
 {
 	stub_log(__func__);
@@ -658,86 +650,3 @@ __public int libnvme_path_get_queue_depth(struct libnvme_path *p)
 	(void)p;
 	return 0;
 }
-
-/* Fabrics string conversion functions (fabrics.c) */
-__public const char *libnvmf_trtype_str(__u8 trtype)
-{
-	stub_log(__func__);
-	(void)trtype;
-	return "unknown";
-}
-
-__public const char *libnvmf_eflags_str(__u16 eflags)
-{
-	stub_log(__func__);
-	(void)eflags;
-	return "unknown";
-}
-
-__public const char *libnvmf_sectype_str(__u8 sectype)
-{
-	stub_log(__func__);
-	(void)sectype;
-	return "unknown";
-}
-
-__public const char *libnvmf_cms_str(__u8 cms)
-{
-	stub_log(__func__);
-	(void)cms;
-	return "unknown";
-}
-
-__public const char *libnvmf_qptype_str(__u8 qptype)
-{
-	stub_log(__func__);
-	(void)qptype;
-	return "unknown";
-}
-
-__public const char *libnvmf_prtype_str(__u8 prtype)
-{
-	stub_log(__func__);
-	(void)prtype;
-	return "unknown";
-}
-
-__public const char *libnvmf_adrfam_str(__u8 adrfam)
-{
-	stub_log(__func__);
-	(void)adrfam;
-	return "unknown";
-}
-
-__public const char *libnvmf_subtype_str(__u8 subtype)
-{
-	stub_log(__func__);
-	(void)subtype;
-	return "unknown";
-}
-
-__public const char *libnvmf_treq_str(__u8 treq)
-{
-	stub_log(__func__);
-	(void)treq;
-	return "unknown";
-}
-
-/* NBFT functions (nbft.c) */
-__public int libnvmf_nbft_read_files(struct libnvme_global_ctx *ctx, char *path,
-			  struct nbft_file_entry **nbft_list)
-{
-	stub_log(__func__);
-	(void)ctx;
-	(void)path;
-	(void)nbft_list;
-	errno = ENOTSUP;
-	return -1;
-}
-
-__public void libnvmf_nbft_free(struct libnvme_global_ctx *ctx, struct nbft_file_entry *head)
-{
-	stub_log(__func__);
-	(void)ctx;
-	(void)head;
-}
diff --git a/libnvme/src/platform/includes.h b/libnvme/src/platform/includes.h
index 8c14fb905b..9810056b86 100644
--- a/libnvme/src/platform/includes.h
+++ b/libnvme/src/platform/includes.h
@@ -8,8 +8,6 @@
 
 #pragma once
 
-#include "platform/types.h"
-
 /* Platform-specific includes */
 #ifdef _WIN32
     #include "platform/windows.h"
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index 130c4f13a1..e1dde196b2 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -30,8 +30,6 @@
 #include <netdb.h>
 #include <netinet/in.h>
 
-/* Extract IPv4 from IPv6 mapped address */
-#define ipv4_from_in6_addr(addr) &(addr.s6_addr32[3])
 
 typedef int libnvme_fd_t;
 #define TEST_FD 0xFD
diff --git a/libnvme/src/platform/types.h b/libnvme/src/platform/types.h
deleted file mode 100644
index b51427b2e4..0000000000
--- a/libnvme/src/platform/types.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-only */
-/*
- * This file is part of libnvme.
- * Copyright (c) 2026 Micron Technology, Inc.
- *
- * Platform compatibility for linux/types.h
- */
-#pragma once
-
-#ifdef _WIN32
-
-#include <stdint.h>
-
-/* Standard type definitions for linux/types.h compatibility */
-typedef uint8_t  __u8;
-typedef uint16_t __u16;
-typedef uint32_t __u32;
-typedef uint64_t __u64;
-typedef int8_t   __s8;
-typedef int16_t  __s16;
-typedef int32_t  __s32;
-typedef int64_t  __s64;
-
-/* Little-endian types (Windows is little-endian) */
-typedef __u16    __le16;
-typedef __u32    __le32;
-typedef __u64    __le64;
-typedef __s16    __le16s;
-typedef __s32    __le32s;
-typedef __s64    __le64s;
-
-/* Big-endian types for completeness */
-typedef __u16    __be16;
-typedef __u32    __be32;
-typedef __u64    __be64;
-typedef __s16    __be16s;
-typedef __s32    __be32s;
-typedef __s64    __be64s;
-
-#else
-
-#include <linux/types.h>
-
-#endif
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 5b5b7f5a16..3b97d203ff 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -45,52 +45,6 @@ static inline void libnvme_init(void)
 }
 
 
-/* endian.h compatibility */
-
-#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-	#define htobe16(x) (x)
-	#define htobe32(x) (x)
-	#define htobe64(x) (x)
-	#define htole16(x) __builtin_bswap16(x)
-	#define htole32(x) __builtin_bswap32(x)
-	#define htole64(x) __builtin_bswap64(x)
-	#define le16toh(x) __builtin_bswap16(x)
-	#define le32toh(x) __builtin_bswap32(x)
-	#define le64toh(x) __builtin_bswap64(x)
-#else
-	/* Little-endian (most common case for Windows) */
-	#define htobe16(x) __builtin_bswap16(x)
-	#define htobe32(x) __builtin_bswap32(x)
-	#define htobe64(x) __builtin_bswap64(x)
-	#define htole16(x) (x)
-	#define htole32(x) (x)
-	#define htole64(x) (x)
-	#define le16toh(x) (x)
-	#define le32toh(x) (x)
-	#define le64toh(x) (x)
-#endif
-
-
-/* syslog.h compatibility */
-
-#define LOG_EMERG   0
-#define LOG_ALERT   1
-#define LOG_CRIT    2
-#define LOG_ERR     3
-#define LOG_WARNING 4
-#define LOG_NOTICE  5
-#define LOG_INFO    6
-#define LOG_DEBUG   7
-static inline void syslog(int priority, const char *format, ...) { (void)priority; (void)format; }
-static inline void openlog(const char *ident, int option, int facility) { (void)ident; (void)option; (void)facility; }
-static inline void closelog(void) { }
-
-
-/* poll.h compatibility (winsock2.h provides additional compatibility) */
-
-typedef unsigned long nfds_t;
-
-
 /* sys/param.h compatibility */
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
@@ -106,27 +60,6 @@ typedef unsigned long nfds_t;
 #define ENAVAIL   119
 
 
-/* socket.h compatibility */
-
-struct msghdr {
-	void *msg_name;
-	socklen_t msg_namelen;
-	struct iovec *msg_iov;
-	size_t msg_iovlen;
-	void *msg_control;
-	size_t msg_controllen;
-	int msg_flags;
-};
-
-struct iovec {
-	void *iov_base;
-	size_t iov_len;
-};
-
-/* Extract IPv4 from IPv6 mapped address (in6_addr) */
-#define ipv4_from_in6_addr(addr) &(addr.u.Byte[12])
-
-
 /* ifaddrs.h compatibility */
 
 struct ifaddrs {
diff --git a/windows-stubs.c b/windows-stubs.c
index 00fa13111d..0282be60fb 100644
--- a/windows-stubs.c
+++ b/windows-stubs.c
@@ -9,55 +9,6 @@
 #ifdef _WIN32
 
 #include <stdio.h>
-#include <stdbool.h>
-
-/* ========== NVMe Fabrics Command Stubs ========== */
-/*
- * NVMe over Fabrics is not currently supported on Windows.
- * These stubs provide error messages when users attempt to use fabrics commands.
- */
-
-int fabrics_discovery(const char *desc, int argc, char **argv, bool connect)
-{
-	(void)desc; (void)argc; (void)argv; (void)connect;
-	fprintf(stderr, "NVMe fabrics discovery is not supported on Windows\n");
-	return -1;
-}
-
-int fabrics_connect(const char *desc, int argc, char **argv)
-{
-	(void)desc; (void)argc; (void)argv;
-	fprintf(stderr, "NVMe fabrics connect is not supported on Windows\n");
-	return -1;
-}
-
-int fabrics_disconnect(const char *desc, int argc, char **argv)
-{
-	(void)desc; (void)argc; (void)argv;
-	fprintf(stderr, "NVMe fabrics disconnect is not supported on Windows\n");
-	return -1;
-}
-
-int fabrics_disconnect_all(const char *desc, int argc, char **argv)
-{
-	(void)desc; (void)argc; (void)argv;
-	fprintf(stderr, "NVMe fabrics disconnect-all is not supported on Windows\n");
-	return -1;
-}
-
-int fabrics_config(const char *desc, int argc, char **argv)
-{
-	(void)desc; (void)argc; (void)argv;
-	fprintf(stderr, "NVMe fabrics config is not supported on Windows\n");
-	return -1;
-}
-
-int fabrics_dim(const char *desc, int argc, char **argv)
-{
-	(void)desc; (void)argc; (void)argv;
-	fprintf(stderr, "NVMe fabrics DIM is not supported on Windows\n");
-	return -1;
-}
 
 /* ========== NVMe RPMB Command Stubs ========== */
 /*

From 304a3516027279439f137eba105f224d1e5b7804 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 08:22:34 -0700
Subject: [PATCH 59/83] Fixed windows-stubs.c build post merge.

Explicitly including tree.h for definitions found there.
---
 libnvme/src/nvme/windows-stubs.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libnvme/src/nvme/windows-stubs.c b/libnvme/src/nvme/windows-stubs.c
index 3f9dda98b7..b57942664f 100644
--- a/libnvme/src/nvme/windows-stubs.c
+++ b/libnvme/src/nvme/windows-stubs.c
@@ -14,6 +14,7 @@
 #include <nvme/types.h>
 
 #include "private.h"
+#include "tree.h"
 #include "compiler-attributes.h"
 
 /* Logging control for stub calls */

From a0c52218a909a7f82c38f2cb2f851b8150c040a3 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 10:40:59 -0700
Subject: [PATCH 60/83] Cleanup of platform/includes.h usage.

- Removed platform/includes usage where possible.
- Restored default includes where possible.
- Removed unneeded support from platform/windows.h
---
 libnvme/src/nvme/cleanup.h     |   4 +-
 libnvme/src/nvme/ioctl.c       |   2 +-
 libnvme/src/nvme/log.c         |   3 +-
 libnvme/src/nvme/mi-mctp.c     |   6 +-
 libnvme/src/nvme/util.c        |   5 +-
 libnvme/src/platform/windows.h | 117 +++++----------------------------
 logging.c                      |   2 +-
 nvme-print-json.c              |   7 +-
 nvme-print-stdout.c            |   9 ++-
 util/table.c                   |   2 +-
 10 files changed, 45 insertions(+), 112 deletions(-)

diff --git a/libnvme/src/nvme/cleanup.h b/libnvme/src/nvme/cleanup.h
index db0b2b3b71..02fb9fb61e 100644
--- a/libnvme/src/nvme/cleanup.h
+++ b/libnvme/src/nvme/cleanup.h
@@ -4,9 +4,7 @@
 
 #include <stdlib.h>
 
-#include <platform/includes.h>
-
-#include "private.h"
+#include "private.h"	/* for __libnvme_free */
 
 #define __cleanup(fn) __attribute__((cleanup(fn)))
 
diff --git a/libnvme/src/nvme/ioctl.c b/libnvme/src/nvme/ioctl.c
index 5b1b3b8d58..edfba69490 100644
--- a/libnvme/src/nvme/ioctl.c
+++ b/libnvme/src/nvme/ioctl.c
@@ -29,7 +29,7 @@
 static int nvme_verify_chr(struct libnvme_transport_handle *hdl)
 {
 	static struct stat nvme_stat;
-	int err = libnvme_fstat(hdl->fd, &nvme_stat);
+	int err = fstat(hdl->fd, &nvme_stat);
 
 	if (err < 0)
 		return -errno;
diff --git a/libnvme/src/nvme/log.c b/libnvme/src/nvme/log.c
index 6cde865bf3..a436e005f7 100644
--- a/libnvme/src/nvme/log.c
+++ b/libnvme/src/nvme/log.c
@@ -12,8 +12,7 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <time.h>
-
-#include <platform/includes.h>
+#include <unistd.h>
 
 #include <libnvme.h>
 
diff --git a/libnvme/src/nvme/mi-mctp.c b/libnvme/src/nvme/mi-mctp.c
index cd86202c0e..8f9d16ca90 100644
--- a/libnvme/src/nvme/mi-mctp.c
+++ b/libnvme/src/nvme/mi-mctp.c
@@ -12,8 +12,12 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
 
-#include <platform/includes.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/uio.h>
 
 #if HAVE_LINUX_MCTP_H
 #include <linux/mctp.h>
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 1bcd286d8e..13fc3ee506 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -19,13 +19,14 @@
 #if defined(HAVE_NETDB) || defined(CONFIG_FABRICS)
 #include <sys/types.h>
 #include <ifaddrs.h>
+#include <arpa/inet.h>
+#include <netdb.h>
 #endif
 
+#include <sys/param.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
-#include <platform/includes.h>
-
 #include <ccan/endian/endian.h>
 #include <ccan/minmax/minmax.h>
 
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 3b97d203ff..3da5f002fd 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -44,20 +44,27 @@ static inline void libnvme_init(void)
 	_setmode(_fileno(stderr), O_BINARY);
 }
 
+/* Platform-specific UUID generation using BCryptGenRandom */
+static inline int random_uuid(unsigned char *uuid, size_t len)
+{
+	NTSTATUS status;
 
-/* sys/param.h compatibility */
+	status = BCryptGenRandom(NULL, uuid, (ULONG)len,
+				 BCRYPT_USE_SYSTEM_PREFERRED_RNG);
+	if (!BCRYPT_SUCCESS(status))
+		return -EIO;
 
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
+	return 0;
+}
 
 
 /* errno.h compatibility */
 
-#define EREMOTEIO 121
-#define EDQUOT    122
-#define ERESTART  85
-#define ENOTBLK   15
-#define ENAVAIL   119
+#define EREMOTEIO 121	// util.c
+#define EDQUOT    122	// util.c
+#define ERESTART  85	// util.c
+#define ENOTBLK   15	// sfx-nvme.c - could they just use libnvme's check for char device instead?
+#define ENAVAIL   119	// nvme.c - just used internally, define a custom, internal error code for this?
 
 
 /* ifaddrs.h compatibility */
@@ -72,21 +79,6 @@ struct ifaddrs {
 	void *ifa_data;
 };
 
-static inline void freeifaddrs(struct ifaddrs *ifa) { (void)ifa; }
-
-/* Platform-specific UUID generation using BCryptGenRandom */
-static inline int random_uuid(unsigned char *uuid, size_t len)
-{
-	NTSTATUS status;
-
-	status = BCryptGenRandom(NULL, uuid, (ULONG)len,
-				 BCRYPT_USE_SYSTEM_PREFERRED_RNG);
-	if (!BCRYPT_SUCCESS(status))
-		return -EIO;
-
-	return 0;
-}
-
 
 /* stdio.h POSIX extensions */
 
@@ -175,29 +167,6 @@ static inline FILE *open_memstream(char **ptr, size_t *sizeloc)
 }
 
 
-/* string.h POSIX extensions */
-
-/* strsep implementation for Windows */
-static inline char *strsep(char **stringp, const char *delim)
-{
-	char *start = *stringp;
-	char *p;
-
-	if (start == NULL)
-		return NULL;
-
-	p = strpbrk(start, delim);
-	if (p) {
-		*p = '\0';
-		*stringp = p + 1;
-	} else {
-		*stringp = NULL;
-	}
-
-	return start;
-}
-
-
 /* stdlib.h compatibility */
 
 /* Aligned memory allocation function, use platform_aligned_free to free. */
@@ -316,59 +285,6 @@ static inline int sigaction(int signum, const struct sigaction *act,
 }
 
 
-/* fnmatch.h POSIX compatibility - Only used by fabrics - consider removing */
-
-#define FNM_NOMATCH 1
-#define FNM_PATHNAME 0x01
-
-/* Basic fnmatch implementation for Windows:
- * - Supports '*' (match any sequence, including empty) and
- *   '?' (match any single character).
- * - Ignores flags for now; they are accepted for compatibility.
- * Returns 0 on match, FNM_NOMATCH on mismatch.
- */
-static inline int fnmatch(const char *pattern, const char *string, int flags)
-{
-	(void)flags; /* flags currently unused */
-
-	while (*pattern) {
-		if (*pattern == '*') {
-			/* Skip consecutive '*' characters */
-			while (*pattern == '*')
-				pattern++;
-
-			if (!*pattern)
-				/* Trailing '*' matches the rest of the string */
-				return 0;
-
-			/* Try to match the remainder of the pattern at each suffix of string */
-			while (*string) {
-				if (!fnmatch(pattern, string, flags))
-					return 0;
-				string++;
-			}
-			/* No match found for pattern suffix after '*' */
-			return FNM_NOMATCH;
-		} else if (*pattern == '?') {
-			/* '?' matches any single character, if present */
-			if (!*string)
-				return FNM_NOMATCH;
-			pattern++;
-			string++;
-		} else {
-			/* Literal character match */
-			if (*pattern != *string)
-				return FNM_NOMATCH;
-			pattern++;
-			string++;
-		}
-	}
-
-	/* At end of pattern: match only if we're also at end of string */
-	return *string ? FNM_NOMATCH : 0;
-}
-
-
 /* limits.h compatibility */
 
 #ifndef NAME_MAX
@@ -376,7 +292,10 @@ static inline int fnmatch(const char *pattern, const char *string, int flags)
 #endif
 
 
+/* sys/stat.h compatibility */
+
 /* Windows _mkdir doesn't take mode parameter */
+/* _mkdir is defined in <direct.h> */
 #define mkdir(path, mode) _mkdir(path)
 
 /* Platform-specific fstat wrapper for libnvme_fd_t */
diff --git a/logging.c b/logging.c
index f7de46ebc8..9f4691541c 100644
--- a/logging.c
+++ b/logging.c
@@ -6,7 +6,7 @@
 #include <stdint.h>
 #include <string.h>
 
-#include <platform/includes.h>
+#include <sys/time.h>
 
 #include <ccan/endian/endian.h>
 
diff --git a/nvme-print-json.c b/nvme-print-json.c
index f86e345128..66b64190b6 100644
--- a/nvme-print-json.c
+++ b/nvme-print-json.c
@@ -4,11 +4,16 @@
 #include <errno.h>
 #include <time.h>
 #include <sys/types.h>
-#include <platform/includes.h>
+
+#ifdef CONFIG_FABRICS
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#endif
 
 #include <ccan/compiler/compiler.h>
 
 #include <libnvme.h>
+
 #include "nvme-print.h"
 
 #include "util/json.h"
diff --git a/nvme-print-stdout.c b/nvme-print-stdout.c
index a71eb468ed..22bf8d1988 100644
--- a/nvme-print-stdout.c
+++ b/nvme-print-stdout.c
@@ -5,7 +5,14 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
-#include <platform/includes.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef CONFIG_FABRICS
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#endif
+
 #include <ccan/strset/strset.h>
 #include <ccan/htable/htable_type.h>
 #include <ccan/htable/htable.h>
diff --git a/util/table.c b/util/table.c
index f9fc82c1c0..60c9d61654 100644
--- a/util/table.c
+++ b/util/table.c
@@ -20,7 +20,7 @@
 #include <errno.h>
 #include <string.h>
 
-#include <platform/includes.h>
+#include <platform/includes.h>	/* for reallocarray */
 
 #include "table.h"
 

From 19c56ae98d0ff0f0244215670768d80cea78a9f9 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 12:12:42 -0700
Subject: [PATCH 61/83] Refactored stdlib.h compatiblity.

- Added nvme/stdlib.h
- Renamed platform_aligned_free to aligned_free
- Updated code to use new header
- Removed stdlib compatiblity from windows.h and linux.h
---
 libnvme/src/meson.build          |  1 +
 libnvme/src/nvme/lib.h           |  1 +
 libnvme/src/nvme/stdlib.h        | 57 ++++++++++++++++++++++++++++++++
 libnvme/src/nvme/util.c          |  5 +--
 libnvme/src/platform/linux.h     |  9 -----
 libnvme/src/platform/windows.h   | 34 -------------------
 nvme-rpmb.c                      |  2 +-
 plugins/memblaze/memblaze-nvme.c |  2 +-
 plugins/micron/micron-nvme.c     |  2 +-
 plugins/netapp/netapp-nvme.c     |  4 +--
 plugins/shannon/shannon-nvme.c   |  2 +-
 plugins/toshiba/toshiba-nvme.c   |  8 ++---
 plugins/zns/zns.c                |  6 ++--
 util/mem-windows.c               |  4 +--
 util/mem.c                       |  6 ++--
 util/table.c                     |  3 +-
 16 files changed, 81 insertions(+), 65 deletions(-)
 create mode 100644 libnvme/src/nvme/stdlib.h

diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index 526f74f37e..41cc3683a5 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -39,6 +39,7 @@ headers = [
     'nvme/linux.h',
     'nvme/nvme-cmds.h',
     'nvme/nvme-types.h',
+    'nvme/stdlib.h',
     'nvme/tree.h',
     'nvme/types.h',
     'nvme/util.h',
diff --git a/libnvme/src/nvme/lib.h b/libnvme/src/nvme/lib.h
index b61afe01e1..3c4fa338bb 100644
--- a/libnvme/src/nvme/lib.h
+++ b/libnvme/src/nvme/lib.h
@@ -12,6 +12,7 @@
 #include <stdio.h>
 
 #include <nvme/lib-types.h>
+#include <nvme/stdlib.h>
 
 #include <platform/includes.h> /* for libnvme_fd_t */
 
diff --git a/libnvme/src/nvme/stdlib.h b/libnvme/src/nvme/stdlib.h
new file mode 100644
index 0000000000..1267dc1535
--- /dev/null
+++ b/libnvme/src/nvme/stdlib.h
@@ -0,0 +1,57 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (c) 2026 Micron Technology, Inc.
+ *
+ * Cross-platform compatibility for stdlib.h.
+ * Provides functionality that may be missing on some platforms.
+ * Compatibility is not comprehensive. Only functionality required by
+ * nvme-cli and libnvme is included.
+ * 
+ * Authors: Broc Going <bgoing@micron.com>
+ *          Brandon Capener <bcapener@micron.com>
+ */
+
+#pragma once
+
+#include <stdlib.h>
+
+#if defined(_WIN32) || defined(_WIN64)
+
+#include <malloc.h>
+
+/* Aligned memory allocation function, use aligned_free to free. */
+static inline int posix_memalign(void **memptr, size_t alignment, size_t size)
+{
+	*memptr = _aligned_malloc(size, alignment);
+	return (*memptr == NULL) ? ENOMEM : 0;
+}
+
+/* reallocarray implementation for Windows */
+static inline void *reallocarray(void *ptr, size_t nmemb, size_t size)
+{
+	size_t total_size;
+
+	/* Check for multiplication overflow */
+	if (nmemb != 0 && size > SIZE_MAX / nmemb) {
+		errno = ENOMEM;
+		return NULL;
+	}
+
+	total_size = nmemb * size;
+	return realloc(ptr, total_size);
+}
+
+#endif
+
+/*
+ * Cross-platform compatible free for aligned memory allocations.
+ * Use when posix_memalign is used to allocate memory.
+ */
+static inline void aligned_free(void *p)
+{
+#if defined(_WIN32) || defined(_WIN64)
+	_aligned_free(p);
+#else
+	free(p);
+#endif
+}
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 13fc3ee506..0d876e3cad 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -12,7 +12,6 @@
 #include <malloc.h>
 #include <stdbool.h>
 #include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
@@ -27,6 +26,8 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
+#include <nvme/stdlib.h>
+
 #include <ccan/endian/endian.h>
 #include <ccan/minmax/minmax.h>
 
@@ -983,7 +984,7 @@ void *__libnvme_realloc(void *p, size_t len)
 
 void __libnvme_free(void *p)
 {
-	platform_aligned_free(p);
+	aligned_free(p);
 }
 
 #ifdef CONFIG_FABRICS
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index e1dde196b2..6c7163ae45 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -68,12 +68,3 @@ static inline int random_uuid(unsigned char *uuid, size_t len)
 	close(f);
 	return ret;
 }
-
-/*
- * Platform-specific free for aligned memory allocations.
- * Use when posix_memalign is used to allocate memory.
- */
-static inline void platform_aligned_free(void *p)
-{
-	free(p);
-}
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 3da5f002fd..f8aa519f11 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -167,40 +167,6 @@ static inline FILE *open_memstream(char **ptr, size_t *sizeloc)
 }
 
 
-/* stdlib.h compatibility */
-
-/* Aligned memory allocation function, use platform_aligned_free to free. */
-static inline int posix_memalign(void **memptr, size_t alignment, size_t size)
-{
-	*memptr = _aligned_malloc(size, alignment);
-	return (*memptr == NULL) ? ENOMEM : 0;
-}
-
-/*
- * Platform-specific free for aligned memory allocations.
- * Use when posix_memalign is used to allocate memory.
- */
-static inline void platform_aligned_free(void *p)
-{
-	_aligned_free(p);
-}
-
-/* reallocarray implementation for Windows */
-static inline void *reallocarray(void *ptr, size_t nmemb, size_t size)
-{
-	size_t total_size;
-
-	/* Check for multiplication overflow */
-	if (nmemb != 0 && size > SIZE_MAX / nmemb) {
-		errno = ENOMEM;
-		return NULL;
-	}
-
-	total_size = nmemb * size;
-	return realloc(ptr, total_size);
-}
-
-
 /* malloc.h compatibility*/
 
 static inline size_t malloc_usable_size(void *ptr)
diff --git a/nvme-rpmb.c b/nvme-rpmb.c
index 78279785e5..913a45720a 100644
--- a/nvme-rpmb.c
+++ b/nvme-rpmb.c
@@ -194,7 +194,7 @@ static int read_file(const char *file, unsigned char **data, unsigned int *len)
 		err = -errno;
 		fprintf(stderr, "Failed to read data from file"
 				" %s with %s\n", file, libnvme_strerror(errno));
-		platform_aligned_free(buf);
+		aligned_free(buf);
 		goto out;
 	}
 	*data = buf; 
diff --git a/plugins/memblaze/memblaze-nvme.c b/plugins/memblaze/memblaze-nvme.c
index 137b418d42..12e6a7685c 100644
--- a/plugins/memblaze/memblaze-nvme.c
+++ b/plugins/memblaze/memblaze-nvme.c
@@ -861,7 +861,7 @@ static int mb_selective_download(int argc, char **argv, struct command *acmd, st
 	}
 
 out_free:
-	platform_aligned_free(fw_buf);
+	aligned_free(fw_buf);
 out_close:
 	close(fw_fd);
 out:
diff --git a/plugins/micron/micron-nvme.c b/plugins/micron/micron-nvme.c
index ec20edaa0f..4c1278adb9 100644
--- a/plugins/micron/micron-nvme.c
+++ b/plugins/micron/micron-nvme.c
@@ -686,7 +686,7 @@ static int micron_selective_download(int argc, char **argv,
 	}
 
 out_free:
-	platform_aligned_free(fw_buf);
+	aligned_free(fw_buf);
 out:
 	close(fw_fd);
 	return err;
diff --git a/plugins/netapp/netapp-nvme.c b/plugins/netapp/netapp-nvme.c
index 107e2afe4a..7e3d50227b 100644
--- a/plugins/netapp/netapp-nvme.c
+++ b/plugins/netapp/netapp-nvme.c
@@ -831,12 +831,12 @@ static int netapp_ontapdevices_get_info(struct libnvme_transport_handle *hdl,
 		fprintf(stderr, "Unable to identify namespace descriptor for %s (%s)\n",
 			dev, err < 0 ? libnvme_strerror(-err) :
 			libnvme_status_to_string(err, false));
-		platform_aligned_free(nsdescs);
+		aligned_free(nsdescs);
 		return 0;
 	}
 
 	memcpy(item->uuid, nsdescs + sizeof(struct nvme_ns_id_desc), sizeof(item->uuid));
-	platform_aligned_free(nsdescs);
+	aligned_free(nsdescs);
 
 	err = nvme_get_ontap_c2_log(hdl, item->nsid, item->log_data, ONTAP_C2_LOG_SIZE);
 	if (err) {
diff --git a/plugins/shannon/shannon-nvme.c b/plugins/shannon/shannon-nvme.c
index 36a29501c8..4aa945c3b4 100644
--- a/plugins/shannon/shannon-nvme.c
+++ b/plugins/shannon/shannon-nvme.c
@@ -230,7 +230,7 @@ static int get_additional_feature(int argc, char **argv, struct command *acmd, s
 			cfg.cdw11, 0, buf, cfg.data_len, &result);
 	if (err > 0)
 		nvme_show_status(err);
-	platform_aligned_free(buf);
+	aligned_free(buf);
 	return err;
 }
 
diff --git a/plugins/toshiba/toshiba-nvme.c b/plugins/toshiba/toshiba-nvme.c
index fa41be1be3..76a9979d66 100644
--- a/plugins/toshiba/toshiba-nvme.c
+++ b/plugins/toshiba/toshiba-nvme.c
@@ -110,7 +110,7 @@ static int nvme_get_sct_status(struct libnvme_transport_handle *hdl, __u32 devic
 		}
 	}
 end:
-	platform_aligned_free(data);
+	aligned_free(data);
 	return err;
 }
 
@@ -134,7 +134,7 @@ static int nvme_sct_command_transfer_log(struct libnvme_transport_handle *hdl, b
 	memcpy(data + 2, &function_code, sizeof(function_code));
 
 	err = nvme_sct_op(hdl, OP_SCT_COMMAND_TRANSFER, DW10_SCT_COMMAND_TRANSFER, DW11_SCT_COMMAND_TRANSFER, data, data_len);
-	platform_aligned_free(data);
+	aligned_free(data);
 	return err;
 }
 
@@ -314,7 +314,7 @@ static int nvme_get_internal_log(struct libnvme_transport_handle *hdl,
 end:
 	if (o_fd >= 0)
 		close(o_fd);
-	platform_aligned_free(page_data);
+	aligned_free(page_data);
 	return err;
 }
 
@@ -411,7 +411,7 @@ static int nvme_get_vendor_log(struct libnvme_transport_handle *hdl,
 			d(log, log_len, 16, 1);
 	}
 end:
-	platform_aligned_free(log);
+	aligned_free(log);
 	return err;
 }
 
diff --git a/plugins/zns/zns.c b/plugins/zns/zns.c
index aa589f49a0..ff97b292d7 100644
--- a/plugins/zns/zns.c
+++ b/plugins/zns/zns.c
@@ -426,7 +426,7 @@ static int zone_mgmt_send(int argc, char **argv, struct command *acmd, struct pl
 	if (cfg.file)
 		close(ffd);
 free:
-	platform_aligned_free(buf);
+	aligned_free(buf);
 	return err;
 }
 
@@ -1076,12 +1076,12 @@ static int zone_append(int argc, char **argv, struct command *acmd, struct plugi
 		perror("zns zone-append");
 
 free_meta:
-	platform_aligned_free(mbuf);
+	aligned_free(mbuf);
 close_mfd:
 	if (cfg.metadata)
 		close(mfd);
 free_data:
-	platform_aligned_free(buf);
+	aligned_free(buf);
 close_dfd:
 	if (cfg.data)
 		close(dfd);
diff --git a/util/mem-windows.c b/util/mem-windows.c
index 6ce3a6f126..aeb5aeff0a 100644
--- a/util/mem-windows.c
+++ b/util/mem-windows.c
@@ -6,11 +6,11 @@
  * Authors: Brandon Capener <bcapener@micron.com>
  */
 
-#include <stdlib.h>
 #include <malloc.h>
 #include <string.h>
 
-#include "platform/includes.h"
+#include <nvme/stdlib.h>
+#include "platform/includes.h" /* unistd.h + compatibility */
 
 #include "mem.h"
 #include "common.h"
diff --git a/util/mem.c b/util/mem.c
index 6facb3ced6..e1763ec8f2 100644
--- a/util/mem.c
+++ b/util/mem.c
@@ -1,9 +1,9 @@
 /* SPDX-License-Identifier: GPL-2.0-or-later */
-#include <stdlib.h>
 #include <malloc.h>
 #include <string.h>
 
-#include <platform/includes.h>
+#include <nvme/stdlib.h>
+#include <platform/includes.h>	/* getpagesize, malloc_usable_size */
 
 #include "mem.h"
 
@@ -42,7 +42,7 @@ void *nvme_realloc(void *p, size_t len)
 
 void nvme_free(void *p)
 {
-	platform_aligned_free(p);
+	aligned_free(p);
 }
 
 #ifndef _WIN32
diff --git a/util/table.c b/util/table.c
index 60c9d61654..f3bf91ecb8 100644
--- a/util/table.c
+++ b/util/table.c
@@ -16,11 +16,10 @@
  */
 
 #include <stdio.h>
-#include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 
-#include <platform/includes.h>	/* for reallocarray */
+#include <nvme/stdlib.h>
 
 #include "table.h"
 

From 55b3711633cd554c2ecbc6b9704a96d678ce6d65 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 12:32:04 -0700
Subject: [PATCH 62/83] Refactored malloc.h and unistd.h compatibility.

- Added nvme/unistd.h and nvme/malloc.h
- Updated code to use new headers instead of platform/includes.h
- Removed malloc.h and unistd.h compatibility from windows.h
---
 libnvme/src/meson.build        |  2 ++
 libnvme/src/nvme/lib.h         |  1 +
 libnvme/src/nvme/malloc.h      | 26 ++++++++++++++++
 libnvme/src/nvme/stdlib.h      |  1 +
 libnvme/src/nvme/unistd.h      | 55 ++++++++++++++++++++++++++++++++++
 libnvme/src/nvme/util.c        |  2 +-
 libnvme/src/platform/windows.h | 44 ---------------------------
 util/mem-windows.c             |  4 ++-
 util/mem.c                     |  3 +-
 9 files changed, 91 insertions(+), 47 deletions(-)
 create mode 100644 libnvme/src/nvme/malloc.h
 create mode 100644 libnvme/src/nvme/unistd.h

diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index 41cc3683a5..962d5ae05c 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -37,11 +37,13 @@ headers = [
     'nvme/lib-types.h',
     'nvme/lib.h',
     'nvme/linux.h',
+    'nvme/malloc.h',
     'nvme/nvme-cmds.h',
     'nvme/nvme-types.h',
     'nvme/stdlib.h',
     'nvme/tree.h',
     'nvme/types.h',
+    'nvme/unistd.h',
     'nvme/util.h',
 ]
 
diff --git a/libnvme/src/nvme/lib.h b/libnvme/src/nvme/lib.h
index 3c4fa338bb..519d56bfc9 100644
--- a/libnvme/src/nvme/lib.h
+++ b/libnvme/src/nvme/lib.h
@@ -13,6 +13,7 @@
 
 #include <nvme/lib-types.h>
 #include <nvme/stdlib.h>
+#include <nvme/unistd.h>
 
 #include <platform/includes.h> /* for libnvme_fd_t */
 
diff --git a/libnvme/src/nvme/malloc.h b/libnvme/src/nvme/malloc.h
new file mode 100644
index 0000000000..4238058f70
--- /dev/null
+++ b/libnvme/src/nvme/malloc.h
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2026 Micron Technology, Inc.
+ *
+ * Cross-platform compatibility for malloc.h.
+ * Provides functionality that may be missing on some platforms.
+ * Compatibility is not comprehensive. Only functionality required by
+ * nvme-cli and libnvme is included.
+ * 
+ * Authors: Broc Going <bgoing@micron.com>
+ *          Brandon Capener <bcapener@micron.com>
+ */
+#pragma once
+
+#include <malloc.h>
+
+#ifdef _WIN32
+
+/* malloc_usable_size implementation for Windows */
+static inline size_t malloc_usable_size(void *ptr)
+{
+	return _msize(ptr);
+}
+
+#endif /* _WIN32 */
diff --git a/libnvme/src/nvme/stdlib.h b/libnvme/src/nvme/stdlib.h
index 1267dc1535..f3b3f39346 100644
--- a/libnvme/src/nvme/stdlib.h
+++ b/libnvme/src/nvme/stdlib.h
@@ -1,5 +1,6 @@
 /* SPDX-License-Identifier: LGPL-2.1-or-later */
 /*
+ * This file is part of libnvme.
  * Copyright (c) 2026 Micron Technology, Inc.
  *
  * Cross-platform compatibility for stdlib.h.
diff --git a/libnvme/src/nvme/unistd.h b/libnvme/src/nvme/unistd.h
new file mode 100644
index 0000000000..0ac7bd69de
--- /dev/null
+++ b/libnvme/src/nvme/unistd.h
@@ -0,0 +1,55 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2026 Micron Technology, Inc.
+ *
+ * Cross-platform compatibility for unistd.h.
+ * Provides functionality that may be missing on some platforms.
+ * Compatibility is not comprehensive. Only functionality required by
+ * nvme-cli and libnvme is included.
+ * 
+ * Authors: Broc Going <bgoing@micron.com>
+ *          Brandon Capener <bcapener@micron.com>
+ */
+#pragma once
+
+#include <unistd.h>
+
+#if defined(_WIN32) || defined(_WIN64)
+
+#include <io.h>
+#include <sysinfoapi.h>
+
+/* unistd.h POSIX compatibility */
+
+#define STDERR_FILENO 2
+#define STDOUT_FILENO 1
+#define STDIN_FILENO  0
+
+/* getpagesize implementation for Windows */
+static inline int getpagesize(void)
+{
+	SYSTEM_INFO si;
+
+	GetSystemInfo(&si);
+	return si.dwPageSize;
+}
+
+/*
+ * readlink stub - Windows doesn't have symbolic links in the same way
+ * NOTE: This is only used by micron-nvme.c, and can be removed once that
+ * has been refactored to not rely on Linux-specific sysfs paths.
+ */
+static inline ssize_t readlink(const char *path, char *buf, size_t bufsiz)
+{
+	errno = ENOTSUP;
+	return -1;
+}
+
+/* fsync implementation for Windows */
+static inline int fsync(int fd)
+{
+	return _commit(fd);
+}
+
+#endif
\ No newline at end of file
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 0d876e3cad..cbfd03f600 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -9,7 +9,6 @@
 
 #include <errno.h>
 #include <fcntl.h>
-#include <malloc.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
@@ -26,6 +25,7 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
+#include <nvme/malloc.h>
 #include <nvme/stdlib.h>
 
 #include <ccan/endian/endian.h>
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index f8aa519f11..1ed12d06c3 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -167,50 +167,6 @@ static inline FILE *open_memstream(char **ptr, size_t *sizeloc)
 }
 
 
-/* malloc.h compatibility*/
-
-static inline size_t malloc_usable_size(void *ptr)
-{
-	return _msize(ptr);
-}
-
-
-/* unistd.h POSIX compatibility */
-
-#define STDERR_FILENO 2
-#define STDOUT_FILENO 1
-#define STDIN_FILENO  0
-
-/* getpagesize implementation for Windows */
-static inline DWORD getpagesize(void)
-{
-	SYSTEM_INFO si;
-
-	GetSystemInfo(&si);
-	return si.dwPageSize;
-}
-
-/*
- * readlink stub - Windows doesn't have symbolic links in the same way
- * NOTE: This is only used by micron-nvme.c, and can be removed once that
- * has been refactored to not rely on Linux-specific sysfs paths.
- */
-static inline int readlink(const char *path, char *buf, size_t bufsiz)
-{
-	(void)path;
-	(void)buf;
-	(void)bufsiz;
-	errno = EINVAL;
-	return -1;
-}
-
-/* fsync implementation for Windows */
-static inline int fsync(int fd)
-{
-	return _commit(fd);
-}
-
-
 /* time.h POSIX compatibility */
 
 static inline struct tm *gmtime_r(const time_t *timep, struct tm *result)
diff --git a/util/mem-windows.c b/util/mem-windows.c
index aeb5aeff0a..ffeb0a355c 100644
--- a/util/mem-windows.c
+++ b/util/mem-windows.c
@@ -9,8 +9,10 @@
 #include <malloc.h>
 #include <string.h>
 
+#include <memoryapi.h>
+
 #include <nvme/stdlib.h>
-#include "platform/includes.h" /* unistd.h + compatibility */
+#include <nvme/unistd.h>
 
 #include "mem.h"
 #include "common.h"
diff --git a/util/mem.c b/util/mem.c
index e1763ec8f2..c7a447295d 100644
--- a/util/mem.c
+++ b/util/mem.c
@@ -2,8 +2,9 @@
 #include <malloc.h>
 #include <string.h>
 
+#include <nvme/malloc.h>
 #include <nvme/stdlib.h>
-#include <platform/includes.h>	/* getpagesize, malloc_usable_size */
+#include <nvme/unistd.h>
 
 #include "mem.h"
 

From f94f09268dbb57dcaf229fb1bc0274ed378205b1 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 12:46:44 -0700
Subject: [PATCH 63/83] Removed public libnvme_fstat.

Only lib-windows.c and ocp-nvme.c used libnvme_fstat, and ocp-nvme.c was easily refactored to use the existing libnvme_transport_handle_is_blkdev check instead.
- Refactored ocp-nvme.c to not need libnvme_fsat
- Removed public libnvme_fstat
- Made implementation in lib-windows.c private and renamed.
---
 libnvme/src/libnvme.ld         |   1 -
 libnvme/src/nvme/lib-windows.c | 152 ++++++++++++++++-----------------
 libnvme/src/platform/linux.h   |   6 --
 libnvme/src/platform/windows.h |   3 -
 plugins/ocp/ocp-nvme.c         |  12 +--
 5 files changed, 78 insertions(+), 96 deletions(-)

diff --git a/libnvme/src/libnvme.ld b/libnvme/src/libnvme.ld
index ab758fc138..6543b4b165 100644
--- a/libnvme/src/libnvme.ld
+++ b/libnvme/src/libnvme.ld
@@ -38,7 +38,6 @@ LIBNVME_3 {
 		libnvme_free_nbft;
 		libnvme_free_ns;
 		libnvme_free_subsystem;
-		libnvme_fstat;
 		libnvme_gen_dhchap_key;
 		libnvme_generate_hostid;
 		libnvme_generate_hostnqn;
diff --git a/libnvme/src/nvme/lib-windows.c b/libnvme/src/nvme/lib-windows.c
index cbf54628ca..d543a0136d 100644
--- a/libnvme/src/nvme/lib-windows.c
+++ b/libnvme/src/nvme/lib-windows.c
@@ -11,7 +11,80 @@
 #include "compiler-attributes.h"
 
 
-static int __nvme_transport_handle_open_direct(struct libnvme_transport_handle *hdl, const char *name)
+/* fstat implementation for device HANDLE */
+static int __libnvme_fd_fstat(libnvme_fd_t fd, struct stat *buf)
+{
+	BY_HANDLE_FILE_INFORMATION file_info;
+	ULARGE_INTEGER ull;
+	DWORD file_type;
+
+	if (!buf) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	/* Check for invalid handle */
+	if (fd == INVALID_HANDLE_VALUE || fd == NULL) {
+		errno = EBADF;
+		return -1;
+	}
+
+	/*
+	 * GetFileInformationByHandle() does not work for all device HANDLEs
+	 * (e.g. raw \\\\.\\PhysicalDriveN). For those, fall back to file type.
+	 */
+	if (!GetFileInformationByHandle(fd, &file_info)) {
+		file_type = GetFileType(fd);
+		if (file_type == FILE_TYPE_DISK || file_type == FILE_TYPE_CHAR) {
+			memset(buf, 0, sizeof(*buf));
+			buf->st_mode = S_IFBLK | 0600;
+			buf->st_nlink = 1;
+			return 0;
+		}
+
+		errno = EBADF;
+		return -1;
+	}
+
+	/* Fill in the stat structure */
+	memset(buf, 0, sizeof(*buf));
+
+	/* Convert Windows file attributes to stat mode */
+	if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DEVICE)
+		/* Windows device files should be marked as block devices */
+		/* This is used by libnvme_verify_chr to check device type */
+		buf->st_mode = S_IFBLK | 0600;
+	else if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+		buf->st_mode = S_IFDIR | 0755;
+	else
+		buf->st_mode = S_IFREG | 0644;
+
+	/* File size */
+	buf->st_size = (((off_t)file_info.nFileSizeHigh << 32)
+					| file_info.nFileSizeLow);
+
+	/* Number of hard links */
+	buf->st_nlink = file_info.nNumberOfLinks;
+
+	/* Convert FILETIME to time_t for timestamps */
+	/* Windows FILETIME is 100-nanosecond intervals since Jan 1, 1601 */
+	/* Unix time_t is seconds since Jan 1, 1970 */
+	ull.LowPart = file_info.ftLastWriteTime.dwLowDateTime;
+	ull.HighPart = file_info.ftLastWriteTime.dwHighDateTime;
+	buf->st_mtime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
+
+	ull.LowPart = file_info.ftLastAccessTime.dwLowDateTime;
+	ull.HighPart = file_info.ftLastAccessTime.dwHighDateTime;
+	buf->st_atime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
+
+	ull.LowPart = file_info.ftCreationTime.dwLowDateTime;
+	ull.HighPart = file_info.ftCreationTime.dwHighDateTime;
+	buf->st_ctime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
+
+	return 0;
+}
+
+static int __libnvme_transport_handle_open_direct(struct libnvme_transport_handle *hdl, const char *name)
 {
 	char device_path[MAX_PATH];
 	HANDLE h;
@@ -53,7 +126,7 @@ static int __nvme_transport_handle_open_direct(struct libnvme_transport_handle *
 
 	hdl->fd = h;
 
-	libnvme_fstat(hdl->fd, &hdl->stat);
+	__libnvme_fd_fstat(hdl->fd, &hdl->stat);
 
 	/* Windows doesn't distinguish 32/64-bit ioctl, assume 64-bit capable */
 	hdl->ioctl_admin64 = true;
@@ -96,7 +169,7 @@ __public int libnvme_open(struct libnvme_global_ctx *ctx, const char *name,
 		libnvme_close(hdl);
 		return -ENOTSUP;
 	} else {
-		ret = __nvme_transport_handle_open_direct(hdl, name);
+		ret = __libnvme_transport_handle_open_direct(hdl, name);
 	}
 
 	if (ret) {
@@ -132,76 +205,3 @@ __public void libnvme_close(struct libnvme_transport_handle *hdl)
 		break;
 	}
 }
-
-/* Platform-specific fstat wrapper for libnvme_fd_t */
-__public int libnvme_fstat(libnvme_fd_t fd, struct stat *buf)
-{
-	BY_HANDLE_FILE_INFORMATION file_info;
-	ULARGE_INTEGER ull;
-	DWORD file_type;
-
-	if (!buf) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	/* Check for invalid handle */
-	if (fd == INVALID_HANDLE_VALUE || fd == NULL) {
-		errno = EBADF;
-		return -1;
-	}
-
-	/*
-	 * GetFileInformationByHandle() does not work for all device HANDLEs
-	 * (e.g. raw \\\\.\\PhysicalDriveN). For those, fall back to file type.
-	 */
-	if (!GetFileInformationByHandle(fd, &file_info)) {
-		file_type = GetFileType(fd);
-		if (file_type == FILE_TYPE_DISK || file_type == FILE_TYPE_CHAR) {
-			memset(buf, 0, sizeof(*buf));
-			buf->st_mode = S_IFBLK | 0600;
-			buf->st_nlink = 1;
-			return 0;
-		}
-
-		errno = EBADF;
-		return -1;
-	}
-
-	/* Fill in the stat structure */
-	memset(buf, 0, sizeof(*buf));
-
-	/* Convert Windows file attributes to stat mode */
-	if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DEVICE)
-		/* Windows device files should be marked as block devices */
-		/* This is used by libnvme_verify_chr to check device type */
-		buf->st_mode = S_IFBLK | 0600;
-	else if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
-		buf->st_mode = S_IFDIR | 0755;
-	else
-		buf->st_mode = S_IFREG | 0644;
-
-	/* File size */
-	buf->st_size = (((off_t)file_info.nFileSizeHigh << 32)
-					| file_info.nFileSizeLow);
-
-	/* Number of hard links */
-	buf->st_nlink = file_info.nNumberOfLinks;
-
-	/* Convert FILETIME to time_t for timestamps */
-	/* Windows FILETIME is 100-nanosecond intervals since Jan 1, 1601 */
-	/* Unix time_t is seconds since Jan 1, 1970 */
-	ull.LowPart = file_info.ftLastWriteTime.dwLowDateTime;
-	ull.HighPart = file_info.ftLastWriteTime.dwHighDateTime;
-	buf->st_mtime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
-
-	ull.LowPart = file_info.ftLastAccessTime.dwLowDateTime;
-	ull.HighPart = file_info.ftLastAccessTime.dwHighDateTime;
-	buf->st_atime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
-
-	ull.LowPart = file_info.ftCreationTime.dwLowDateTime;
-	ull.HighPart = file_info.ftCreationTime.dwHighDateTime;
-	buf->st_ctime = (time_t)((ull.QuadPart / 10000000ULL) - 11644473600ULL);
-
-	return 0;
-}
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index 6c7163ae45..711a0df367 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -40,12 +40,6 @@ typedef int libnvme_fd_t;
 #define O_BINARY 0
 #endif
 
-/* Platform-specific fstat wrapper for libnvme_fd_t */
-static inline int libnvme_fstat(libnvme_fd_t fd, struct stat *buf)
-{
-	return fstat(fd, buf);
-}
-
 /* Platform initialization - no-op on Linux */
 static inline void libnvme_init(void) {}
 
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 1ed12d06c3..9d65550347 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -220,9 +220,6 @@ static inline int sigaction(int signum, const struct sigaction *act,
 /* _mkdir is defined in <direct.h> */
 #define mkdir(path, mode) _mkdir(path)
 
-/* Platform-specific fstat wrapper for libnvme_fd_t */
-int libnvme_fstat(libnvme_fd_t fd, struct stat *buf);
-
 
 /* mman.h memory mapping stubs - not supported on Windows */
 
diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index 797d4022cf..72a04d4ddc 100644
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -349,11 +349,7 @@ int ocp_set_latency_monitor_feature(int argc, char **argv, struct command *acmd,
 	if (err)
 		return err;
 
-	err = libnvme_fstat(libnvme_transport_handle_get_fd(hdl), &nvme_stat);
-	if (err < 0)
-		return err;
-
-	if (S_ISBLK(nvme_stat.st_mode)) {
+	if (libnvme_transport_handle_is_blkdev(hdl)) {
 		err = libnvme_get_nsid(hdl, &nsid);
 		if (err < 0) {
 			perror("invalid-namespace-id");
@@ -1463,11 +1459,7 @@ static int ocp_telemetry_log(int argc, char **argv, struct command *acmd, struct
 	if (opt.telemetry_type == 0)
 		opt.telemetry_type = "host";
 
-	err = libnvme_fstat(libnvme_transport_handle_get_fd(hdl), &nvme_stat);
-	if (err < 0)
-		return err;
-
-	if (S_ISBLK(nvme_stat.st_mode)) {
+	if (libnvme_transport_handle_is_blkdev(hdl)) {
 		err = libnvme_get_nsid(hdl, &nsid);
 		if (err < 0)
 			return err;

From 831badcbdcb7ea4f51ad3eb388054a556a890ad2 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 13:17:57 -0700
Subject: [PATCH 64/83] Refactored mmap compatibility.

- Added HAVE_MMAP definition.
- Made mmap usage dependent on HAVE_MMAP.
- Removed mmap compatibility from platform.h
---
 libnvme/src/platform/windows.h | 22 ----------------------
 meson.build                    |  2 ++
 nvme.c                         | 22 +++++++++++++++++-----
 3 files changed, 19 insertions(+), 27 deletions(-)

diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 9d65550347..b2f94f07cd 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -221,28 +221,6 @@ static inline int sigaction(int signum, const struct sigaction *act,
 #define mkdir(path, mode) _mkdir(path)
 
 
-/* mman.h memory mapping stubs - not supported on Windows */
-
-#define PROT_READ  0x1
-#define PROT_WRITE 0x2
-#define MAP_SHARED 0x01
-#define MAP_FAILED ((void *) -1)
-
-static inline void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
-{
-	(void)addr; (void)length; (void)prot; (void)flags; (void)fd; (void)offset;
-	errno = ENOSYS;
-	return MAP_FAILED;
-}
-
-static inline int munmap(void *addr, size_t length)
-{
-	(void)addr; (void)length;
-	errno = ENOSYS;
-	return -1;
-}
-
-
 /* dlfcn.h compatibility */
 
 static inline void *dlsym(void *handle, const char *symbol)
diff --git a/meson.build b/meson.build
index ca885b78d6..7e0b1482ae 100644
--- a/meson.build
+++ b/meson.build
@@ -427,6 +427,8 @@ conf.set(
 
 conf.set('NVME_HAVE_SENDFILE', cc.has_function('sendfile'))
 
+conf.set('HAVE_MMAP', cc.has_function('mmap'))
+
 project_config_file = 'nvme-config.h'
 nvme_config_h = configure_file(output: project_config_file, configuration: conf)
 config_dep = declare_dependency(
diff --git a/nvme.c b/nvme.c
index fc1d44f542..0a91481f6d 100644
--- a/nvme.c
+++ b/nvme.c
@@ -253,6 +253,7 @@ struct nvme_args nvme_args = {
 };
 
 static void *mmap_registers(struct libnvme_transport_handle *hdl, bool writable);
+static int munmap_registers(void *addr);
 
 static OPT_VALS(feature_name) = {
 	VAL_BYTE("arbitration", NVME_FEAT_FID_ARBITRATION),
@@ -1103,7 +1104,7 @@ static int get_effects_log(int argc, char **argv, struct command *acmd, struct p
 
 		if (bar) {
 			cap = mmio_read64(bar + NVME_REG_CAP);
-			munmap(bar, getpagesize());
+			munmap_registers(bar);
 		} else {
 			nvme_init_get_property(&cmd, NVME_REG_CAP);
 			err = libnvme_submit_admin_passthru(hdl, &cmd);
@@ -5798,8 +5799,9 @@ static int nvme_get_properties(struct libnvme_transport_handle *hdl, void **pbar
 
 static void *mmap_registers(struct libnvme_transport_handle *hdl, bool writable)
 {
+	void *membase = NULL;
+#ifdef HAVE_MMAP
 	char path[512];
-	void *membase;
 	int fd;
 	int prot = PROT_READ;
 
@@ -5828,9 +5830,19 @@ static void *mmap_registers(struct libnvme_transport_handle *hdl, bool writable)
 	}
 
 	close(fd);
+#endif
 	return membase;
 }
 
+static int munmap_registers(void *addr)
+{
+#ifdef HAVE_MMAP
+	return munmap(addr, getpagesize());
+#else
+	return 0;
+#endif
+}
+
 static int show_registers(int argc, char **argv, struct command *acmd, struct plugin *plugin)
 {
 	const char *desc = "Reads and shows the defined NVMe controller registers\n"
@@ -5882,7 +5894,7 @@ static int show_registers(int argc, char **argv, struct command *acmd, struct pl
 	if (cfg.fabrics)
 		free(bar);
 	else
-		munmap(bar, getpagesize());
+		munmap_registers(bar);
 
 	return 0;
 }
@@ -6167,7 +6179,7 @@ static int get_register(int argc, char **argv, struct command *acmd, struct plug
 	if (fabrics)
 		free(bar);
 	else
-		munmap(bar, getpagesize());
+		munmap_registers(bar);
 
 	return err;
 }
@@ -6451,7 +6463,7 @@ static int set_register(int argc, char **argv, struct command *acmd, struct plug
 		err = set_register_names(hdl, bar, opts, &cfg);
 
 	if (bar)
-		munmap(bar, getpagesize());
+		munmap_registers(bar);
 
 	return err;
 }

From eae0756822e43c2eda0314bbb7bc23b9f4daa554 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 13:21:55 -0700
Subject: [PATCH 65/83] Moved NAME_MAX definition to micron-nvme.c.

NAME_MAX is only used in micron-nvme.c.  Moved there instead of adding global compatibility support.
---
 libnvme/src/platform/windows.h | 7 -------
 plugins/micron/micron-nvme.c   | 4 ++++
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index b2f94f07cd..2f9d86b09a 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -207,13 +207,6 @@ static inline int sigaction(int signum, const struct sigaction *act,
 }
 
 
-/* limits.h compatibility */
-
-#ifndef NAME_MAX
-#define NAME_MAX 260
-#endif
-
-
 /* sys/stat.h compatibility */
 
 /* Windows _mkdir doesn't take mode parameter */
diff --git a/plugins/micron/micron-nvme.c b/plugins/micron/micron-nvme.c
index 4c1278adb9..b0295faace 100644
--- a/plugins/micron/micron-nvme.c
+++ b/plugins/micron/micron-nvme.c
@@ -66,6 +66,10 @@
 #endif
 #define SensorCount 8
 
+#ifndef NAME_MAX
+#define NAME_MAX 260
+#endif
+
 /* Plugin version major_number.minor_number.patch */
 static const char *__version_major = "2";
 static const char *__version_minor = "0";

From 38241690b35f2be86f4d5890445166372c383194 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 13:40:35 -0700
Subject: [PATCH 66/83] Refactored stdio compatibiity

Moved stdio compatibility into nvme/stdio.h and removed it from platform/windows.h
---
 libnvme/src/nvme/log.c         |   2 +
 libnvme/src/nvme/stdio.h       | 112 +++++++++++++++++++++++++++++++++
 libnvme/src/platform/windows.h |  87 -------------------------
 nvme-models.c                  |   3 +
 nvme-print-stdout.c            |   2 +
 5 files changed, 119 insertions(+), 87 deletions(-)
 create mode 100644 libnvme/src/nvme/stdio.h

diff --git a/libnvme/src/nvme/log.c b/libnvme/src/nvme/log.c
index a436e005f7..6074253aa2 100644
--- a/libnvme/src/nvme/log.c
+++ b/libnvme/src/nvme/log.c
@@ -14,6 +14,8 @@
 #include <time.h>
 #include <unistd.h>
 
+#include <nvme/stdio.h>
+
 #include <libnvme.h>
 
 #include "cleanup.h"
diff --git a/libnvme/src/nvme/stdio.h b/libnvme/src/nvme/stdio.h
new file mode 100644
index 0000000000..f5a4d72c8e
--- /dev/null
+++ b/libnvme/src/nvme/stdio.h
@@ -0,0 +1,112 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2026 Micron Technology, Inc.
+ *
+ * Cross-platform compatibility for stdio.h.
+ * Provides functionality that may be missing on some platforms.
+ * Compatibility is not comprehensive. Only functionality required by
+ * nvme-cli and libnvme is included.
+ *
+ * Authors: Brandon Capener <bcapener@micron.com>
+ *          Brandon Busacker <bbusacker@micron.com>
+*/
+
+#pragma once
+
+#include <stdio.h>
+
+#if defined(_WIN32) || defined(_WIN64)
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* stdio.h POSIX extensions */
+
+/* dprintf implementation for Windows */
+static inline int dprintf(int fd, const char *format, ...)
+{
+	va_list args;
+	char buffer[4096];
+	int result;
+
+	va_start(args, format);
+	result = vsnprintf(buffer, sizeof(buffer), format, args);
+	va_end(args);
+	if (fd == STDERR_FILENO)
+		fputs(buffer, stderr);
+	else if (fd == STDOUT_FILENO)
+		fputs(buffer, stdout);
+	return result;
+}
+
+/* getline implementation for Windows */
+static inline ssize_t getline(char **lineptr, size_t *n, FILE *stream)
+{
+	char *bufptr = NULL;
+	char *p = bufptr;
+	size_t size;
+	int c;
+
+	if (lineptr == NULL || stream == NULL || n == NULL) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	bufptr = *lineptr;
+	size = *n;
+
+	c = fgetc(stream);
+	if (c == EOF)
+		return -1;
+
+	if (bufptr == NULL) {
+		bufptr = (char *)malloc(128);
+		if (bufptr == NULL) {
+			errno = ENOMEM;
+			return -1;
+		}
+		size = 128;
+	}
+
+	p = bufptr;
+	while (c != EOF) {
+		if ((size_t)(p - bufptr) + 1 >= size) {
+			size_t pos = (size_t)(p - bufptr);
+
+			size = size + 128;
+			bufptr = (char *)realloc(bufptr, size);
+			if (bufptr == NULL) {
+				errno = ENOMEM;
+				return -1;
+			}
+			p = bufptr + pos;
+		}
+		*p++ = c;
+		if (c == '\n')
+			break;
+		c = fgetc(stream);
+	}
+
+	*p = '\0';
+	*lineptr = bufptr;
+	*n = size;
+
+	return p - bufptr;
+}
+
+/* open_memstream workaround for Windows - returns a temporary file instead */
+static inline FILE *open_memstream(char **ptr, size_t *sizeloc)
+{
+	FILE *f = tmpfile();
+
+	if (ptr)
+		*ptr = NULL;
+	if (sizeloc)
+		*sizeloc = 0;
+	return f;
+}
+
+#endif
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 2f9d86b09a..6f68ba350f 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -80,93 +80,6 @@ struct ifaddrs {
 };
 
 
-/* stdio.h POSIX extensions */
-
-/* dprintf implementation for Windows */
-static inline int dprintf(int fd, const char *format, ...)
-{
-	va_list args;
-	char buffer[4096];
-	int result;
-
-	va_start(args, format);
-	result = vsnprintf(buffer, sizeof(buffer), format, args);
-	va_end(args);
-	if (fd == STDERR_FILENO)
-		fputs(buffer, stderr);
-	else if (fd == STDOUT_FILENO)
-		fputs(buffer, stdout);
-	return result;
-}
-
-/* getline implementation for Windows */
-static inline ssize_t getline(char **lineptr, size_t *n, FILE *stream)
-{
-	char *bufptr = NULL;
-	char *p = bufptr;
-	size_t size;
-	int c;
-
-	if (lineptr == NULL || stream == NULL || n == NULL) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	bufptr = *lineptr;
-	size = *n;
-
-	c = fgetc(stream);
-	if (c == EOF)
-		return -1;
-
-	if (bufptr == NULL) {
-		bufptr = (char *)malloc(128);
-		if (bufptr == NULL) {
-			errno = ENOMEM;
-			return -1;
-		}
-		size = 128;
-	}
-
-	p = bufptr;
-	while (c != EOF) {
-		if ((size_t)(p - bufptr) + 1 >= size) {
-			size_t pos = (size_t)(p - bufptr);
-
-			size = size + 128;
-			bufptr = (char *)realloc(bufptr, size);
-			if (bufptr == NULL) {
-				errno = ENOMEM;
-				return -1;
-			}
-			p = bufptr + pos;
-		}
-		*p++ = c;
-		if (c == '\n')
-			break;
-		c = fgetc(stream);
-	}
-
-	*p = '\0';
-	*lineptr = bufptr;
-	*n = size;
-
-	return p - bufptr;
-}
-
-/* open_memstream workaround for Windows - returns a temporary file instead */
-static inline FILE *open_memstream(char **ptr, size_t *sizeloc)
-{
-	FILE *f = tmpfile();
-
-	if (ptr)
-		*ptr = NULL;
-	if (sizeloc)
-		*sizeloc = 0;
-	return f;
-}
-
-
 /* time.h POSIX compatibility */
 
 static inline struct tm *gmtime_r(const time_t *timep, struct tm *result)
diff --git a/nvme-models.c b/nvme-models.c
index 4a94906deb..6dbdf6fc9c 100644
--- a/nvme-models.c
+++ b/nvme-models.c
@@ -9,6 +9,9 @@
 
 #include <sys/stat.h>
 #include <sys/types.h>
+
+#include <nvme/stdio.h>
+
 #include "nvme-models.h"
 #include "nvme.h"
 
diff --git a/nvme-print-stdout.c b/nvme-print-stdout.c
index 22bf8d1988..837f22e1dc 100644
--- a/nvme-print-stdout.c
+++ b/nvme-print-stdout.c
@@ -13,6 +13,8 @@
 #include <arpa/inet.h>
 #endif
 
+#include <nvme/stdio.h>
+
 #include <ccan/strset/strset.h>
 #include <ccan/htable/htable_type.h>
 #include <ccan/htable/htable.h>

From f6ed5bf001dc38fcf08b9967837e67e023c3f3d8 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 14:18:57 -0700
Subject: [PATCH 67/83] Refactored errno and ifaddrs compatibility

- Moved missing error code definitions to util.c where they are used.
- Refactored ENAVAIL usage in nvme.c to use a custom, local error code definition, since it was being used as an internal flag anyway.
- Removed ifaddrs struct (not needed).
- Cleaned up build warnings in ocp-nvme.c
---
 libnvme/src/nvme/util.c        |  9 +++++++++
 libnvme/src/platform/windows.h | 22 ----------------------
 nvme.c                         | 13 ++++++++-----
 plugins/ocp/ocp-nvme.c         |  2 --
 4 files changed, 17 insertions(+), 29 deletions(-)

diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index cbfd03f600..c0cb7d662a 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -9,8 +9,10 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#include <malloc.h>
 #include <stdbool.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
@@ -44,6 +46,13 @@
 #define LINE_MAX 2048
 #endif
 
+/* Windows errno.h doesn't define these*/
+#if defined (_WIN32) || defined(_WIN64)
+#define EREMOTEIO 121
+#define EDQUOT    122
+#define ERESTART  85
+#endif
+
 /* Source Code Control System, query version of binary with 'what' */
 const char sccsid[] = "@(#)libnvme " GIT_VERSION;
 
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 6f68ba350f..af6bcd9d2f 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -58,28 +58,6 @@ static inline int random_uuid(unsigned char *uuid, size_t len)
 }
 
 
-/* errno.h compatibility */
-
-#define EREMOTEIO 121	// util.c
-#define EDQUOT    122	// util.c
-#define ERESTART  85	// util.c
-#define ENOTBLK   15	// sfx-nvme.c - could they just use libnvme's check for char device instead?
-#define ENAVAIL   119	// nvme.c - just used internally, define a custom, internal error code for this?
-
-
-/* ifaddrs.h compatibility */
-
-struct ifaddrs {
-	struct ifaddrs *ifa_next;
-	char *ifa_name;
-	unsigned int ifa_flags;
-	struct sockaddr *ifa_addr;
-	struct sockaddr *ifa_netmask;
-	struct sockaddr *ifa_broadaddr;
-	void *ifa_data;
-};
-
-
 /* time.h POSIX compatibility */
 
 static inline struct tm *gmtime_r(const time_t *timep, struct tm *result)
diff --git a/nvme.c b/nvme.c
index 0a91481f6d..7e08d952c4 100644
--- a/nvme.c
+++ b/nvme.c
@@ -7353,6 +7353,9 @@ static void get_pif_sts(struct nvme_id_ns *ns, struct nvme_nvm_id_ns *nvm_ns,
 		*pif = (elbaf & NVME_NVM_ELBAF_QPIF_MASK) >> 9;
 }
 
+
+#define ERR_IGNORE_INVALID_FIELD 0x2000 /* invalid field error - ignore */
+
 static int get_pi_info(struct libnvme_transport_handle *hdl,
 		__u32 nsid, __u8 prinfo, __u64 ilbrt, __u64 lbst,
 		unsigned int *logical_block_size, __u16 *metadata_size)
@@ -7394,7 +7397,7 @@ static int get_pi_info(struct libnvme_transport_handle *hdl,
 		 * Keep the I/O commands behavior same as before.
 		 * Since the error returned by drives unsupported.
 		 */
-		return -ENAVAIL;
+		return ERR_IGNORE_INVALID_FIELD;
 
 	pi_size = (pif == NVME_NVM_PIF_16B_GUARD) ? 8 : 16;
 	if (NVME_FLBAS_META_EXT(ns->flbas)) {
@@ -7449,7 +7452,7 @@ static int init_pi_tags(struct libnvme_transport_handle *hdl,
 		 * Keep the I/O commands behavior same as before.
 		 * Since the error returned by drives unsupported.
 		 */
-		return -ENAVAIL;
+		return ERR_IGNORE_INVALID_FIELD;
 
 	if (invalid_tags(lbst, ilbrt, sts, pif))
 		return -EINVAL;
@@ -7565,7 +7568,7 @@ static int write_zeroes(int argc, char **argv,
 
 	err = init_pi_tags(hdl, &cmd, cfg.nsid, cfg.ilbrt, cfg.lbst, cfg.lbat,
 			   cfg.lbatm);
-	if (err && err != -ENAVAIL)
+	if (err && err != ERR_IGNORE_INVALID_FIELD)
 		return err;
 
 	err = libnvme_submit_io_passthru(hdl, &cmd);
@@ -7908,7 +7911,7 @@ static int copy_cmd(int argc, char **argv, struct command *acmd, struct plugin *
 		       cfg.fua, cfg.lr, 0, cfg.dspec, copy->f0);
 	err = init_pi_tags(hdl, &cmd, cfg.nsid, cfg.ilbrt, cfg.lbst, cfg.lbat,
 		cfg.lbatm);
-	if (err != 0 && err != -ENAVAIL)
+	if (err != 0 && err != ERR_IGNORE_INVALID_FIELD)
 		return err;
 	err = libnvme_submit_io_passthru(hdl, &cmd);
 	if (err) {
@@ -8747,7 +8750,7 @@ static int verify_cmd(int argc, char **argv, struct command *acmd, struct plugin
 		cfg.block_count, control, 0, NULL, 0, NULL, 0);
 	err = init_pi_tags(hdl, &cmd, cfg.nsid, cfg.ilbrt, cfg.lbst,
 		cfg.lbat, cfg.lbatm);
-	if (err != 0 && err != -ENAVAIL)
+	if (err != 0 && err != ERR_IGNORE_INVALID_FIELD)
 		return err;
 	err = libnvme_submit_io_passthru(hdl, &cmd);
 	if (err) {
diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index 72a04d4ddc..bf93ac6222 100644
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -292,7 +292,6 @@ int ocp_set_latency_monitor_feature(int argc, char **argv, struct command *acmd,
 	__u64 result;
 	struct feature_latency_monitor buf = { 0 };
 	__u32  nsid = NVME_NSID_ALL;
-	struct stat nvme_stat;
 	struct nvme_id_ctrl ctrl;
 
 	const char *desc = "Set Latency Monitor feature.";
@@ -1433,7 +1432,6 @@ static int ocp_telemetry_log(int argc, char **argv, struct command *acmd, struct
 	__cleanup_nvme_transport_handle struct libnvme_transport_handle *hdl = NULL;
 	int err = 0;
 	__u32  nsid = NVME_NSID_ALL;
-	struct stat nvme_stat;
 	char sn[21] = {0,};
 	struct nvme_id_ctrl ctrl;
 	bool is_support_telemetry_controller;

From 8c0327953ca3b8dfd386ef7d7ea401e774f1fa60 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 15:03:50 -0700
Subject: [PATCH 68/83] Moved random_uuid helper into util.c

Only used in one place.  Define there.
---
 libnvme/src/nvme/util.c        | 41 ++++++++++++++++++++++++++++++++++
 libnvme/src/platform/linux.h   | 20 -----------------
 libnvme/src/platform/windows.h | 13 -----------
 3 files changed, 41 insertions(+), 33 deletions(-)

diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index c0cb7d662a..4508838413 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -770,6 +770,47 @@ __public int libnvme_uuid_from_string(const char *str, unsigned char uuid[NVME_U
 
 }
 
+#if defined(_WIN32) || defined(_WIN64)
+
+#include <bcrypt.h>
+
+/* Windows-specific UUID generation using BCryptGenRandom */
+static inline int random_uuid(unsigned char *uuid, size_t len)
+{
+	NTSTATUS status;
+
+	status = BCryptGenRandom(NULL, uuid, (ULONG)len,
+				 BCRYPT_USE_SYSTEM_PREFERRED_RNG);
+	if (!BCRYPT_SUCCESS(status))
+		return -EIO;
+
+	return 0;
+}
+
+#else
+
+/* Linux-specific UUID generation using /dev/urandom */
+static inline int random_uuid(unsigned char *uuid, size_t len)
+{
+	int f, ret = 0;
+	ssize_t n;
+
+	f = open("/dev/urandom", O_RDONLY);
+	if (f < 0)
+		return -errno;
+
+	n = read(f, uuid, len);
+	if (n < 0)
+		ret = -errno;
+	else if ((size_t)n != len)
+		ret = -EIO;
+
+	close(f);
+	return ret;
+}
+
+#endif
+
 __public int libnvme_random_uuid(unsigned char uuid[NVME_UUID_LEN])
 {
 	int ret;
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index 711a0df367..e6c6612e10 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -42,23 +42,3 @@ typedef int libnvme_fd_t;
 
 /* Platform initialization - no-op on Linux */
 static inline void libnvme_init(void) {}
-
-/* Platform-specific UUID generation using /dev/urandom */
-static inline int random_uuid(unsigned char *uuid, size_t len)
-{
-	int f, ret = 0;
-	ssize_t n;
-
-	f = open("/dev/urandom", O_RDONLY);
-	if (f < 0)
-		return -errno;
-
-	n = read(f, uuid, len);
-	if (n < 0)
-		ret = -errno;
-	else if ((size_t)n != len)
-		ret = -EIO;
-
-	close(f);
-	return ret;
-}
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index af6bcd9d2f..b5d3e0fd17 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -44,19 +44,6 @@ static inline void libnvme_init(void)
 	_setmode(_fileno(stderr), O_BINARY);
 }
 
-/* Platform-specific UUID generation using BCryptGenRandom */
-static inline int random_uuid(unsigned char *uuid, size_t len)
-{
-	NTSTATUS status;
-
-	status = BCryptGenRandom(NULL, uuid, (ULONG)len,
-				 BCRYPT_USE_SYSTEM_PREFERRED_RNG);
-	if (!BCRYPT_SUCCESS(status))
-		return -EIO;
-
-	return 0;
-}
-
 
 /* time.h POSIX compatibility */
 

From ca9603fb4cd4f4d9151f056afb0e78613e0f9068 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 15:07:37 -0700
Subject: [PATCH 69/83] Cleaned up unistd.h

---
 libnvme/src/nvme/unistd.h | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/libnvme/src/nvme/unistd.h b/libnvme/src/nvme/unistd.h
index 0ac7bd69de..47e8d28b38 100644
--- a/libnvme/src/nvme/unistd.h
+++ b/libnvme/src/nvme/unistd.h
@@ -7,9 +7,9 @@
  * Provides functionality that may be missing on some platforms.
  * Compatibility is not comprehensive. Only functionality required by
  * nvme-cli and libnvme is included.
- * 
- * Authors: Broc Going <bgoing@micron.com>
- *          Brandon Capener <bcapener@micron.com>
+ *
+ * Authors: Brandon Busacker <bbusacker@micron.com>
+ *          Broc Going <bgoing@micron.com>
  */
 #pragma once
 
@@ -17,15 +17,10 @@
 
 #if defined(_WIN32) || defined(_WIN64)
 
-#include <io.h>
 #include <sysinfoapi.h>
 
 /* unistd.h POSIX compatibility */
 
-#define STDERR_FILENO 2
-#define STDOUT_FILENO 1
-#define STDIN_FILENO  0
-
 /* getpagesize implementation for Windows */
 static inline int getpagesize(void)
 {

From f3b09dd71b7c19480bb7d741e4e5aa1080657ec0 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 15:08:51 -0700
Subject: [PATCH 70/83] Enabled ucrt64 gmtime_r implementation

Defined _POSIX_THREAD_SAFE_FUNCTIONS to enable built-in gmtime_r implementation, and removed windows.h implementation.
---
 libnvme/src/platform/windows.h | 10 ----------
 meson.build                    |  1 +
 2 files changed, 1 insertion(+), 10 deletions(-)

diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index b5d3e0fd17..242409a396 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -45,16 +45,6 @@ static inline void libnvme_init(void)
 }
 
 
-/* time.h POSIX compatibility */
-
-static inline struct tm *gmtime_r(const time_t *timep, struct tm *result)
-{
-	if (gmtime_s(result, timep) == 0)
-		return result;
-	return NULL;
-}
-
-
 /* signal.h POSIX compatibility - Windows doesn't have sigaction */
 
 struct sigaction {
diff --git a/meson.build b/meson.build
index 7e0b1482ae..4de6f0ac40 100644
--- a/meson.build
+++ b/meson.build
@@ -177,6 +177,7 @@ if host_system == 'windows'
     add_project_arguments(
         [
             '-DHAVE_GLIBC_IOCTL=0',
+            '-D_POSIX_THREAD_SAFE_FUNCTIONS',
         ],
         language : 'c',
     )

From 9e1ff30836d521c43f404056ed53ca7560dc55bd Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 15:31:23 -0700
Subject: [PATCH 71/83] Removed libnvme-wrap.c from build.

libnvme-wrap.c isn't actually used for anything.  Instead of adding dlsym support for an unused file, just excluding from the Windows build.
---
 libnvme-wrap.c                 | 2 --
 libnvme/src/platform/windows.h | 8 --------
 meson.build                    | 2 +-
 3 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/libnvme-wrap.c b/libnvme-wrap.c
index b8918f26e6..70ce5cb443 100644
--- a/libnvme-wrap.c
+++ b/libnvme-wrap.c
@@ -5,9 +5,7 @@
  * Copyright (c) 2022 Daniel Wagner, SUSE
  */
 
-#ifndef _WIN32
 #include <dlfcn.h>
-#endif
 #include <errno.h>
 #include <stdlib.h>
 
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 242409a396..e9af339be8 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -80,11 +80,3 @@ static inline int sigaction(int signum, const struct sigaction *act,
 /* Windows _mkdir doesn't take mode parameter */
 /* _mkdir is defined in <direct.h> */
 #define mkdir(path, mode) _mkdir(path)
-
-
-/* dlfcn.h compatibility */
-
-static inline void *dlsym(void *handle, const char *symbol)
-{
-	return (void *)GetProcAddress((HMODULE)handle, symbol);
-}
diff --git a/meson.build b/meson.build
index 4de6f0ac40..00dc623779 100644
--- a/meson.build
+++ b/meson.build
@@ -510,7 +510,6 @@ if want_nvme
     subdir('util')      # declares: util_sources
 
     sources = [
-        'libnvme-wrap.c',
         'logging.c',
         'nvme-cmds.c',
         'nvme-models.c',
@@ -526,6 +525,7 @@ if want_nvme
         ]
     else
         sources += [
+            'libnvme-wrap.c',
             'nvme-rpmb.c',
         ]
     endif

From d061d3ab53006af68860f75c1f371a89e88b4de0 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 15:48:36 -0700
Subject: [PATCH 72/83] Refactored mkdir support and enabled plugin building.

- Moved mkdir compatibility into nvme/mkdir.h and added to plugins that used mkdir.
- Enabled plugins building on Windows.
---
 libnvme/src/nvme/mkdir.h                  | 19 +++++++++++++++++++
 libnvme/src/platform/windows.h            |  9 +--------
 plugins/meson.build                       |  8 ++------
 plugins/micron/micron-nvme.c              |  2 ++
 plugins/solidigm/solidigm-internal-logs.c |  1 +
 plugins/wdc/wdc-nvme.c                    |  1 +
 plugins/wdc/wdc-utils.c                   |  1 +
 7 files changed, 27 insertions(+), 14 deletions(-)
 create mode 100644 libnvme/src/nvme/mkdir.h

diff --git a/libnvme/src/nvme/mkdir.h b/libnvme/src/nvme/mkdir.h
new file mode 100644
index 0000000000..aa402dfc98
--- /dev/null
+++ b/libnvme/src/nvme/mkdir.h
@@ -0,0 +1,19 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2026 Micron Technology, Inc.
+ *
+ * Cross-platform compatibility for mkdir (sys/stat.h).
+ *
+ * Authors: Broc Going <bgoing@micron.com>
+ */
+#pragma once
+
+#if defined(_WIN32) || defined(_WIN64)
+
+#include <direct.h>
+
+/* Windows mkdir doesn't take the mode parameter */
+#define mkdir(path, mode) _mkdir(path)
+
+#endif
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index e9af339be8..6e74c5f3e3 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -72,11 +72,4 @@ static inline int sigaction(int signum, const struct sigaction *act,
 		return 0;
 	}
 	return -1;
-}
-
-
-/* sys/stat.h compatibility */
-
-/* Windows _mkdir doesn't take mode parameter */
-/* _mkdir is defined in <direct.h> */
-#define mkdir(path, mode) _mkdir(path)
+}
\ No newline at end of file
diff --git a/plugins/meson.build b/plugins/meson.build
index 5f06824182..4c833682ee 100644
--- a/plugins/meson.build
+++ b/plugins/meson.build
@@ -36,11 +36,7 @@ if host_system != 'windows'
 endif
 
 # Get the list of plugins to build
-if host_system != 'windows'
-  selected_plugins = get_option('plugins')
-else
-  selected_plugins = []
-endif
+selected_plugins = get_option('plugins')
 
 # Build the plugin_sources list from simple plugins
 plugin_sources = []
@@ -59,7 +55,7 @@ if 'feat' in selected_plugins
   subdir('feat')
 endif
 
-if 'lm' in selected_plugins
+if 'lm' in selected_plugins and host_system != 'windows'
   subdir('lm')
 endif
 
diff --git a/plugins/micron/micron-nvme.c b/plugins/micron/micron-nvme.c
index b0295faace..80da8e2efe 100644
--- a/plugins/micron/micron-nvme.c
+++ b/plugins/micron/micron-nvme.c
@@ -25,6 +25,8 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
+#include <nvme/mkdir.h>
+
 #include <libnvme.h>
 
 #include "common.h"
diff --git a/plugins/solidigm/solidigm-internal-logs.c b/plugins/solidigm/solidigm-internal-logs.c
index 9c9929b69c..4a18b58dba 100644
--- a/plugins/solidigm/solidigm-internal-logs.c
+++ b/plugins/solidigm/solidigm-internal-logs.c
@@ -15,6 +15,7 @@
 #include <inttypes.h>
 #include <time.h>
 
+#include <nvme/mkdir.h>
 #include <libnvme.h>
 
 #include "common.h"
diff --git a/plugins/wdc/wdc-nvme.c b/plugins/wdc/wdc-nvme.c
index 5465bbd587..eb5c0b238a 100644
--- a/plugins/wdc/wdc-nvme.c
+++ b/plugins/wdc/wdc-nvme.c
@@ -31,6 +31,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 
+#include <nvme/mkdir.h>
 #include <libnvme.h>
 
 #include "common.h"
diff --git a/plugins/wdc/wdc-utils.c b/plugins/wdc/wdc-utils.c
index 81ace2dfc7..98200c8219 100644
--- a/plugins/wdc/wdc-utils.c
+++ b/plugins/wdc/wdc-utils.c
@@ -25,6 +25,7 @@
 #include <unistd.h>
 #include <time.h>
 
+#include <nvme/mkdir.h>
 #include <libnvme.h>
 
 #include "nvme-cmds.h"

From 538510c80b064e5388d396dc8b0039a1496f98d1 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 15:55:31 -0700
Subject: [PATCH 73/83] Refactored signal compatibility

Moved signal.h compatibility into nvme/signal.h
---
 libnvme/src/nvme/signal.h      | 49 ++++++++++++++++++++++++++++++++++
 libnvme/src/platform/windows.h | 30 ---------------------
 plugins/amzn/amzn-nvme.c       |  1 +
 util/sighdl.c                  |  2 +-
 4 files changed, 51 insertions(+), 31 deletions(-)
 create mode 100644 libnvme/src/nvme/signal.h

diff --git a/libnvme/src/nvme/signal.h b/libnvme/src/nvme/signal.h
new file mode 100644
index 0000000000..0dbbb31b3a
--- /dev/null
+++ b/libnvme/src/nvme/signal.h
@@ -0,0 +1,49 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2026 Micron Technology, Inc.
+ *
+ * Cross-platform compatibility for signal.h.
+ * Provides functionality that may be missing on some platforms.
+ * Compatibility is not comprehensive. Only functionality required by
+ * nvme-cli and libnvme is included.
+ * 
+ * Authors: Brandon Busacker <bbusacker@micron.com>
+ *          Broc Going <bgoing@micron.com>
+ */
+#pragma once
+
+#include <signal.h>
+
+#if defined(_WIN32) || defined(_WIN64)
+
+/* signal.h POSIX compatibility - Windows doesn't have sigaction */
+
+struct sigaction {
+	void (*sa_handler)(int);
+	int sa_flags;
+	int sa_mask;  /* simplified - normally sigset_t */
+};
+
+static inline int sigemptyset(int *set)
+{
+	*set = 0;
+	return 0;
+}
+
+/*
+ * Simplified signal handling using Windows signal() function
+ * This is sufficient for handling SIGINT with no mask or flags.
+ */
+static inline int sigaction(int signum, const struct sigaction *act,
+			struct sigaction *oldact)
+{
+	(void)oldact; /* ignore old action for simplicity */
+	if (act && act->sa_handler) {
+		signal(signum, act->sa_handler);
+		return 0;
+	}
+	return -1;
+}
+
+#endif
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index 6e74c5f3e3..f657a00692 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -43,33 +43,3 @@ static inline void libnvme_init(void)
 	_setmode(_fileno(stdout), O_BINARY);
 	_setmode(_fileno(stderr), O_BINARY);
 }
-
-
-/* signal.h POSIX compatibility - Windows doesn't have sigaction */
-
-struct sigaction {
-	void (*sa_handler)(int);
-	int sa_flags;
-	int sa_mask;  /* simplified - normally sigset_t */
-};
-
-static inline int sigemptyset(int *set)
-{
-	*set = 0;
-	return 0;
-}
-
-/*
- * Simplified signal handling using Windows signal() function
- * This is sufficient for handling SIGINT with no mask or flags.
- */
-static inline int sigaction(int signum, const struct sigaction *act,
-			struct sigaction *oldact)
-{
-	(void)oldact; /* ignore old action for simplicity */
-	if (act && act->sa_handler) {
-		signal(signum, act->sa_handler);
-		return 0;
-	}
-	return -1;
-}
\ No newline at end of file
diff --git a/plugins/amzn/amzn-nvme.c b/plugins/amzn/amzn-nvme.c
index 307ef48fdf..50f772a9e5 100644
--- a/plugins/amzn/amzn-nvme.c
+++ b/plugins/amzn/amzn-nvme.c
@@ -7,6 +7,7 @@
 #include <unistd.h>
 #include <inttypes.h>
 
+#include <nvme/signal.h>
 #include <libnvme.h>
 
 #include "common.h"
diff --git a/util/sighdl.c b/util/sighdl.c
index 3f7bfa5f1e..d40267ad5a 100644
--- a/util/sighdl.c
+++ b/util/sighdl.c
@@ -3,7 +3,7 @@
 #include <errno.h>
 #include <stddef.h>
 
-#include <platform/includes.h>
+#include <nvme/signal.h>
 
 #include "sighdl.h"
 

From d6adc8d34f3b3751b58e2d831f858e656ac848e5 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 15:59:01 -0700
Subject: [PATCH 74/83] Added missing headers to build configuration headers
 list

---
 libnvme/src/meson.build | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index 962d5ae05c..e5ba996d83 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -38,8 +38,11 @@ headers = [
     'nvme/lib.h',
     'nvme/linux.h',
     'nvme/malloc.h',
+    'nvme/mkdir.h',
     'nvme/nvme-cmds.h',
     'nvme/nvme-types.h',
+    'nvme/signal.h',
+    'nvme/stdio.h',
     'nvme/stdlib.h',
     'nvme/tree.h',
     'nvme/types.h',

From 8540f321b3b7c4b15d19c8001b01fe0dae1b595b Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 16:11:49 -0700
Subject: [PATCH 75/83] Minimized includes in windows.h and linux.h

- Removed unneeded includes.
- Added gethostname support to nvme/unistd.h
---
 libnvme/src/nvme/unistd.h      |  3 +++
 libnvme/src/nvme/util.c        |  2 ++
 libnvme/src/platform/linux.h   | 23 -----------------------
 libnvme/src/platform/windows.h | 15 ++-------------
 4 files changed, 7 insertions(+), 36 deletions(-)

diff --git a/libnvme/src/nvme/unistd.h b/libnvme/src/nvme/unistd.h
index 47e8d28b38..6e9c0cde4c 100644
--- a/libnvme/src/nvme/unistd.h
+++ b/libnvme/src/nvme/unistd.h
@@ -17,6 +17,9 @@
 
 #if defined(_WIN32) || defined(_WIN64)
 
+#define WIN32_LEAN_AND_MEAN	/* keeps windows.h from including winsock.*/
+#include <winsock2.h>	/* for gethostname */
+
 #include <sysinfoapi.h>
 
 /* unistd.h POSIX compatibility */
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 4508838413..19ce950568 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -33,6 +33,8 @@
 #include <ccan/endian/endian.h>
 #include <ccan/minmax/minmax.h>
 
+#include <nvme/unistd.h>
+
 #include <libnvme.h>
 
 #include "cleanup.h"
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index e6c6612e10..6a5d257ea9 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -8,29 +8,6 @@
 
 #pragma once
 
-/* Linux-specific includes */
-#include <dirent.h>
-#include <endian.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include <syslog.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/param.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/uio.h>
-
-#include <arpa/inet.h>
-#include <ifaddrs.h>
-#include <netdb.h>
-#include <netinet/in.h>
-
-
 typedef int libnvme_fd_t;
 #define TEST_FD 0xFD
 #define INIT_FD -1
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/platform/windows.h
index f657a00692..b1225e8340 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/platform/windows.h
@@ -8,23 +8,12 @@
 
 #pragma once
 
-/* Windows-specific includes - winsock2 before windows.h to avoid warnings */
-#define WIN32_LEAN_AND_MEAN
-#include <winsock2.h>
-#include <ws2tcpip.h>
+/* Windows-specific includes */
+#define WIN32_LEAN_AND_MEAN	/* keeps windows.h from including winsock.*/
 #include <windows.h>
-#undef WIN32_LEAN_AND_MEAN
 
-#include <bcrypt.h>
-#include <direct.h>
-#include <errno.h>
 #include <fcntl.h>
-#include <io.h>
-#include <process.h>
-#include <signal.h>
 #include <stdio.h>
-#include <sys/stat.h>
-#include <time.h>
 
 
 /* Platform compatibility helper types and methods */

From bcd43d5435e5c556d5e5375a771f4b732b95f430 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 16:15:32 -0700
Subject: [PATCH 76/83] Moved O_BINARY handling to the one place it is used.

---
 libnvme/src/platform/linux.h | 5 -----
 plugins/ocp/ocp-nvme.c       | 4 ++++
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
index 6a5d257ea9..75dc377a25 100644
--- a/libnvme/src/platform/linux.h
+++ b/libnvme/src/platform/linux.h
@@ -12,10 +12,5 @@ typedef int libnvme_fd_t;
 #define TEST_FD 0xFD
 #define INIT_FD -1
 
-/* O_BINARY is required on Windows, but not defined on Linux. */
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
 /* Platform initialization - no-op on Linux */
 static inline void libnvme_init(void) {}
diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index bf93ac6222..b047274aa4 100644
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -1188,7 +1188,11 @@ static int get_telemetry_log_page_data(struct libnvme_transport_handle *hdl,
 	}
 	memset(hdr, 0, bs);
 
+#ifdef O_BINARY	/* required for Windows, not defined on Linux */
 	fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
+#else
+	fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+#endif
 	if (fd < 0) {
 		fprintf(stderr, "Failed to open output file %s: %s!\n",
 				output_file, libnvme_strerror(errno));

From 7d28895146946cf7a82987a0257f2962317e1ea1 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 16:35:06 -0700
Subject: [PATCH 77/83] Moved remaining compatibility helpers into new
 lib-compat.h

Moved libnvme-specific compatibility types, definitions, and methods into new nvme/lib-compat.h and removed platform/*.h.

Also cleaned up and standardized formatting of compatibility headers.
---
 libnvme/src/meson.build                       | 11 -------
 .../{platform/windows.h => nvme/lib-compat.h} | 30 +++++++++++++------
 libnvme/src/nvme/lib.h                        |  3 +-
 libnvme/src/nvme/malloc.h                     |  4 +--
 libnvme/src/nvme/private.h                    |  2 +-
 libnvme/src/nvme/signal.h                     |  6 ++--
 libnvme/src/nvme/stdio.h                      |  3 +-
 libnvme/src/nvme/stdlib.h                     |  3 +-
 libnvme/src/platform/includes.h               | 16 ----------
 libnvme/src/platform/linux.h                  | 16 ----------
 10 files changed, 30 insertions(+), 64 deletions(-)
 rename libnvme/src/{platform/windows.h => nvme/lib-compat.h} (52%)
 delete mode 100644 libnvme/src/platform/includes.h
 delete mode 100644 libnvme/src/platform/linux.h

diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index e5ba996d83..18b77e5b7f 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -197,14 +197,3 @@ if want_mi
         install_mode: mode,
     )
 endif
-
-
-# Install platform abstraction headers
-install_headers([
-        'platform/includes.h',
-        'platform/linux.h',
-        'platform/windows.h',
-    ],
-    subdir: 'platform',
-    install_mode: mode,
-)
diff --git a/libnvme/src/platform/windows.h b/libnvme/src/nvme/lib-compat.h
similarity index 52%
rename from libnvme/src/platform/windows.h
rename to libnvme/src/nvme/lib-compat.h
index b1225e8340..53495500ab 100644
--- a/libnvme/src/platform/windows.h
+++ b/libnvme/src/nvme/lib-compat.h
@@ -1,34 +1,46 @@
-// SPDX-License-Identifier: LGPL-2.1-or-later
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
 /*
  * This file is part of libnvme.
- * Copyright (c) 2025 Micron Technology, Inc.
+ * Copyright (c) 2026 Micron Technology, Inc.
  *
- * Windows platform-specific definitions and includes.
+ * Cross-platform compatibility definitions, types, and utilities.
+ *
+ * Authors: Broc Going <bgoing@micron.com>
+ *          Brandon Busacker <bbusacker@micron.com>
  */
-
 #pragma once
 
-/* Windows-specific includes */
+#if defined(_WIN32) || defined(_WIN64)
+
 #define WIN32_LEAN_AND_MEAN	/* keeps windows.h from including winsock.*/
 #include <windows.h>
 
 #include <fcntl.h>
 #include <stdio.h>
 
-
-/* Platform compatibility helper types and methods */
-
 typedef HANDLE libnvme_fd_t;
+
 #define TEST_FD INVALID_HANDLE_VALUE
 #define INIT_FD nullptr
 
 /*
  * Set stdout and stderr to binary mode to prevent Windows text-mode
  * translation from converting LF to CRLF and corrupting raw binary output.
- * Called once at startup from main().
+ * Call once at startup.
  */
 static inline void libnvme_init(void)
 {
 	_setmode(_fileno(stdout), O_BINARY);
 	_setmode(_fileno(stderr), O_BINARY);
 }
+
+#else
+
+typedef int libnvme_fd_t;
+#define TEST_FD 0xFD
+#define INIT_FD -1
+
+/* Platform initialization - no-op on Linux */
+static inline void libnvme_init(void) {}
+
+#endif
diff --git a/libnvme/src/nvme/lib.h b/libnvme/src/nvme/lib.h
index 519d56bfc9..2ca5e93344 100644
--- a/libnvme/src/nvme/lib.h
+++ b/libnvme/src/nvme/lib.h
@@ -11,12 +11,11 @@
 #include <stdbool.h>
 #include <stdio.h>
 
+#include <nvme/lib-compat.h>
 #include <nvme/lib-types.h>
 #include <nvme/stdlib.h>
 #include <nvme/unistd.h>
 
-#include <platform/includes.h> /* for libnvme_fd_t */
-
 enum libnvme_log_level {
 	LIBNVME_LOG_ERR	  = 0,
 	LIBNVME_LOG_WARN  = 1,
diff --git a/libnvme/src/nvme/malloc.h b/libnvme/src/nvme/malloc.h
index 4238058f70..207f401892 100644
--- a/libnvme/src/nvme/malloc.h
+++ b/libnvme/src/nvme/malloc.h
@@ -7,7 +7,7 @@
  * Provides functionality that may be missing on some platforms.
  * Compatibility is not comprehensive. Only functionality required by
  * nvme-cli and libnvme is included.
- * 
+ *
  * Authors: Broc Going <bgoing@micron.com>
  *          Brandon Capener <bcapener@micron.com>
  */
@@ -23,4 +23,4 @@ static inline size_t malloc_usable_size(void *ptr)
 	return _msize(ptr);
 }
 
-#endif /* _WIN32 */
+#endif
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index d8f92adb0d..7ff5b4a9af 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -10,7 +10,7 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
-#include <platform/includes.h> /* for libnvme_fd_t */
+#include <nvme/lib-compat.h>
 
 #include <ccan/list/list.h>
 
diff --git a/libnvme/src/nvme/signal.h b/libnvme/src/nvme/signal.h
index 0dbbb31b3a..dfedd7d04e 100644
--- a/libnvme/src/nvme/signal.h
+++ b/libnvme/src/nvme/signal.h
@@ -7,9 +7,9 @@
  * Provides functionality that may be missing on some platforms.
  * Compatibility is not comprehensive. Only functionality required by
  * nvme-cli and libnvme is included.
- * 
- * Authors: Brandon Busacker <bbusacker@micron.com>
- *          Broc Going <bgoing@micron.com>
+ *
+ * Authors: Broc Going <bgoing@micron.com>
+ *          Brandon Busacker <bbusacker@micron.com>
  */
 #pragma once
 
diff --git a/libnvme/src/nvme/stdio.h b/libnvme/src/nvme/stdio.h
index f5a4d72c8e..de11f2fdb7 100644
--- a/libnvme/src/nvme/stdio.h
+++ b/libnvme/src/nvme/stdio.h
@@ -8,10 +8,9 @@
  * Compatibility is not comprehensive. Only functionality required by
  * nvme-cli and libnvme is included.
  *
- * Authors: Brandon Capener <bcapener@micron.com>
+ * Authors: Broc Going <bgoing@micron.com>
  *          Brandon Busacker <bbusacker@micron.com>
 */
-
 #pragma once
 
 #include <stdio.h>
diff --git a/libnvme/src/nvme/stdlib.h b/libnvme/src/nvme/stdlib.h
index f3b3f39346..275fd5dfda 100644
--- a/libnvme/src/nvme/stdlib.h
+++ b/libnvme/src/nvme/stdlib.h
@@ -7,11 +7,10 @@
  * Provides functionality that may be missing on some platforms.
  * Compatibility is not comprehensive. Only functionality required by
  * nvme-cli and libnvme is included.
- * 
+ *
  * Authors: Broc Going <bgoing@micron.com>
  *          Brandon Capener <bcapener@micron.com>
  */
-
 #pragma once
 
 #include <stdlib.h>
diff --git a/libnvme/src/platform/includes.h b/libnvme/src/platform/includes.h
deleted file mode 100644
index 9810056b86..0000000000
--- a/libnvme/src/platform/includes.h
+++ /dev/null
@@ -1,16 +0,0 @@
-// SPDX-License-Identifier: LGPL-2.1-or-later
-/*
- * This file is part of libnvme.
- * Copyright (c) 2025 Micron Technology, Inc.
- *
- * Common platform-specific includes and definitions.
- */
-
-#pragma once
-
-/* Platform-specific includes */
-#ifdef _WIN32
-    #include "platform/windows.h"
-#else
-    #include "platform/linux.h"
-#endif
diff --git a/libnvme/src/platform/linux.h b/libnvme/src/platform/linux.h
deleted file mode 100644
index 75dc377a25..0000000000
--- a/libnvme/src/platform/linux.h
+++ /dev/null
@@ -1,16 +0,0 @@
-// SPDX-License-Identifier: LGPL-2.1-or-later
-/*
- * This file is part of libnvme.
- * Copyright (c) 2026 Micron Technology, Inc.
- *
- * Linux platform-specific definitions and includes.
- */
-
-#pragma once
-
-typedef int libnvme_fd_t;
-#define TEST_FD 0xFD
-#define INIT_FD -1
-
-/* Platform initialization - no-op on Linux */
-static inline void libnvme_init(void) {}

From ed7758564d6b685015500c33dc2e45fbdb3c89ed Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 17:09:17 -0700
Subject: [PATCH 78/83] Moved O_BINARY definition into new nvme/fcntl.h

---
 libnvme/src/meson.build  |  1 +
 libnvme/src/nvme/fcntl.h | 21 +++++++++++++++++++++
 plugins/ocp/ocp-nvme.c   |  5 +----
 3 files changed, 23 insertions(+), 4 deletions(-)
 create mode 100644 libnvme/src/nvme/fcntl.h

diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index 18b77e5b7f..1c531e9c26 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -32,6 +32,7 @@ endif
 headers = [
     'nvme/accessors.h',
     'nvme/endian.h',
+    'nvme/fcntl.h',
     'nvme/filters.h',
     'nvme/ioctl.h',
     'nvme/lib-types.h',
diff --git a/libnvme/src/nvme/fcntl.h b/libnvme/src/nvme/fcntl.h
new file mode 100644
index 0000000000..78c986c0a3
--- /dev/null
+++ b/libnvme/src/nvme/fcntl.h
@@ -0,0 +1,21 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2026 Micron Technology, Inc.
+ *
+ * Cross-platform compatibility for fcntl.h.
+ *
+ * Authors: Broc Going <bgoing@micron.com>
+ */
+#pragma once
+
+#include <fcntl.h>
+
+/*
+ * O_BINARY is required for Windows to avoid line ending translations.
+ * Define it as 0 on platforms where it is not defined so that it can be used
+ * but will have no effect.
+ */
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index b047274aa4..d277ec0b35 100644
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -17,6 +17,7 @@
 #include <time.h>
 
 #include <libnvme.h>
+#include <nvme/fcntl.h>
 
 #include "common.h"
 #include "logging.h"
@@ -1188,11 +1189,7 @@ static int get_telemetry_log_page_data(struct libnvme_transport_handle *hdl,
 	}
 	memset(hdr, 0, bs);
 
-#ifdef O_BINARY	/* required for Windows, not defined on Linux */
 	fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
-#else
-	fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
-#endif
 	if (fd < 0) {
 		fprintf(stderr, "Failed to open output file %s: %s!\n",
 				output_file, libnvme_strerror(errno));

From 3afb48e36a02156ccc1d5ce35ad6b4c060f4556b Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 17:15:24 -0700
Subject: [PATCH 79/83] Includes updates to fix Linux build.

---
 libnvme/src/nvme/ioctl.c | 4 ++++
 libnvme/src/nvme/lib.c   | 4 ++++
 nvme.c                   | 5 ++++-
 util/mem.c               | 6 ++++++
 4 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/libnvme/src/nvme/ioctl.c b/libnvme/src/nvme/ioctl.c
index edfba69490..551aac68cc 100644
--- a/libnvme/src/nvme/ioctl.c
+++ b/libnvme/src/nvme/ioctl.c
@@ -11,8 +11,12 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
+
+#include <sys/stat.h>
 
 #ifndef _WIN32
+#include <sys/ioctl.h>
 #include <linux/fs.h>
 #endif
 
diff --git a/libnvme/src/nvme/lib.c b/libnvme/src/nvme/lib.c
index 795df12768..2892fbe7e1 100644
--- a/libnvme/src/nvme/lib.c
+++ b/libnvme/src/nvme/lib.c
@@ -17,6 +17,10 @@
 #include <ifaddrs.h>
 #endif
 
+#ifndef _WIN32
+#include <sys/ioctl.h>
+#endif
+
 #include <libnvme.h>
 
 #include "cleanup.h"
diff --git a/nvme.c b/nvme.c
index 7e08d952c4..a994c3a387 100644
--- a/nvme.c
+++ b/nvme.c
@@ -39,10 +39,13 @@
 #include <string.h>
 #include <unistd.h>
 
+#ifdef HAVE_MMAP
+#include <sys/mman.h>
+#endif
+
 #include <sys/stat.h>
 #include <sys/types.h>
 
-
 #include <libnvme.h>
 
 #include "common.h"
diff --git a/util/mem.c b/util/mem.c
index c7a447295d..f0db3f985e 100644
--- a/util/mem.c
+++ b/util/mem.c
@@ -1,7 +1,13 @@
 /* SPDX-License-Identifier: GPL-2.0-or-later */
+#include <stdlib.h>
+#include <unistd.h>
 #include <malloc.h>
 #include <string.h>
 
+#ifdef HAVE_MMAP
+#include <sys/mman.h>
+#endif
+
 #include <nvme/malloc.h>
 #include <nvme/stdlib.h>
 #include <nvme/unistd.h>

From 01d38f432bff67d5c82f97d474a60cf41da9d6e7 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 17:18:08 -0700
Subject: [PATCH 80/83] Enabling tests compilation to check compatibility
 build.

---
 meson.build | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/meson.build b/meson.build
index 00dc623779..61a91da1ca 100644
--- a/meson.build
+++ b/meson.build
@@ -55,7 +55,7 @@ want_fabrics = get_option('fabrics').disabled() == false and host_system != 'win
 want_mi = get_option('mi').disabled() == false and host_system != 'windows'
 want_json_c = get_option('json-c').disabled() == false and want_fabrics
 want_libkmod = get_option('libkmod').disabled() == false and host_system != 'windows'
-want_tests = get_option('tests') and host_system != 'windows'
+want_tests = get_option('tests')
 want_examples = get_option('examples') and host_system != 'windows'
 want_docs = get_option('docs')
 want_docs_build = get_option('docs-build')

From c5765c03a8a29bd1f5bf290eb5befd52b8027790 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 17:53:39 -0700
Subject: [PATCH 81/83] Renamed Windows fstat implementation for device
 handles.

---
 libnvme/src/nvme/lib-windows.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/libnvme/src/nvme/lib-windows.c b/libnvme/src/nvme/lib-windows.c
index d543a0136d..3ec545746f 100644
--- a/libnvme/src/nvme/lib-windows.c
+++ b/libnvme/src/nvme/lib-windows.c
@@ -11,8 +11,8 @@
 #include "compiler-attributes.h"
 
 
-/* fstat implementation for device HANDLE */
-static int __libnvme_fd_fstat(libnvme_fd_t fd, struct stat *buf)
+/* fstat implementation for Windows device HANDLE */
+static int __handle_fstat(HANDLE fd, struct stat *buf)
 {
 	BY_HANDLE_FILE_INFORMATION file_info;
 	ULARGE_INTEGER ull;
@@ -126,7 +126,7 @@ static int __libnvme_transport_handle_open_direct(struct libnvme_transport_handl
 
 	hdl->fd = h;
 
-	__libnvme_fd_fstat(hdl->fd, &hdl->stat);
+	__handle_fstat(hdl->fd, &hdl->stat);
 
 	/* Windows doesn't distinguish 32/64-bit ioctl, assume 64-bit capable */
 	hdl->ioctl_admin64 = true;

From c57b3852d93f04ee0286154e57122072221b4c9c Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 17:57:27 -0700
Subject: [PATCH 82/83] Added newline to end of unistd.h

---
 libnvme/src/nvme/unistd.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libnvme/src/nvme/unistd.h b/libnvme/src/nvme/unistd.h
index 6e9c0cde4c..43153517f2 100644
--- a/libnvme/src/nvme/unistd.h
+++ b/libnvme/src/nvme/unistd.h
@@ -50,4 +50,4 @@ static inline int fsync(int fd)
 	return _commit(fd);
 }
 
-#endif
\ No newline at end of file
+#endif

From d2a2ba13c2d0ceeba68722bc116784d1c5a21040 Mon Sep 17 00:00:00 2001
From: Broc Going <bgoing@micron.com>
Date: Fri, 17 Apr 2026 18:17:55 -0700
Subject: [PATCH 83/83] Removed cleanup.h dependency on private.h to match
 upstream.

Removed __libnvme_free from private.h. It was only used by fabrics, which isn't supported on Windows, and in cleanup.h.  Removed __libnvme_free implementation from util.c  Directly calling aligned_free instead.

This allows us to get rid of the private.h include in cleanup.h, better matching the recent upstream refactoring.
---
 libnvme/src/nvme/cleanup.h | 4 +---
 libnvme/src/nvme/fabrics.c | 8 ++++----
 libnvme/src/nvme/private.h | 2 --
 libnvme/src/nvme/util.c    | 7 +------
 4 files changed, 6 insertions(+), 15 deletions(-)

diff --git a/libnvme/src/nvme/cleanup.h b/libnvme/src/nvme/cleanup.h
index 02fb9fb61e..ac512c55c3 100644
--- a/libnvme/src/nvme/cleanup.h
+++ b/libnvme/src/nvme/cleanup.h
@@ -4,8 +4,6 @@
 
 #include <stdlib.h>
 
-#include "private.h"	/* for __libnvme_free */
-
 #define __cleanup(fn) __attribute__((cleanup(fn)))
 
 #define DECLARE_CLEANUP_FUNC(name, type) \
@@ -26,7 +24,7 @@ static inline void freep(void *p)
 
 static inline void nvme_freep(void *p)
 {
-	__libnvme_free(*(void **)p);
+	aligned_free(*(void **)p);
 }
 #define __cleanup_nvme_free __cleanup(nvme_freep)
 
diff --git a/libnvme/src/nvme/fabrics.c b/libnvme/src/nvme/fabrics.c
index f6afde9cb3..8a93b9cf96 100644
--- a/libnvme/src/nvme/fabrics.c
+++ b/libnvme/src/nvme/fabrics.c
@@ -1415,7 +1415,7 @@ static int nvme_discovery_log(libnvme_ctrl_t ctrl,
 		if (numrec == 0)
 			break;
 
-		__libnvme_free(log);
+		free(log);
 		entries_size = sizeof(*log->entries) * numrec;
 		log = __libnvme_alloc(sizeof(*log) + entries_size);
 		if (!log) {
@@ -1472,7 +1472,7 @@ static int nvme_discovery_log(libnvme_ctrl_t ctrl,
 	}
 
 out_free_log:
-	__libnvme_free(log);
+	free(log);
 	return err;
 }
 
@@ -1784,7 +1784,7 @@ static const char *dctype_str[] = {
  */
 static int nvme_fetch_cntrltype_dctype_from_id(libnvme_ctrl_t c)
 {
-	__cleanup_nvme_free struct nvme_id_ctrl *id = NULL;
+	__cleanup_free struct nvme_id_ctrl *id = NULL;
 	int ret;
 
 	id = __libnvme_alloc(sizeof(*id));
@@ -2255,7 +2255,7 @@ static int nvmf_create_discovery_ctrl(struct libnvme_global_ctx *ctx,
 		struct libnvmf_context *fctx, libnvme_host_t h,
 		struct libnvme_ctrl **ctrl)
 {
-	__cleanup_nvme_free struct nvme_id_ctrl *id = NULL;
+	__cleanup_free struct nvme_id_ctrl *id = NULL;
 	struct libnvme_ctrl *c;
 	int ret;
 
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index 7ff5b4a9af..1a910d7865 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -380,8 +380,6 @@ void *__libnvme_alloc(size_t len);
 
 void *__libnvme_realloc(void *p, size_t len);
 
-void __libnvme_free(void *p);
-
 void nvme_deconfigure_ctrl(struct libnvme_ctrl *c);
 
 struct libnvme_host *libnvme_lookup_host(struct libnvme_global_ctx *ctx,
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 19ce950568..49c409cb57 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -1028,17 +1028,12 @@ void *__libnvme_realloc(void *p, size_t len)
 
 	if (p && result) {
 		memcpy(result, p, min(old_len, len));
-		__libnvme_free(p);
+		aligned_free(p);
 	}
 
 	return result;
 }
 
-void __libnvme_free(void *p)
-{
-	aligned_free(p);
-}
-
 #ifdef CONFIG_FABRICS
 const struct ifaddrs *libnvme_getifaddrs(struct libnvme_global_ctx *ctx)
 {