AbstractIoUringServerChannel Class — netty Architecture

Source Code

transport-classes-io_uring/src/main/java/io/netty/channel/uring/AbstractIoUringServerChannel.java lines 36–300

abstract class AbstractIoUringServerChannel extends AbstractIoUringChannel implements ServerChannel {
    private static final ChannelMetadata METADATA = new ChannelMetadata(false, 16);

    private static final class AcceptedAddressMemory {
        private final CleanableDirectBuffer acceptedAddressMemoryCleanable;
        private final ByteBuffer acceptedAddressMemory;
        private final CleanableDirectBuffer acceptedAddressLengthMemoryCleanable;
        private final ByteBuffer acceptedAddressLengthMemory;
        private final long acceptedAddressMemoryAddress;
        private final long acceptedAddressLengthMemoryAddress;

        AcceptedAddressMemory() {
            acceptedAddressMemoryCleanable = Buffer.allocateDirectBufferWithNativeOrder(Native.SIZEOF_SOCKADDR_STORAGE);
            acceptedAddressMemory = acceptedAddressMemoryCleanable.buffer();
            acceptedAddressMemoryAddress = Buffer.memoryAddress(acceptedAddressMemory);
            acceptedAddressLengthMemoryCleanable = Buffer.allocateDirectBufferWithNativeOrder(Long.BYTES);
            acceptedAddressLengthMemory = acceptedAddressLengthMemoryCleanable.buffer();
            // Needs to be initialized to the size of acceptedAddressMemory.
            // See https://man7.org/linux/man-pages/man2/accept.2.html
            acceptedAddressLengthMemory.putLong(0, Native.SIZEOF_SOCKADDR_STORAGE);
            acceptedAddressLengthMemoryAddress = Buffer.memoryAddress(acceptedAddressLengthMemory);
        }

        void free() {
            acceptedAddressMemoryCleanable.clean();
            acceptedAddressLengthMemoryCleanable.clean();
        }
    }
    private final AcceptedAddressMemory acceptedAddressMemory;
    private long acceptId;

    protected AbstractIoUringServerChannel(LinuxSocket socket, boolean active) {
        super(null, socket, active);

        // We can only depend on the accepted address if multi-shot is not used.
        // From the manpage:
        //       The multishot variants allow an application to issue a single
        //       accept request, which will repeatedly trigger a CQE when a
        //       connection request comes in. Like other multishot type requests,
        //       the application should look at the CQE flags and see if
        //       IORING_CQE_F_MORE is set on completion as an indication of whether
        //       or not the accept request will generate further CQEs. Note that
        //       for the multishot variants, setting addr and addrlen may not make
        //       a lot of sense, as the same value would be used for every accepted
        //       connection. This means that the data written to addr may be
        //       overwritten by a new connection before the application has had
        //       time to process a past connection. If the application knows that a
        //       new connection cannot come in before a previous one has been
        //       processed, it may be used as expected.
        if (IoUring.isAcceptMultishotEnabled()) {
            acceptedAddressMemory = null;
        } else {
            acceptedAddressMemory = new AcceptedAddressMemory();
        }
    }

    @Override
    public final ChannelMetadata metadata() {
        return METADATA;
    }

    @Override
    protected final void doClose() throws Exception {
        super.doClose();
    }

    @Override
    protected final AbstractUringUnsafe newUnsafe() {
        return new UringServerChannelUnsafe();
    }

    @Override
    protected final void doWrite(ChannelOutboundBuffer in) {
        throw new UnsupportedOperationException();
    }

    @Override
    protected final void cancelOutstandingReads(IoRegistration registration, int numOutstandingReads) {
        if (acceptId != 0) {
            assert numOutstandingReads == 1 || numOutstandingReads == -1;
            IoUringIoOps ops = IoUringIoOps.newAsyncCancel((byte) 0, acceptId, Native.IORING_OP_ACCEPT);