plugins/posix: minimized IO queue abstraction

This patch set minimizes the IO queue abstraction, making it as low-
level as possible.

It now only wraps the lowest-level IO-related API. It works with a set
of IOs (writes or reads) while leaving the Xfer level logic to the upper
layer (posix_backend).

This patch set allows the posix_backend to implement the common logic,
while only offloading the details of specific file access API to the IO
queue abstraction.

This patch set prepares the code for the POSIX plugin threading model
implementation. With it, the threading will be implemented once,
in the posix_backend.

Signed-off-by: Anton Nayshtut <[email protected]>

Author: anton-nayshtut

src/plugins/posix/aio_queue.cpp

@@ -0,0 +1,53 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "io_queue.h"
+
+nixlPosixIOQueue::nixlPosixIOQueueCreateFn
+    DEFINE_NIXL_POSIX_IO_QUEUE_FACTORY_NAME(nixlPosixAioIOQueue);
+nixlPosixIOQueue::nixlPosixIOQueueCreateFn
+    DEFINE_NIXL_POSIX_IO_QUEUE_FACTORY_NAME(nixlPosixIoUringIOQueue);
+nixlPosixIOQueue::nixlPosixIOQueueCreateFn
+    DEFINE_NIXL_POSIX_IO_QUEUE_FACTORY_NAME(nixlPosixLinuxAioIOQueue);
+
+static const struct {
+    const char *name;
+    nixlPosixIOQueue::nixlPosixIOQueueCreateFn createFn;
+} factories[] = {
+#ifdef HAVE_LIBAIO
+    {"POSIXAIO", DEFINE_NIXL_POSIX_IO_QUEUE_FACTORY_NAME(nixlPosixAioIOQueue)},
+#endif
+#ifdef HAVE_LIBURING
+    {"URING", DEFINE_NIXL_POSIX_IO_QUEUE_FACTORY_NAME(nixlPosixIoUringIOQueue)},
+#endif
+#ifdef HAVE_LINUXAIO
+    {"AIO", DEFINE_NIXL_POSIX_IO_QUEUE_FACTORY_NAME(nixlPosixLinuxAioIOQueue)},
+#endif
+    {nullptr, nullptr}};
+
+const uint32_t nixlPosixIOQueue::MIN_IOS = 64;
+const uint32_t nixlPosixIOQueue::MAX_IOS = 1024 * 64;
+
+std::unique_ptr<nixlPosixIOQueue>
+nixlPosixIOQueue::instantiate(std::string_view io_queue_type, uint32_t max_ios) {
+    for (const auto &factory : factories) {
+        if (factory.name == io_queue_type.data()) {
+            return factory.createFn(max_ios);
+        }
+    }
+    return nullptr;
+}

src/plugins/posix/aio_queue.h

@@ -0,0 +1,74 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef POSIX_IO_QUEUE_H
+#define POSIX_IO_QUEUE_H
+
+#include <stdint.h>
+#include <map>
+#include <string>
+#include <memory>
+#include "backend_aux.h"
+
+typedef void (*nixlPosixIOQueueDoneCb)(void *ctx, uint32_t data_size, int error);
+
+class nixlPosixIOQueue {
+public:
+    typedef std::unique_ptr<nixlPosixIOQueue> (*nixlPosixIOQueueCreateFn)(uint32_t max_ios);
+
+    nixlPosixIOQueue(uint32_t max_ios) : max_ios_(normalizedMaxIOS(max_ios)) {}
+
+    virtual ~nixlPosixIOQueue() {}
+
+    virtual nixl_status_t
+    enqueue(int fd,
+            void *buf,
+            size_t len,
+            off_t offset,
+            bool read,
+            nixlPosixIOQueueDoneCb clb,
+            void *ctx) = 0;
+    virtual nixl_status_t
+    post(void) = 0;
+    virtual nixl_status_t
+    poll(void) = 0;
+
+    static std::unique_ptr<nixlPosixIOQueue>
+    instantiate(std::string_view io_queue_type, uint32_t max_ios);
+
+protected:
+    static uint32_t
+    normalizedMaxIOS(uint32_t max_ios) {
+        uint32_t m = std::max(MIN_IOS, max_ios);
+        m = std::min(m, MAX_IOS);
+        return m;
+    }
+
+    uint32_t max_ios_;
+    static const uint32_t MIN_IOS;
+    static const uint32_t MAX_IOS;
+};
+
+#define DEFINE_NIXL_POSIX_IO_QUEUE_FACTORY_NAME(class_name) class_name##Create
+
+#define DEFINE_NIXL_POSIX_IO_QUEUE_FACTORY(class_name)                                     \
+    std::unique_ptr<nixlPosixIOQueue> DEFINE_NIXL_POSIX_IO_QUEUE_FACTORY_NAME(class_name)( \
+        uint32_t max_ios) {                                                                \
+        return std::make_unique<class_name>(max_ios);                                      \
+    }
+
+#endif // POSIX_IO_QUEUE_H