quic: establish a "happened-before" relationship between stream write and read

This ensures that our race detector will not get tripped off in tests
where we do something like the following:

1. Client writes to a shared variable.
2. Client sends a request to a server.
3. Server handler reads the shared variable.

We are technically over-synchronizing right now by always using the
address of quicSync when calling runtime.RaceAcquire and
runtime.RaceReleaseMerge. However, that is fine for now since this
mostly matters just for testing, and creating a mapping of stream ID to
addressess are rather unclean.

For golang/go#78737

Change-Id: Id65964ad3aa0b2e998e8faf11bfda3c76a6a6964
Reviewed-on: https://go-review.googlesource.com/c/net/+/777940
LUCI-TryBot-Result: golang-scoped@luci-project-accounts.iam.gserviceaccount.com <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Damien Neil <dneil@google.com>
Reviewed-by: Nicholas Husin <husin@google.com>

Author: nicholashusin

quic/race_disabled.go

@@ -0,0 +1,10 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !race
+
+package quic
+
+func raceAcquire()      {}
+func raceReleaseMerge() {}

quic/race_enabled.go

@@ -0,0 +1,27 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build race
+
+package quic
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+// Our synchronization here is rather coarse-grained since we always use the
+// address of quicSync. As such, it will not differentiate between, for
+// example, reads and writes to different QUIC streams.
+// However, this is consistent with our synchronization for net/http, and
+// mostly only matters for testing.
+var quicSync uint64
+
+func raceAcquire() {
+	runtime.RaceAcquire(unsafe.Pointer(&quicSync))
+}
+
+func raceReleaseMerge() {
+	runtime.RaceReleaseMerge(unsafe.Pointer(&quicSync))
+}

quic/stream.go

@@ -246,8 +246,8 @@ func (s *Stream) Read(b []byte) (n int, err error) {
 	fastPath := false
 	s.inbufmu.Lock()
 	if len(s.inbuf) > s.inbufoff {
-		// Fast path: If s.inbuf contains unread bytes, return them immediately
-		// without taking a lock.
+		// Fast path: If s.inbuf contains unread bytes, return them
+		// immediately.
 		n = copy(b, s.inbuf[s.inbufoff:])
 		s.inbufoff += n
 		fastPath = true
@@ -302,6 +302,7 @@ func (s *Stream) Read(b []byte) (n int, err error) {
 	bytesRead = int64(len(b))
 	start := s.in.start
 	end := start + int64(len(b))
+	raceAcquire()
 	s.in.copy(start, b)
 	s.in.discardBefore(end)
 	if end == s.insize {
@@ -462,6 +463,7 @@ func (s *Stream) Write(b []byte) (n int, err error) {
 		}
 		s.outbufmu.Unlock()
 	}
+	raceReleaseMerge()
 	s.outUnlock()
 	return n, nil
 }

quic/stream_test.go

@@ -1623,6 +1623,50 @@ func TestStreamInbufReadRace(t *testing.T) {
 	})
 }
 
+// TestStreamWriteHappensBeforeRead verifies that a write to a stream
+// establishes a happens-before relationship with a read from the stream, as
+// seen by the race detector.
+func TestStreamWriteHappensBeforeRead(t *testing.T) {
+	// Use real UDP sockets via newLocalConnPair to avoid the synchronization
+	// inherent in the channel-based testConn infrastructure.
+	cli, srv := newLocalConnPair(t, &Config{}, &Config{})
+	var written bool
+	var wg sync.WaitGroup
+	defer wg.Wait()
+	wg.Go(func() {
+		s, err := srv.AcceptStream(t.Context())
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer s.Close()
+
+		if _, err := io.ReadFull(s, make([]byte, 1)); err != nil {
+			t.Fatal(err)
+		}
+
+		// Access shared variable after reading from stream. If the stream read
+		// doesn't establish happens-before with the stream write, this will be
+		// flagged as a data race.
+		if !written {
+			t.Error("written is false, want true")
+		}
+	})
+
+	s, err := cli.NewSendOnlyStream(t.Context())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer s.Close()
+
+	written = true // Write shared variable
+	// Write to stream. This should happen-before the read of x in the
+	// goroutine.
+	_, err = s.Write([]byte{1})
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
 type streamSide string
 
 const (