runtime,syscall,internal/poll,os,sync: wasip1 poll_oneoff scheduler integration + net.FileListener

On wasip1 today every syscall.Read/Write blocks the entire wasm module — the
cooperative scheduler invokes poll_oneoff only for sleep/timer wakeups, and
there's no path from the net package to a working TCP server. This change
fixes both: it threads poll_oneoff through the scheduler's idle path so a
goroutine doing FD I/O parks instead of blocking the module, and it provides
enough internal/poll / os / syscall surface that upstream Go's
net.FileListener / net.FileConn works on a host-pre-opened TCP socket.

End to end:

  $ tinygo build -target=wasip1 -o tcpecho.wasm ./tcpecho.go
  $ wasmtime run -Spreview2=false -Stcplisten=127.0.0.1:9999 ./tcpecho.wasm &
  listening on FD 3

  $ echo hello | nc 127.0.0.1 9999
  hello                                  # echoed by the wasm

Concurrent connections work too — multiple nc clients hit the server back-to-
back; both got accepted and echoed while the cooperative scheduler kept
running goroutines parked on sock_recv. The tcpecho.go source is the minimal
upstream-Go-idiomatic TCP echo server, no TinyGo net override required:

  f := os.NewFile(3, "tcplisten")
  ln, _ := net.FileListener(f)
  for {
      c, _ := ln.Accept()
      go func(c net.Conn) { defer c.Close(); io.Copy(c, c) }(c)
  }

Architecture:

The cooperative scheduler's idle path now calls poll_oneoff with one combined
subscription array: a clock subscription for the next timer/sleep deadline,
plus one FD subscription per goroutine that's parked waiting on I/O.

  syscall.Read/Write ─EAGAIN─► internal/poll registry ─► task.Pause()
                                       │
                                       ▼
                  scheduler idle  ──►  pollIO(timeoutNs)
                                       │
                                       ├─ build subs: [clock, fd1, fd2, …]
                                       ├─ poll_oneoff(...)
                                       └─ wake matched tasks → run queue

Upstream net's net.FileListener(f) flow plumbs through these layers:

  1. (*os.File).PollFD() returns a cached *poll.FD stored in a new
     pfd pollFD field on the shared file struct. pollFD is a per-target
     alias — *poll.FD on wasip1, literal struct{} (zero bytes, non-
     trailing) on every other target.
  2. (*poll.FD).Copy() increments a SysFile refcount so f.Close() and
     ln.Close() cooperatively release the syscall FD.
  3. Upstream net/file_wasip1.go calls fd_fdstat_get_type (linknamed into
     our syscall) to detect FILETYPE_SOCKET_STREAM.
  4. Listener.Accept → (*poll.FD).Accept → syscall.Accept → sock_accept
     wasmimport. EAGAIN parks the goroutine via the runtime netpoll
     registry.
  5. Conn.Read/Write see isSocket() == true (cached SysFile.Filetype) and
     dispatch to sock_recv / sock_send direct wasmimports with park-on-
     EAGAIN + deadline support.
  6. Conn.Close triggers Shutdown (→ sock_shutdown) and refcount-aware
     Close.

Non-goals (deferred):

- net.Dial("tcp", ...), net.Listen("tcp", ...) — wasip1 has no
  sock_connect / bind / listen (only sock_accept / recv / send /
  shutdown). Outbound TCP requires the wasi-sockets proposal (preview2+)
  or a runtime-specific extension. The relevant stubs return ENOSYS so
  callers see a clean error.
- UDP / PacketConn — upstream's filePacketConn returns ENOPROTOOPT on
  wasip1.
- DNS resolution — FileListener / FileConn paths bypass the resolver
  entirely.
- wasip2 — uses pollable resources, structurally different. Future PR.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: achille-roussel

loader/goroot.go

@@ -246,6 +246,7 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
 		"internal/futex/":             false,
 		"internal/fuzz/":              false,
 		"internal/itoa":               false,
+		"internal/poll/":              false,
 		"internal/reflectlite/":       false,
 		"internal/gclayout":           false,
 		"internal/task/":              false,

src/internal/poll/export_test_wasip1.go

@@ -0,0 +1,45 @@
+//go:build wasip1
+
+// Internal-test helpers exposed via go:linkname so user code can drive
+// the deadline-aware Read/Write loop without becoming a stdlib package.
+// Not part of the public API; the names are intentionally awkward to
+// signal "for tests only".
+
+package poll
+
+import (
+	"syscall"
+	"time"
+)
+
+// pollTestReadWithDeadline opens a pollable FD wrapper for sysfd, sets
+// a read deadline d into the future, calls Read once, and returns
+// (n, err). Caller is responsible for closing sysfd.
+//
+//go:linkname pollTestReadWithDeadline
+func pollTestReadWithDeadline(sysfd int, d time.Duration, p []byte) (int, error) {
+	fd := &FD{Sysfd: sysfd, IsStream: true}
+	// Best-effort init; ignore error so a caller using a not-fcntl-able FD
+	// (stdin under wazero, etc.) still gets to test the deadline path on
+	// whatever park behaviour the runtime gives.
+	_ = fd.Init("test", true)
+	if err := fd.SetReadDeadline(time.Now().Add(d)); err != nil {
+		return 0, err
+	}
+	return fd.Read(p)
+}
+
+// pollTestSetNonblock toggles O_NONBLOCK on a raw sysfd. Useful in
+// tests when the caller wants to ensure the FD is in nonblocking mode
+// before calling pollTestReadWithDeadline (Init is best-effort and may
+// silently skip).
+//
+//go:linkname pollTestSetNonblock
+func pollTestSetNonblock(sysfd int) error {
+	flags, err := syscall.Fcntl(sysfd, syscall.F_GETFL, 0)
+	if err != nil {
+		return err
+	}
+	_, err = syscall.Fcntl(sysfd, syscall.F_SETFL, flags|syscall.O_NONBLOCK)
+	return err
+}