Implement event loop based on QNX ionotify

CMakeLists.txt

@@ -141,6 +141,14 @@ elseif (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD" OR CMAKE_SYSTEM_NAME STREQUAL "NetB
     set(EVENT_LOOP_DEFINE "KQUEUE")
     set(USE_S2N ON)
 
+elseif(CMAKE_SYSTEM_NAME STREQUAL "QNX")
+    file(GLOB AWS_IO_OS_SRC
+            "source/qnx/*.c"
+            "source/posix/*.c"
+            )
+    set(EVENT_LOOP_DEFINE "IONOTIFY")
+    set(USE_S2N ON)
+    list(APPEND PLATFORM_LIBS "socket")
 endif()
 
 if (BYO_CRYPTO)
@@ -231,7 +239,7 @@ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
         DESTINATION "${LIBRARY_DIRECTORY}/${PROJECT_NAME}/cmake/"
         COMPONENT Development)
 
-if (NOT CMAKE_CROSSCOMPILING)
+if (NOT CMAKE_CROSSCOMPILING OR AWS_BUILD_QNX_TESTS)
     if (BUILD_TESTING)
        add_subdirectory(tests)
     endif()

include/aws/io/io.h

@@ -14,12 +14,37 @@ AWS_PUSH_SANE_WARNING_LEVEL
 
 #define AWS_C_IO_PACKAGE_ID 1
 
+struct aws_io_handle;
+
+struct aws_event_loop;
+
+/**
+ * Results of the I/O operation(s) performed on the aws_io_handle.
+ */
+struct aws_io_handle_io_op_result {
+    size_t read_bytes;
+    size_t written_bytes;
+    /** Error codes representing generic errors happening on I/O handles. */
+    int error_code;
+    /** Error codes specific to reading operations. */
+    int read_error_code;
+    /** Error codes specific to writing operations. */
+    int write_error_code;
+};
+
+typedef void(aws_io_handle_update_io_results_fn)(
+    struct aws_event_loop *,
+    struct aws_io_handle *,
+    const struct aws_io_handle_io_op_result *);
+
 struct aws_io_handle {
     union {
         int fd;
         void *handle;
     } data;
     void *additional_data;
+    /* Optional callback to return results of I/O operations performed on this handle. */
+    aws_io_handle_update_io_results_fn *update_io_result;
 };
 
 enum aws_io_message_type {

source/posix/pipe.c

@@ -278,9 +278,22 @@ int aws_pipe_read(struct aws_pipe_read_end *read_end, struct aws_byte_buf *dst_b
     if (read_val < 0) {
         int errno_value = errno; /* Always cache errno before potential side-effect */
         if (errno_value == EAGAIN || errno_value == EWOULDBLOCK) {
+            if (read_impl->handle.update_io_result) {
+                struct aws_io_handle_io_op_result io_op_result;
+                AWS_ZERO_STRUCT(io_op_result);
+                io_op_result.read_error_code = AWS_IO_READ_WOULD_BLOCK;
+                read_impl->handle.update_io_result(read_impl->event_loop, &read_impl->handle, &io_op_result);
+            }
             return aws_raise_error(AWS_IO_READ_WOULD_BLOCK);
         }
         return s_raise_posix_error(errno_value);
+    } else if (read_val == 0) {
+        if (read_impl->handle.update_io_result) {
+            struct aws_io_handle_io_op_result io_op_result;
+            AWS_ZERO_STRUCT(io_op_result);
+            io_op_result.error_code = AWS_IO_SOCKET_CLOSED;
+            read_impl->handle.update_io_result(read_impl->event_loop, &read_impl->handle, &io_op_result);
+        }
     }
 
     /* Success */
@@ -454,6 +467,14 @@ static void s_write_end_process_requests(struct aws_pipe_write_end *write_end) {
                 if (errno_value == EAGAIN || errno_value == EWOULDBLOCK) {
                     /* The pipe is no longer writable. Bail out */
                     write_impl->is_writable = false;
+
+                    if (write_impl->handle.update_io_result) {
+                        struct aws_io_handle_io_op_result io_op_result;
+                        AWS_ZERO_STRUCT(io_op_result);
+                        io_op_result.write_error_code = AWS_IO_READ_WOULD_BLOCK;
+                        write_impl->handle.update_io_result(write_impl->event_loop, &write_impl->handle, &io_op_result);
+                    }
+
                     return;
                 }
 

source/posix/socket.c

@@ -476,6 +476,14 @@ static void s_socket_connect_event(
                 "id=%p fd=%d: spurious event, waiting for another notification.",
                 (void *)socket_args->socket,
                 handle->data.fd);
+
+            if (handle->update_io_result) {
+                struct aws_io_handle_io_op_result io_op_result;
+                AWS_ZERO_STRUCT(io_op_result);
+                io_op_result.read_error_code = AWS_IO_READ_WOULD_BLOCK;
+                handle->update_io_result(event_loop, handle, &io_op_result);
+            }
+
             return;
         }
 
@@ -955,6 +963,9 @@ static void s_socket_accept_event(
     AWS_LOGF_DEBUG(
         AWS_LS_IO_SOCKET, "id=%p fd=%d: listening event received", (void *)socket, socket->io_handle.data.fd);
 
+    struct aws_io_handle_io_op_result io_op_result;
+    AWS_ZERO_STRUCT(io_op_result);
+
     if (socket_impl->continue_accept && events & AWS_IO_EVENT_TYPE_READABLE) {
         int in_fd = 0;
         while (socket_impl->continue_accept && in_fd != -1) {
@@ -966,12 +977,14 @@ static void s_socket_accept_event(
                 int errno_value = errno; /* Always cache errno before potential side-effect */
 
                 if (errno_value == EAGAIN || errno_value == EWOULDBLOCK) {
+                    io_op_result.read_error_code = AWS_IO_READ_WOULD_BLOCK;
                     break;
                 }
 
                 int aws_error = aws_socket_get_error(socket);
                 aws_raise_error(aws_error);
                 s_on_connection_error(socket, aws_error);
+                io_op_result.read_error_code = aws_error;
                 break;
             }
 
@@ -1064,6 +1077,10 @@ static void s_socket_accept_event(
         }
     }
 
+    if (handle->update_io_result) {
+        handle->update_io_result(event_loop, handle, &io_op_result);
+    }
+
     AWS_LOGF_TRACE(
         AWS_LS_IO_SOCKET,
         "id=%p fd=%d: finished processing incoming connections, "
@@ -1632,6 +1649,9 @@ static int s_process_socket_write_requests(struct aws_socket *socket, struct soc
     bool parent_request_failed = false;
     bool pushed_to_written_queue = false;
 
+    struct aws_io_handle_io_op_result io_op_result;
+    AWS_ZERO_STRUCT(io_op_result);
+
     /* if a close call happens in the middle, this queue will have been cleaned out from under us. */
     while (!aws_linked_list_empty(&socket_impl->write_queue)) {
         struct aws_linked_list_node *node = aws_linked_list_front(&socket_impl->write_queue);
@@ -1660,6 +1680,7 @@ static int s_process_socket_write_requests(struct aws_socket *socket, struct soc
             if (errno_value == EAGAIN) {
                 AWS_LOGF_TRACE(
                     AWS_LS_IO_SOCKET, "id=%p fd=%d: returned would block", (void *)socket, socket->io_handle.data.fd);
+                io_op_result.write_error_code = AWS_IO_READ_WOULD_BLOCK;
                 break;
             }
 
@@ -1672,6 +1693,7 @@ static int s_process_socket_write_requests(struct aws_socket *socket, struct soc
                 aws_error = AWS_IO_SOCKET_CLOSED;
                 aws_raise_error(aws_error);
                 purge = true;
+                io_op_result.write_error_code = aws_error;
                 break;
             }
 
@@ -1684,9 +1706,12 @@ static int s_process_socket_write_requests(struct aws_socket *socket, struct soc
                 errno_value);
             aws_error = s_determine_socket_error(errno_value);
             aws_raise_error(aws_error);
+            io_op_result.write_error_code = aws_error;
             break;
         }
 
+        io_op_result.written_bytes += (size_t)written;
+
         size_t remaining_to_write = write_request->cursor_cpy.len;
 
         aws_byte_cursor_advance(&write_request->cursor_cpy, (size_t)written);
@@ -1732,6 +1757,10 @@ static int s_process_socket_write_requests(struct aws_socket *socket, struct soc
         aws_event_loop_schedule_task_now(socket->event_loop, &socket_impl->written_task);
     }
 
+    if (socket->io_handle.update_io_result) {
+        socket->io_handle.update_io_result(socket->event_loop, &socket->io_handle, &io_op_result);
+    }
+
     /* Only report error if aws_socket_write() invoked this function and its write_request failed */
     if (!parent_request_failed) {
         return AWS_OP_SUCCESS;