Automated rollback of changelist 339675182

PiperOrigin-RevId: 339750876

1 files changed, 4 insertions, 61 deletions

diff --git a/pkg/tcpip/transport/tcp/endpoint.go b/pkg/tcpip/transport/tcp/endpoint.go
index 8f5e3a42d..bfe26e460 100644
--- a/pkg/tcpip/transport/tcp/endpoint.go
+++ b/pkg/tcpip/transport/tcp/endpoint.go
@@ -440,11 +440,6 @@ type endpoint struct {
 	ttl               uint8
 	v6only            bool
 	isConnectNotified bool
-	// h stores a reference to the current handshake state if the endpoint is in
-	// the SYN-SENT or SYN-RECV states, in which case endpoint == endpoint.h.ep.
-	// nil otherwise.
-	h *handshake `state:"nosave"`
-
 	// TCP should never broadcast but Linux nevertheless supports enabling/
 	// disabling SO_BROADCAST, albeit as a NOOP.
 	broadcast bool
@@ -726,9 +721,9 @@ func (e *endpoint) LockUser() {
 	for {
 		// Try first if the sock is locked then check if it's owned
 		// by another user goroutine if not then we spin, otherwise
-		// we just go to sleep on the Lock() and wait.
+		// we just goto sleep on the Lock() and wait.
 		if !e.mu.TryLock() {
-			// If socket is owned by the user then just go to sleep
+			// If socket is owned by the user then just goto sleep
 			// as the lock could be held for a reasonably long time.
 			if atomic.LoadUint32(&e.ownedByUser) == 1 {
 				e.mu.Lock()
@@ -927,7 +922,6 @@ func newEndpoint(s *stack.Stack, netProto tcpip.NetworkProtocolNumber, waiterQue
 	e.segmentQueue.ep = e
 	e.tsOffset = timeStampOffset()
 	e.acceptCond = sync.NewCond(&e.acceptMu)
-	e.keepalive.timer.init(&e.keepalive.waker)
 
 	return e
 }
@@ -1149,7 +1143,6 @@ func (e *endpoint) cleanupLocked() {
 	// Close all endpoints that might have been accepted by TCP but not by
 	// the client.
 	e.closePendingAcceptableConnectionsLocked()
-	e.keepalive.timer.cleanup()
 
 	e.workerCleanup = false
 
@@ -2189,8 +2182,6 @@ func (*endpoint) Disconnect() *tcpip.Error {
 func (e *endpoint) Connect(addr tcpip.FullAddress) *tcpip.Error {
 	err := e.connect(addr, true, true)
 	if err != nil && !err.IgnoreStats() {
-		// Connect failed. Let's wake up any waiters.
-		e.waiterQueue.Notify(waiter.EventHUp | waiter.EventErr | waiter.EventIn | waiter.EventOut)
 		e.stack.Stats().TCP.FailedConnectionAttempts.Increment()
 		e.stats.FailedConnectionAttempts.Increment()
 	}
@@ -2404,60 +2395,12 @@ func (e *endpoint) connect(addr tcpip.FullAddress, handshake bool, run bool) *tc
 	}
 
 	if run {
-		if err := e.startMainLoop(handshake); err != nil {
-			return err
-		}
-	}
-
-	return tcpip.ErrConnectStarted
-}
-
-// startMainLoop sends the initial SYN and starts the main loop for the
-// endpoint.
-func (e *endpoint) startMainLoop(handshake bool) *tcpip.Error {
-	preloop := func() *tcpip.Error {
-		if handshake {
-			h := e.newHandshake()
-			e.setEndpointState(StateSynSent)
-			if err := h.start(); err != nil {
-				e.lastErrorMu.Lock()
-				e.lastError = err
-				e.lastErrorMu.Unlock()
-
-				e.setEndpointState(StateError)
-				e.HardError = err
-
-				// Call cleanupLocked to free up any reservations.
-				e.cleanupLocked()
-				return err
-			}
-		}
-		e.stack.Stats().TCP.ActiveConnectionOpenings.Increment()
 		e.workerRunning = true
-		return nil
-	}
-
-	if !e.route.IsResolutionRequired() {
-		// No route resolution is required, so we can send the initial SYN here without
-		// blocking. This will hopefully reduce overall latency by overlapping time
-		// spent waiting for a SYN-ACK and time spent spinning up a new goroutine
-		// for the main loop.
-		if err := preloop(); err != nil {
-			return err
-		}
+		e.stack.Stats().TCP.ActiveConnectionOpenings.Increment()
 		go e.protocolMainLoop(handshake, nil) // S/R-SAFE: will be drained before save.
-		return nil
 	}
 
-	// Sending the initial SYN may block due to route resolution; do it in a
-	// separate goroutine to avoid blocking the syscall goroutine.
-	go func() { // S/R-SAFE: will be drained before save.
-		if err := preloop(); err != nil {
-			return
-		}
-		e.protocolMainLoop(handshake, nil)
-	}()
-	return nil
+	return tcpip.ErrConnectStarted
 }
 
 // ConnectEndpoint is not supported.