extmod/modlwip: Return a partial or ENOBUFS from a non-blocking send - #19705

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 98.59%. Comparing base (cc12057) to head (9cdfb4e).
⚠️ Report is 4 commits behind head on master.

@@            Coverage Diff             @@
##           master   #19705      +/-   ##
==========================================
+ Coverage   98.55%   98.59%   +0.03%     
==========================================
  Files         182      182              
  Lines       23335    23335              
  Branches        5        5              
==========================================
+ Hits        22998    23006       +8     
+ Misses        336      328       -8     
  Partials        1        1              

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

Code size report:

Reference:  rp2: Keep machine.RTC ticking while in lightsleep(). [cc12057]
Comparison: extmod/modlwip: Return a partial or ENOBUFS from a non-blocking send. [merge of 9cdfb4e]
  mpy-cross:    +0 +0.000% 
   bare-arm:    +0 +0.000% 
minimal x86:    +0 +0.000% 
   unix x64:    +0 +0.000% standard
      stm32:    +0 +0.000% PYBV10
      esp32:    +0 +0.000% ESP32_GENERIC
     mimxrt:    +0 +0.000% TEENSY40
        rp2:   +16 +0.002% RPI_PICO_W
       samd:    +0 +0.000% ADAFRUIT_ITSYBITSY_M4_EXPRESS
  qemu rv32:    +0 +0.000% VIRT_RV32

@dpgeorge, thank you for the review.

There is an issue with ENOBUFS: mp_is_nonblocking_error accepts only EAGAIN/EWOULDBLOCK, so ENOBUFS would propagate out of asyncio's Stream.drain() and fail the mbedtls send callback. Therefore:

• switched to EAGAIN; the check now sits where poll_sockets() was.
• the halving retry is gone too: with Nagle on, tcp_pbuf_prealloc allocates a full-MSS pbuf regardless of length, so it only reduced the segment count.

Prior art, read from source: lwIP's own netconn returns ERR_WOULDBLOCK from lwip_netconn_do_writemore on ERR_MEM, and Linux returns EAGAIN from sk_stream_wait_memory; both then gate socket writability with a per-socket rule (NETCONN_FLAG_CHECK_WRITESPACE low-water marks, sk_stream_moderate_sndbuf), which cannot see memory held by another socket.

PR reworked, three commits:

1. A non-blocking send blocked on ERR_MEM: the loop now returns EAGAIN for a non-blocking socket; nothing is queued, and the caller retries. Previously, write() blocked up to 10 s and raised ENOMEM.

2. The socket timeout did not cover the whole send: one start tick now covers both the tcp_sndbuf == 0 wait and the ERR_MEM loop; ETIMEDOUT is returned at the timeout. The 10 s limit applies only to a socket with no timeout. Previously, the loop ended only at 10 s with ENOMEM, and each wait used its own clock, so a send could take about 2× the timeout.

3. POLLOUT reported writable after that EAGAIN: it now requires one segment's memory: a pbuf of mss bytes, one tcp_seg tried and released, and a free slot in snd_queuelen. The send retries once at a single MSS before returning EAGAIN. Previously, POLLOUT only checked tcp_sndbuf > 0, so the next write() failed again. Cost: one mem_malloc/mem_free and one memp_malloc/memp_free per poll on a socket that has seen ERR_MEM; nothing on any other poll.

Tested on an OpenMV RT1062 (cyw43 Wi-Fi), v1.28-based tree with the same change on its mp_hal_delay_ms(50) loop:

• EAGAIN return: one reader throttled to 20 KB/s, 320 s: worst write() 1553086 us and 54 events over 100 ms before; 1264–1316 us and 0 events after, five runs.
• Socket timeout: two readers oversubscribing the 16 KB lwIP heap, settimeout(0.5), 240 s: 390 ETIMEDOUT, 0 ENOMEM.
• POLLOUT gate: same two readers, a non-blocking socket polling POLLOUT after each EAGAIN, 240 s: the low-water rule answered writable and the next write failed on 1780 of 3509 polls; the allocation gate on 0 of 3016, with 3294 chunks written against 1566.