test: add async test case

Add tests cases for the async submission API. Since there is no easy way to
tests async test, it only tests the fallback mode, when there is no io_uring.

Signed-off-by: Daniel Wagner <wagi@kernel.org>

Author: igaw

libnvme/test/ioctl/async.c

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/**
+ * This file is part of libnvme.
+ * Copyright (c) 2026 Daniel Wagner, SUSE Software Solutions
+ */
+
+#include <errno.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include <libnvme.h>
+
+#include "mock.h"
+#include "util.h"
+
+static struct libnvme_transport_handle *test_hdl;
+
+static void test_admin_async_submit_not_supported(void)
+{
+	struct nvme_id_ctrl id = {};
+	struct libnvme_passthru_cmd cmd;
+	int err;
+
+	nvme_init_identify_ctrl(&cmd, &id);
+	err = libnvme_submit_admin_passthru_async(test_hdl, &cmd,
+			(void *)(uintptr_t)0x1234);
+	check(err == -ENOTSUP, "submit async returned %d, expected %d",
+	      err, -ENOTSUP);
+}
+
+static void test_io_async_submit_not_supported(void)
+{
+	struct libnvme_passthru_cmd cmd = {};
+	int err;
+
+	err = libnvme_submit_io_passthru_async(test_hdl, &cmd,
+			(void *)(uintptr_t)0x5678);
+	check(err == -ENOTSUP, "IO submit async returned %d, expected %d",
+	      err, -ENOTSUP);
+}
+
+static void test_async_reap_not_supported(void)
+{
+	struct libnvme_passthru_completion completion = {};
+	int err;
+
+	err = libnvme_reap_passthru_async(test_hdl, &completion);
+	check(err == -ENOTSUP, "reap async returned %d, expected %d",
+	      err, -ENOTSUP);
+}
+
+static void test_sync_path_fallback(void)
+{
+	struct nvme_id_ctrl expected_id = {}, id = {};
+	struct mock_cmd mock_admin_cmd = {
+		.opcode = nvme_admin_identify,
+		.data_len = sizeof(expected_id),
+		.cdw10 = NVME_IDENTIFY_CNS_CTRL,
+		.out_data = &expected_id,
+	};
+	struct libnvme_passthru_cmd cmd;
+	int err;
+
+	arbitrary(&expected_id, sizeof(expected_id));
+	set_mock_admin_cmds(&mock_admin_cmd, 1);
+	nvme_init_identify_ctrl(&cmd, &id);
+	err = libnvme_exec_admin_passthru(test_hdl, &cmd);
+	end_mock_cmds();
+	check(err == 0, "sync fallback returned %d", err);
+	cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
+}
+
+static void test_io_sync_path_fallback(void)
+{
+	struct libnvme_passthru_cmd cmd = {};
+	struct mock_cmd mock_io_cmd = {
+		.opcode = nvme_cmd_read,
+		.data_len = 0,
+	};
+	int err;
+
+	set_mock_io_cmds(&mock_io_cmd, 1);
+	cmd.opcode = nvme_cmd_read;
+	err = libnvme_exec_io_passthru(test_hdl, &cmd);
+	end_mock_cmds();
+	check(err == 0, "IO sync fallback returned %d", err);
+}
+
+static void test_batched_submit_wait_pattern(void)
+{
+	struct nvme_id_ctrl id1 = {}, id2 = {};
+	struct mock_cmd mock_cmds[] = {
+		{
+			.opcode = nvme_admin_identify,
+			.data_len = sizeof(id1),
+			.cdw10 = NVME_IDENTIFY_CNS_CTRL,
+			.out_data = &id1,
+		},
+		{
+			.opcode = nvme_admin_identify,
+			.data_len = sizeof(id2),
+			.cdw10 = NVME_IDENTIFY_CNS_CTRL,
+			.out_data = &id2,
+		},
+	};
+	struct libnvme_passthru_cmd cmd1, cmd2;
+	int err;
+
+	/* Test the batching pattern: submit multiple, then wait */
+	arbitrary(&id1, sizeof(id1));
+	arbitrary(&id2, sizeof(id2));
+	set_mock_admin_cmds(mock_cmds, 2);
+
+	nvme_init_identify_ctrl(&cmd1, &id1);
+	nvme_init_identify_ctrl(&cmd2, &id2);
+
+	/* When io_uring is unavailable, submit falls back to exec */
+	err = libnvme_submit_admin_passthru(test_hdl, &cmd1);
+	check(err == 0, "batched submit 1 returned %d", err);
+
+	err = libnvme_submit_admin_passthru(test_hdl, &cmd2);
+	check(err == 0, "batched submit 2 returned %d", err);
+
+	/* wait is a no-op when io_uring is not available */
+	err = libnvme_wait_passthru(test_hdl);
+	check(err == -ENOTSUP, "batched wait returned %d", err);
+
+	end_mock_cmds();
+}
+
+static void run_test(const char *test_name, void (*test_fn)(void))
+{
+	printf("Running test %s...", test_name);
+	fflush(stdout);
+	test_fn();
+	puts(" OK");
+}
+
+#define RUN_TEST(name) run_test(#name, test_ ## name)
+
+int main(void)
+{
+	struct libnvme_global_ctx *ctx =
+		libnvme_create_global_ctx(stdout, LIBNVME_DEFAULT_LOGLEVEL);
+
+	set_mock_fd(LIBNVME_TEST_FD);
+	check(!libnvme_open(ctx, "NVME_TEST_FD", &test_hdl),
+	      "opening test link failed");
+
+	RUN_TEST(admin_async_submit_not_supported);
+	RUN_TEST(io_async_submit_not_supported);
+	RUN_TEST(async_reap_not_supported);
+	RUN_TEST(sync_path_fallback);
+	RUN_TEST(io_sync_path_fallback);
+	RUN_TEST(batched_submit_wait_pattern);
+
+	libnvme_free_global_ctx(ctx);
+}

libnvme/test/ioctl/meson.build

@@ -52,6 +52,18 @@ ana = executable(
 )
 test('libnvme - ana', ana, env: mock_ioctl_env)
 
+async = executable(
+    'test-async',
+    'async.c',
+    dependencies: [
+        config_dep,
+        ccan_dep,
+        libnvme_dep,
+    ],
+    link_with: mock_ioctl,
+)
+test('libnvme - async', async, env: mock_ioctl_env)
+
 if want_fabrics
     discovery = executable(
         'test-discovery',