AbstractUringUnsafe Class — netty Architecture

Source Code

transport-classes-io_uring/src/main/java/io/netty/channel/uring/AbstractIoUringChannel.java lines 432–1167

    protected abstract class AbstractUringUnsafe extends AbstractUnsafe implements IoUringIoHandle {
        private IoUringRecvByteAllocatorHandle allocHandle;
        private boolean closed;
        private boolean socketIsEmpty;

        /**
         * Schedule the write of multiple messages in the {@link ChannelOutboundBuffer} and returns the number of
         * {@link #writeComplete(byte, int, int, short)} calls that are expected because of the scheduled write.
         */
        protected abstract int scheduleWriteMultiple(ChannelOutboundBuffer in);

        /**
         * Schedule the write of a single message and returns the number of
         * {@link #writeComplete(byte, int, int, short)} calls that are expected because of the scheduled write.
         */
        protected abstract int scheduleWriteSingle(Object msg);

        @Override
        public final void handle(IoRegistration registration, IoEvent ioEvent) {
            IoUringIoEvent event = (IoUringIoEvent) ioEvent;
            byte op = event.opcode();
            int res = event.res();
            int flags = event.flags();
            short data = event.data();
            switch (op) {
                case Native.IORING_OP_RECV:
                case Native.IORING_OP_ACCEPT:
                case Native.IORING_OP_RECVMSG:
                case Native.IORING_OP_READ:
                    readComplete(op, res, flags, data);
                    break;
                case Native.IORING_OP_WRITEV:
                case Native.IORING_OP_SEND:
                case Native.IORING_OP_SENDMSG:
                case Native.IORING_OP_WRITE:
                case Native.IORING_OP_SPLICE:
                case Native.IORING_OP_SEND_ZC:
                case Native.IORING_OP_SENDMSG_ZC:
                    writeComplete(op, res, flags, data);
                    break;
                case Native.IORING_OP_POLL_ADD:
                    pollAddComplete(res, flags, data);
                    break;
                case Native.IORING_OP_ASYNC_CANCEL:
                    cancelComplete0(op, res, flags, data);
                    break;
                case Native.IORING_OP_CONNECT:
                    connectComplete(op, res, flags, data);

                    // once the connect was completed we can also free some resources that are not needed anymore.
                    freeMsgHdrArray();
                    freeRemoteAddressMemory();
                    break;
                case Native.IORING_OP_CLOSE:
                    if (res != Native.ERRNO_ECANCELED_NEGATIVE) {
                        if (delayedClose != null) {
                            delayedClose.promise.setSuccess();
                        }
                        closed = true;
                    }
                    break;
                default:
                    break;
            }

            // We delay the actual close if there is still a write or read scheduled, let's see if there
            // was a close that needs to be done now.
            handleDelayedClosed();

            if (ioState == 0 && closed) {
                // Cancel the registration now.
                registration.cancel();
            }
        }

        @Override
        public void unregistered() {
            freeMsgHdrArray();
            freeRemoteAddressMemory();
        }