Localhost Relay: non-blocking IO on Linux side, IOCP with fully async reads and writes on Windows side

[wangxin12]

Summary of the Pull Request

Linux — non-blocking poll-based state machine:

• Switch both sockets to O_NONBLOCK via fcntl
• Per-direction RelayDirection buffers with head/tail cursors
• poll() loop that independently tracks read-readiness and write-readiness per direction
• Back-pressure via Available() > 0 guard (buffer full → stop reading → TCP flow control throttles sender)
• Compact() to handle short writes (slides unwritten data to buffer front)
• Proper TCP half-close: each direction drains independently, calls shutdown(SHUT_WR) when done
• POLLIN checked before POLLERR/POLLHUP on read entries to drain buffered data at EOF

Windows — IOCP with fully async reads and writes:

• Replace WaitForMultipleObjects + InterruptableWrite with CreateIoCompletionPort + GetQueuedCompletionStatus
• Per-direction RelayDirection with separate IoContext (extended OVERLAPPED) for read and write
• Pipelined I/O: async read and write can run concurrently on the same direction's buffer (read appends at Tail, write consumes from Head, no overlap)
• Buffer reset guard: Head = Tail = 0 only when Pending() == 0 && !ReadPending to prevent offset corruption with concurrent async operations
• Proper TCP half-close: shutdown(SD_SEND) when a direction completes, other direction continues
• Scope guard cancels all pending I/O and drains IOCP on exit

Testing

• Verified with full duplex TCP stress test (50,000 x 32KB frames each direction)
• TCP half-close works end-to-end: one direction can finish while the other continues
• No sequence errors, no data corruption

Without the change, the test tool hangs.

PR Checklist

• Closes: Link to issue Blocking I/O behavior in localhost relay hangs with full duplex traffic due to half duplex forwarding logic. #10688
• Communication: I've discussed this with core contributors already. If work hasn't been agreed, this work might be rejected
• Tests: Added/updated if needed and all pass
• Localization: All end user facing strings can be localized
• Dev docs: Added/updated if needed
• Documentation updated: If checked, please file a pull request on our docs repo and link it here: #xxx

Detailed Description of the Pull Request / Additional comments

Validation Steps Performed

[Copilot]

Pull request overview

Note

Copilot was unable to run its full agentic suite in this review.

Refactors the localhost relay implementation to use non-blocking, back-pressure-aware I/O on Linux and IOCP-based fully asynchronous I/O on Windows, improving full-duplex throughput and correct half-close behavior.

Changes:

• Windows: replaced wait/event-based overlapped I/O with IOCP dispatch and per-direction read/write state machines.
• Linux: switched sockets to non-blocking mode and implemented a poll-driven relay with per-direction buffering and compaction.
• Added per-direction half-close handling so each direction can complete independently.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 4 comments.

File	Description
src/windows/common/relay.cpp	Reworks BidirectionalRelay to use IOCP with per-direction async read/write contexts and completion processing.
src/linux/init/localhost.cpp	Implements a non-blocking poll() relay loop with per-direction buffers, back-pressure, and half-close support.

[guanwenbin123]

“Thanks for the notification. Update received.” 获取 Outlook for iOS<https://aka.ms/o0ukef>

________________________________ 发件人: wangxin12 ***@***.***> 发送时间: Tuesday, April 14, 2026 5:43:42 AM 收件人: microsoft/WSL ***@***.***> 抄送: Subscribed ***@***.***> 主题: Re: [microsoft/WSL] Localhost Relay: non-blocking IO on Linux side, IOCP with fully async reads and writes on Windows side (PR #40171) @wangxin12 commented on this pull request.

________________________________ In src/linux/init/localhost.cpp<#40171 (comment)>:

+ if (pfds[j].events & POLLOUT)

{ - bytesRead = UtilReadBuffer(pollDescriptors[Index].fd, buffer); - if (bytesRead == 0) + // can't write to dstFd any more + if (pfds[j].revents & (POLLERR | POLLHUP)) { - pollDescriptors[Index].fd = -1; - shutdown(outFd[Index], SHUT_WR); + d.done = true; + continue; } - else if (bytesRead < 0) + + if (!(pfds[j].revents & POLLOUT)) { - return; + continue; + } Both fds are owned by unique_fd and are never closed during the relay loop, so POLLNVAL cannot occur. ― Reply to this email directly, view it on GitHub<#40171 (comment)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/B677FUKLYOJS6P74H5GV4N34VVNQZAVCNFSM6AAAAACXXZYSQCVHI2DSMVQWIX3LMV43YUDVNRWFEZLROVSXG5CSMV3GSZLXHM2DCMBSGEYTOMJXGM>. You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[chemwolf6922]

Could simplify the logic to wait for the buffer to be empty before accepting any reads. This shouldn't be a huge performance penalty as there is already a read buffer in the kernel.

[chemwolf6922]

Should do a write here. There is no need to set the write handler most of the time.

[chemwolf6922]

nit: Consider use directions and direction instead of dir and d?

[chemwolf6922]

Instead of labeling this as done. Consider remove this direction from the array to release resources.

[chemwolf6922]

Should half close the read end?

[chemwolf6922]

Could put half close of both the read and write end in the destructor. Then there is no need to do this complex state tracking.

[chemwolf6922]

@guanwenbin123 Hi, could you please configure your auto reply so it does not create a message for every wsl update? Thanks.