plugins/posix: file_api abstraction

This patch set replaces the queue-abstraction based API implementation
with the file_api abstraction.

Unlike queue abstraction, the file_api abstraction is very low-level.
It 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
file_api 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

@@ -15,25 +15,8 @@
  * limitations under the License.
  */
 
-#ifndef QUEUE_FACTORY_IMPL_H
-#define QUEUE_FACTORY_IMPL_H
+#include "file_api.h"
 
-#include "posix_queue.h"
-
-namespace QueueFactory {
-std::unique_ptr<nixlPosixQueue>
-createPosixAioQueue(int num_entries, nixl_xfer_op_t operation);
-
-std::unique_ptr<nixlPosixQueue>
-createUringQueue(int num_entries, nixl_xfer_op_t operation);
-
-std::unique_ptr<nixlPosixQueue>
-createLinuxAioQueue(int num_entries, nixl_xfer_op_t operation);
-
-bool
-isLinuxAioAvailable();
-bool
-isUringAvailable();
-}; // namespace QueueFactory
-
-#endif // QUEUE_FACTORY_IMPL_H
+std::map<std::string, nixlPosixFileApi::nixlPosixFileApiCreateFn> nixlPosixFileApi::apis = {};
+const uint32_t nixlPosixFileApi::MIN_AIO_REQS = 64;
+const uint32_t nixlPosixFileApi::MAX_AIO_REQS = 1024 * 64;

src/plugins/posix/aio_queue.h

@@ -0,0 +1,89 @@
+/*
+ * 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 FILE_API_H
+#define FILE_API_H
+
+#include <stdint.h>
+#include <map>
+#include <string>
+#include <memory>
+#include "backend_aux.h"
+
+typedef void (*nixlPosixFileApiDoneCb)(void *ctx, uint32_t data_size, int error);
+
+class nixlPosixFileApi {
+public:
+    typedef std::unique_ptr<nixlPosixFileApi> (*nixlPosixFileApiCreateFn)(void);
+
+    nixlPosixFileApi() {}
+
+    virtual ~nixlPosixFileApi() {}
+
+    virtual nixl_status_t
+    init(uint32_t max_chunks) = 0;
+    virtual nixl_status_t
+    add(int fd,
+        void *buf,
+        size_t len,
+        off_t offset,
+        bool read,
+        nixlPosixFileApiDoneCb clb,
+        void *ctx) = 0;
+    virtual nixl_status_t
+    post(void) = 0;
+    virtual nixl_status_t
+    pump(void) = 0;
+
+    static std::unique_ptr<nixlPosixFileApi>
+    getApi(const std::string &api_name) {
+        auto it = apis.find(api_name);
+        if (it != apis.end()) {
+            nixlPosixFileApiCreateFn create_fn = it->second;
+            return create_fn();
+        }
+        return nullptr;
+    }
+
+    static void
+    registerApi(const std::string &api_name, nixlPosixFileApiCreateFn create_fn) {
+        apis[api_name] = create_fn;
+    }
+
+    static uint32_t
+    normalizedMaxChunks(uint32_t max_chunks) {
+        uint32_t m = std::max(MIN_AIO_REQS, max_chunks);
+        m = std::min(m, MAX_AIO_REQS);
+        return m;
+    }
+
+protected:
+    static std::map<std::string, nixlPosixFileApiCreateFn> apis;
+    static const uint32_t MIN_AIO_REQS;
+    static const uint32_t MAX_AIO_REQS;
+};
+
+#define NIXL_FILE_API_REGISTER(api_name, class_name)                    \
+    static std::unique_ptr<nixlPosixFileApi> class_name##Create(void) { \
+        return std::make_unique<class_name>();                          \
+    }                                                                   \
+    static const bool registered = []() {                               \
+        nixlPosixFileApi::registerApi(api_name, class_name##Create);    \
+        return true;                                                    \
+    }();
+
+#endif // FILE_API_H