Merge Go 1.26.0 (remote-tracking branch 'upstream/release-branch.go1.26') into tailscale.go1.26

Author: bradfitz

VERSION

@@ -1,2 +1,2 @@
-go1.26rc3
-time 2026-02-03T20:09:49Z
+go1.26.0
+time 2026-02-10T01:22:00Z

src/crypto/tls/conn.go

@@ -1531,7 +1531,7 @@ func (c *Conn) handshakeContext(ctx context.Context) (ret error) {
 	defer cancel()
 
 	if c.quic != nil {
-		c.quic.cancelc = handshakeCtx.Done()
+		c.quic.ctx = handshakeCtx
 		c.quic.cancel = cancel
 	} else if ctx.Done() != nil {
 		// Close the connection if ctx is canceled before the function returns.

src/crypto/tls/quic.go

@@ -162,7 +162,7 @@ type quicState struct {
 	started  bool
 	signalc  chan struct{}   // handshake data is available to be read
 	blockedc chan struct{}   // handshake is waiting for data, closed when done
-	cancelc  <-chan struct{} // handshake has been canceled
+	ctx      context.Context // handshake context
 	cancel   context.CancelFunc
 
 	waitingForDrain bool
@@ -261,10 +261,11 @@ func (q *QUICConn) NextEvent() QUICEvent {
 
 // Close closes the connection and stops any in-progress handshake.
 func (q *QUICConn) Close() error {
-	if q.conn.quic.cancel == nil {
+	if q.conn.quic.ctx == nil {
 		return nil // never started
 	}
 	q.conn.quic.cancel()
+	<-q.conn.quic.signalc
 	for range q.conn.quic.blockedc {
 		// Wait for the handshake goroutine to return.
 	}
@@ -511,20 +512,16 @@ func (c *Conn) quicWaitForSignal() error {
 	// Send on blockedc to notify the QUICConn that the handshake is blocked.
 	// Exported methods of QUICConn wait for the handshake to become blocked
 	// before returning to the user.
-	select {
-	case c.quic.blockedc <- struct{}{}:
-	case <-c.quic.cancelc:
-		return c.sendAlertLocked(alertCloseNotify)
-	}
+	c.quic.blockedc <- struct{}{}
 	// The QUICConn reads from signalc to notify us that the handshake may
 	// be able to proceed. (The QUICConn reads, because we close signalc to
 	// indicate that the handshake has completed.)
-	select {
-	case c.quic.signalc <- struct{}{}:
-		c.hand.Write(c.quic.readbuf)
-		c.quic.readbuf = nil
-	case <-c.quic.cancelc:
+	c.quic.signalc <- struct{}{}
+	if c.quic.ctx.Err() != nil {
+		// The connection has been canceled.
 		return c.sendAlertLocked(alertCloseNotify)
 	}
+	c.hand.Write(c.quic.readbuf)
+	c.quic.readbuf = nil
 	return nil
 }

src/crypto/tls/quic_test.go

@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"reflect"
 	"strings"
+	"sync"
 	"testing"
 )
 
@@ -480,6 +481,24 @@ func TestQUICStartContextPropagation(t *testing.T) {
 	}
 }
 
+func TestQUICContextCancelation(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	config := &QUICConfig{TLSConfig: testConfig.Clone()}
+	config.TLSConfig.MinVersion = VersionTLS13
+	cli := newTestQUICClient(t, config)
+	cli.conn.SetTransportParameters(nil)
+	srv := newTestQUICServer(t, config)
+	srv.conn.SetTransportParameters(nil)
+	// Verify that canceling the connection context concurrently does not cause any races.
+	// See https://go.dev/issue/77274.
+	var wg sync.WaitGroup
+	wg.Go(func() {
+		_ = runTestQUICConnection(ctx, cli, srv, nil)
+	})
+	wg.Go(cancel)
+	wg.Wait()
+}
+
 func TestQUICDelayedTransportParameters(t *testing.T) {
 	clientConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
 	clientConfig.TLSConfig.MinVersion = VersionTLS13

src/log/slog/multi_handler.go

@@ -17,8 +17,8 @@ func NewMultiHandler(handlers ...Handler) *MultiHandler {
 }
 
 // MultiHandler is a [Handler] that invokes all the given Handlers.
-// Its Enable method reports whether any of the handlers' Enabled methods return true.
-// Its Handle, WithAttr and WithGroup methods call the corresponding method on each of the enabled handlers.
+// Its Enabled method reports whether any of the handlers' Enabled methods return true.
+// Its Handle, WithAttrs and WithGroup methods call the corresponding method on each of the enabled handlers.
 type MultiHandler struct {
 	multi []Handler
 }

src/runtime/pprof/pprof.go

@@ -171,7 +171,6 @@ import (
 // holds a lock for 1s while 5 other goroutines are waiting for the entire
 // second to acquire the lock, its unlock call stack will report 5s of
 // contention.
-
 type Profile struct {
 	name  string
 	mu    sync.Mutex

src/simd/archsimd/_gen/simdgen/ops/Others/categories.yaml

@@ -83,7 +83,7 @@
 - go: SHA256TwoRounds
   commutative: false
   documentation: !string |-
-    // NAME does 2 rounds of B loop to calculate updated state variables in SHA1 algorithm defined in FIPS 180-4.
+    // NAME does 2 rounds of B loop to calculate updated state variables in SHA256 algorithm defined in FIPS 180-4.
     // x = {h, g, d, c}
     // y = {f, e, b, a}
     // z = {W0+K0, W1+K1}
@@ -95,14 +95,14 @@
 - go: SHA256Message1
   commutative: false
   documentation: !string |-
-    // NAME does the sigma and addtion of 1 in SHA1 algorithm defined in FIPS 180-4.
+    // NAME does the sigma and addition of 1 in SHA256 algorithm defined in FIPS 180-4.
     // x = {W0, W1, W2, W3}
     // y = {W4, 0, 0, 0}
     // result = {W0+σ(W1), W1+σ(W2), W2+σ(W3), W3+σ(W4)}
 - go: SHA256Message2
   commutative: false
   documentation: !string |-
-    // NAME does the sigma and addition of 3 in SHA1 algorithm defined in FIPS 180-4.
+    // NAME does the sigma and addition of 3 in SHA256 algorithm defined in FIPS 180-4.
     // x = result of 2
     // y = {0, 0, W14, W15}
     // result = {W16, W17, W18, W19}