netstack: remove mention of the long-dead protocol goroutine

Bhasker removed this years ago.

PiperOrigin-RevId: 698915055

Author: kevinGC

pkg/tcpip/transport/tcp/connect.go

@@ -40,10 +40,10 @@ const (
 	// https://github.com/torvalds/linux/blob/7c636d4d20f/include/net/tcp.h#L142
 	InitialRTO = time.Second
 
-	// maxSegmentsPerWake is the maximum number of segments to process in the main
-	// protocol goroutine per wake-up. Yielding [after this number of segments are
-	// processed] allows other events to be processed as well (e.g., timeouts,
-	// resets, etc.).
+	// maxSegmentsPerWake is the maximum number of segments to process per
+	// wake-up. Yielding [after this number of segments are processed]
+	// allows other events to be processed as well (e.g., timeouts, resets,
+	// etc.).
 	maxSegmentsPerWake = 100
 )
 
@@ -543,7 +543,7 @@ func (h *handshake) processSegments() tcpip.Error {
 
 		// We stop processing packets once the handshake is completed,
 		// otherwise we may process packets meant to be processed by
-		// the main protocol goroutine.
+		// the TCP processor goroutine.
 		if h.state == handshakeCompleted {
 			break
 		}
@@ -1032,8 +1032,7 @@ func (e *Endpoint) sendData(next *segment) {
 
 // resetConnectionLocked puts the endpoint in an error state with the given
 // error code and sends a RST if and only if the error is not ErrConnectionReset
-// indicating that the connection is being reset due to receiving a RST. This
-// method must only be called from the protocol goroutine.
+// indicating that the connection is being reset due to receiving a RST.
 // +checklocks:e.mu
 func (e *Endpoint) resetConnectionLocked(err tcpip.Error) {
 	// Only send a reset if the connection is being aborted for a reason
@@ -1167,10 +1166,6 @@ func (e *Endpoint) handleReset(s *segment) (ok bool, err tcpip.Error) {
 			// except SYN-SENT, all reset (RST) segments are
 			// validated by checking their SEQ-fields." So
 			// we only process it if it's acceptable.
-
-			// Notify protocol goroutine. This is required when
-			// handleSegment is invoked from the processor goroutine
-			// rather than the worker goroutine.
 			return false, &tcpip.ErrConnectionReset{}
 		}
 	}
@@ -1292,12 +1287,7 @@ func (e *Endpoint) handleSegmentLocked(s *segment) (cont bool, err tcpip.Error)
 		state := e.EndpointState()
 		if state == StateClose {
 			// When we get into StateClose while processing from the queue,
-			// return immediately and let the protocolMainloop handle it.
-			//
-			// We can reach StateClose only while processing a previous segment
-			// or a notification from the protocolMainLoop (caller goroutine).
-			// This means that with this return, the segment dequeue below can
-			// never occur on a closed endpoint.
+			// return immediately and let the TCP processors handle it.
 			return false, nil
 		}
 

pkg/tcpip/transport/tcp/endpoint.go

@@ -287,10 +287,6 @@ func (*Stats) IsEndpointStats() {}
 type sndQueueInfo struct {
 	sndQueueMu sync.Mutex `state:"nosave"`
 	stack.TCPSndBufState
-
-	// sndWaker is used to signal the protocol goroutine when there may be
-	// segments that need to be sent.
-	sndWaker sleep.Waker `state:"manual"`
 }
 
 // CloneState clones sq into other. It is not thread safe
@@ -524,8 +520,6 @@ type Endpoint struct {
 	// +checklocks:acceptMu
 	acceptQueue acceptQueue
 
-	// The following are only used from the protocol goroutine, and
-	// therefore don't need locks to protect them.
 	rcv *receiver `state:"wait"`
 	snd *sender   `state:"wait"`
 
@@ -1450,8 +1444,7 @@ func (e *Endpoint) Read(dst io.Writer, opts tcpip.ReadOptions) (tcpip.ReadResult
 			if memDelta > 0 {
 				// If the window was small before this read and if the read freed up
 				// enough buffer space, to either fit an aMSS or half a receive buffer
-				// (whichever smaller), then notify the protocol goroutine to send a
-				// window update.
+				// (whichever smaller), then send a window update.
 				if crossed, above := e.windowCrossedACKThresholdLocked(memDelta, int(e.ops.GetReceiveBufferSize())); crossed && above {
 					sendNonZeroWindowUpdate = true
 				}
@@ -2475,7 +2468,6 @@ func (e *Endpoint) connect(addr tcpip.FullAddress, handshake bool) tcpip.Error {
 		for _, l := range []segmentList{e.segmentQueue.list, e.snd.writeList} {
 			for s := l.Front(); s != nil; s = s.Next() {
 				s.id = e.TransportEndpointInfo.ID
-				e.sndQueueInfo.sndWaker.Assert()
 			}
 		}
 		e.segmentQueue.mu.Unlock()
@@ -2962,8 +2954,8 @@ func (e *Endpoint) HandleError(transErr stack.TransportError, pkt *stack.PacketB
 	}
 }
 
-// updateSndBufferUsage is called by the protocol goroutine when room opens up
-// in the send buffer. The number of newly available bytes is v.
+// updateSndBufferUsage is called by when room opens up in the send buffer. The
+// number of newly available bytes is v.
 func (e *Endpoint) updateSndBufferUsage(v int) {
 	sendBufferSize := e.getSendBufferSize()
 	e.sndQueueInfo.sndQueueMu.Lock()
@@ -2987,9 +2979,8 @@ func (e *Endpoint) updateSndBufferUsage(v int) {
 	}
 }
 
-// readyToRead is called by the protocol goroutine when a new segment is ready
-// to be read, or when the connection is closed for receiving (in which case
-// s will be nil).
+// readyToRead is called when a new segment is ready to be read, or when the
+// connection is closed for receiving (in which case s will be nil).
 //
 // +checklocks:e.mu
 func (e *Endpoint) readyToRead(s *segment) {

pkg/tcpip/transport/tcp/test/e2e/tcp_test.go

@@ -863,7 +863,7 @@ func TestClosingWithEnqueuedSegments(t *testing.T) {
 		t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
 	}
 
-	// Pause the endpoint`s protocolMainLoop.
+	// Pause the endpoint.
 	ep.(interface{ StopWork() }).StopWork()
 
 	// Enqueue last ACK followed by an ACK matching the endpoint
@@ -889,10 +889,10 @@ func TestClosingWithEnqueuedSegments(t *testing.T) {
 		RcvWnd:  30000,
 	})
 
-	// Unpause endpoint`s protocolMainLoop.
+	// Unpause endpoint.
 	ep.(interface{ ResumeWork() }).ResumeWork()
 
-	// Wait for the protocolMainLoop to resume and update state.
+	// Wait for the endpoint to resume and update state.
 	time.Sleep(10 * time.Millisecond)
 
 	// Expect the endpoint to be closed.