readComplete() — netty Function Reference

Source Code

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

        private void readComplete(byte op, int res, int flags, short data) {
            assert numOutstandingReads > 0 || numOutstandingReads == -1 : numOutstandingReads;

            boolean multishot = numOutstandingReads == -1;
            boolean rearm = (flags & Native.IORING_CQE_F_MORE) == 0;
            if (rearm) {
                // Reset READ_SCHEDULED if there is nothing more to handle and so we need to re-arm. This works for
                // multi-shot and non multi-shot variants.
                ioState &= ~READ_SCHEDULED;
            }
            boolean pending = readPending;
            if (multishot) {
                // Reset readPending so we can still keep track if we might need to cancel the multi-shot read or
                // not.
                readPending = false;
            } else if (--numOutstandingReads == 0) {
                // We received all outstanding completions.
                readPending = false;
                ioState &= ~READ_SCHEDULED;
            }
            inReadComplete = true;
            try {
                socketIsEmpty = socketIsEmpty(flags);
                socketHasMoreData = IoUring.isCqeFSockNonEmptySupported() &&
                        (flags & Native.IORING_CQE_F_SOCK_NONEMPTY) != 0;
                readComplete0(op, res, flags, data, numOutstandingReads);
            } finally {
                try {
                    // Check if we should consider the read loop to be done.
                    if (recvBufAllocHandle().isReadComplete()) {
                        // Reset the handle as we are done with the read-loop.
                        recvBufAllocHandle().reset(config());

                        // Check if this was a readComplete(...) triggered by a read or multi-shot read.
                        if (!multishot) {
                            if (readPending) {
                                // This was a "normal" read and the user did signal we should continue reading.
                                // Let's schedule the read now.
                                doBeginReadNow();
                            }
                        } else {
                            // The readComplete(...) was triggered by a multi-shot read. Because of this the state
                            // machine is a bit more complicated.

                            if (res == Native.ERRNO_ECANCELED_NEGATIVE) {
                                // The readComplete(...) was triggered because the previous read was cancelled.
                                // In this case we we need to check if the user did signal the desire to read again
                                // in the meantime. If this is the case we need to schedule the read to ensure
                                // we do not stall.
                                if (pending) {
                                    doBeginReadNow();
                                }
                            } else if (rearm) {
                                // We need to rearm the multishot as otherwise we might miss some data.
                                doBeginReadNow();
                            } else if (!readPending) {
                                // Cancel the multi-shot read now as the user did not signal that we want to keep
                                // reading while we handle the completion event.
                                cancelOutstandingReads(registration, numOutstandingReads);
                            }
                        }
                    } else if (res == Native.ERRNO_ECANCELED_NEGATIVE) {
                        // The readComplete(...) was triggered because the previous read was cancelled.
                        // In this case we we need to check if the user did signal the desire to read again
                        // in the meantime. If this is the case we need to schedule the read to ensure
                        // we do not stall.
                        if (pending) {
                            doBeginReadNow();
                        }
                    } else if (multishot && rearm) {
                        // We need to rearm the multishot as otherwise we might miss some data.
                        doBeginReadNow();
                    }
                } finally {
                    inReadComplete = false;
                    socketIsEmpty = false;
                }
            }
        }