netstack: Refactor tcpip.Endpoint.Read

Read now takes a destination io.Writer, count, options. Keeping the method name
Read, in contrast to the Write method.

This enables:
* direct transfer of views under VV
* zero copy

It also eliminates the need for sentry to keep a slice of view because
userspace had requested a read that is smaller than the view returned, removing
the complexity there.

Read/Peek/ReadPacket are now consolidated together and some duplicate code is
removed.

PiperOrigin-RevId: 350636322

6 files changed, 158 insertions, 67 deletions

diff --git a/pkg/tcpip/tests/integration/BUILD b/pkg/tcpip/tests/integration/BUILD
index bb3b2ed0d..ca1e88e99 100644
--- a/pkg/tcpip/tests/integration/BUILD
+++ b/pkg/tcpip/tests/integration/BUILD
@@ -15,6 +15,7 @@ go_test(
     deps = [
         "//pkg/tcpip",
         "//pkg/tcpip/buffer",
+        "//pkg/tcpip/checker",
         "//pkg/tcpip/header",
         "//pkg/tcpip/link/channel",
         "//pkg/tcpip/link/ethernet",
diff --git a/pkg/tcpip/tests/integration/forward_test.go b/pkg/tcpip/tests/integration/forward_test.go
index 907565ac4..60054d6ef 100644
--- a/pkg/tcpip/tests/integration/forward_test.go
+++ b/pkg/tcpip/tests/integration/forward_test.go
@@ -15,12 +15,13 @@
 package integration_test
 
 import (
+	"bytes"
 	"net"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
 	"gvisor.dev/gvisor/pkg/tcpip"
-	"gvisor.dev/gvisor/pkg/tcpip/buffer"
+	"gvisor.dev/gvisor/pkg/tcpip/checker"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/pkg/tcpip/link/ethernet"
 	"gvisor.dev/gvisor/pkg/tcpip/link/nested"
@@ -382,24 +383,33 @@ func TestForwarding(t *testing.T) {
 
 				// Wait for the endpoint to be readable.
 				<-ch
-				var addr tcpip.FullAddress
-				v, _, err := ep.Read(&addr)
+				var buf bytes.Buffer
+				opts := tcpip.ReadOptions{NeedRemoteAddr: true}
+				res, err := ep.Read(&buf, len(data), opts)
 				if err != nil {
-					t.Fatalf("ep.Read(_): %s", err)
+					t.Fatalf("ep.Read(_, %d, %#v): %s", len(data), opts, err)
 				}
 
-				if diff := cmp.Diff(v, buffer.View(data)); diff != "" {
-					t.Errorf("received data mismatch (-want +got):\n%s", diff)
+				if diff := cmp.Diff(tcpip.ReadResult{
+					Count:      len(data),
+					Total:      len(data),
+					RemoteAddr: tcpip.FullAddress{Addr: expectedFrom},
+				}, res, checker.IgnoreCmpPath(
+					"ControlMessages",
+					"RemoteAddr.NIC",
+					"RemoteAddr.Port",
+				)); diff != "" {
+					t.Errorf("ep.Read: unexpected result (-want +got):\n%s", diff)
 				}
-				if addr.Addr != expectedFrom {
-					t.Errorf("got addr.Addr = %s, want = %s", addr.Addr, expectedFrom)
+				if diff := cmp.Diff(buf.Bytes(), data); diff != "" {
+					t.Errorf("received data mismatch (-want +got):\n%s", diff)
 				}
 
 				if t.Failed() {
 					t.FailNow()
 				}
 
-				return addr
+				return res.RemoteAddr
 			}
 
 			addr := read(epsAndAddrs.serverReadableCH, epsAndAddrs.serverEP, data, epsAndAddrs.clientAddr)
diff --git a/pkg/tcpip/tests/integration/link_resolution_test.go b/pkg/tcpip/tests/integration/link_resolution_test.go
index b41b72381..209da3903 100644
--- a/pkg/tcpip/tests/integration/link_resolution_test.go
+++ b/pkg/tcpip/tests/integration/link_resolution_test.go
@@ -15,12 +15,13 @@
 package integration_test
 
 import (
+	"bytes"
 	"net"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
 	"gvisor.dev/gvisor/pkg/tcpip"
-	"gvisor.dev/gvisor/pkg/tcpip/buffer"
+	"gvisor.dev/gvisor/pkg/tcpip/checker"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/pkg/tcpip/link/pipe"
 	"gvisor.dev/gvisor/pkg/tcpip/network/arp"
@@ -86,21 +87,21 @@ func TestPing(t *testing.T) {
 		transProto tcpip.TransportProtocolNumber
 		netProto   tcpip.NetworkProtocolNumber
 		remoteAddr tcpip.Address
-		icmpBuf    func(*testing.T) buffer.View
+		icmpBuf    func(*testing.T) []byte
 	}{
 		{
 			name:       "IPv4 Ping",
 			transProto: icmp.ProtocolNumber4,
 			netProto:   ipv4.ProtocolNumber,
 			remoteAddr: ipv4Addr2.AddressWithPrefix.Address,
-			icmpBuf: func(t *testing.T) buffer.View {
+			icmpBuf: func(t *testing.T) []byte {
 				data := [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
 				hdr := header.ICMPv4(make([]byte, header.ICMPv4MinimumSize+len(data)))
 				hdr.SetType(header.ICMPv4Echo)
 				if n := copy(hdr.Payload(), data[:]); n != len(data) {
 					t.Fatalf("copied %d bytes but expected to copy %d bytes", n, len(data))
 				}
-				return buffer.View(hdr)
+				return hdr
 			},
 		},
 		{
@@ -108,14 +109,14 @@ func TestPing(t *testing.T) {
 			transProto: icmp.ProtocolNumber6,
 			netProto:   ipv6.ProtocolNumber,
 			remoteAddr: ipv6Addr2.AddressWithPrefix.Address,
-			icmpBuf: func(t *testing.T) buffer.View {
+			icmpBuf: func(t *testing.T) []byte {
 				data := [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
 				hdr := header.ICMPv6(make([]byte, header.ICMPv6MinimumSize+len(data)))
 				hdr.SetType(header.ICMPv6EchoRequest)
 				if n := copy(hdr.Payload(), data[:]); n != len(data) {
 					t.Fatalf("copied %d bytes but expected to copy %d bytes", n, len(data))
 				}
-				return buffer.View(hdr)
+				return hdr
 			},
 		},
 	}
@@ -200,16 +201,25 @@ func TestPing(t *testing.T) {
 			// Wait for the endpoint to be readable.
 			<-waiterCH
 
-			var addr tcpip.FullAddress
-			v, _, err := ep.Read(&addr)
+			var buf bytes.Buffer
+			opts := tcpip.ReadOptions{NeedRemoteAddr: true}
+			res, err := ep.Read(&buf, len(icmpBuf), opts)
 			if err != nil {
-				t.Fatalf("ep.Read(_): %s", err)
+				t.Fatalf("ep.Read(_, %d, %#v): %s", len(icmpBuf), opts, err)
 			}
-			if diff := cmp.Diff(v[icmpDataOffset:], icmpBuf[icmpDataOffset:]); diff != "" {
-				t.Errorf("received data mismatch (-want +got):\n%s", diff)
+			if diff := cmp.Diff(tcpip.ReadResult{
+				Count:      buf.Len(),
+				Total:      buf.Len(),
+				RemoteAddr: tcpip.FullAddress{Addr: test.remoteAddr},
+			}, res, checker.IgnoreCmpPath(
+				"ControlMessages",
+				"RemoteAddr.NIC",
+				"RemoteAddr.Port",
+			)); diff != "" {
+				t.Errorf("ep.Read: unexpected result (-want +got):\n%s", diff)
 			}
-			if addr.Addr != test.remoteAddr {
-				t.Errorf("got addr.Addr = %s, want = %s", addr.Addr, test.remoteAddr)
+			if diff := cmp.Diff(buf.Bytes()[icmpDataOffset:], icmpBuf[icmpDataOffset:]); diff != "" {
+				t.Errorf("received data mismatch (-want +got):\n%s", diff)
 			}
 		})
 	}
diff --git a/pkg/tcpip/tests/integration/loopback_test.go b/pkg/tcpip/tests/integration/loopback_test.go
index baaa741cd..cf9e86c3c 100644
--- a/pkg/tcpip/tests/integration/loopback_test.go
+++ b/pkg/tcpip/tests/integration/loopback_test.go
@@ -15,12 +15,14 @@
 package integration_test
 
 import (
+	"bytes"
 	"testing"
 	"time"
 
 	"github.com/google/go-cmp/cmp"
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/buffer"
+	"gvisor.dev/gvisor/pkg/tcpip/checker"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/pkg/tcpip/link/loopback"
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
@@ -238,21 +240,28 @@ func TestLoopbackAcceptAllInSubnetUDP(t *testing.T) {
 				t.Fatalf("got sep.Write(_, _) = (%d, _, nil), want = (%d, _, nil)", n, want)
 			}
 
-			var addr tcpip.FullAddress
-			if gotPayload, _, err := rep.Read(&addr); test.expectRx {
+			var buf bytes.Buffer
+			opts := tcpip.ReadOptions{NeedRemoteAddr: true}
+			if res, err := rep.Read(&buf, len(data), opts); test.expectRx {
 				if err != nil {
-					t.Fatalf("reep.Read(_): %s", err)
-				}
-				if diff := cmp.Diff(buffer.View(data), gotPayload); diff != "" {
-					t.Errorf("got UDP payload mismatch (-want +got):\n%s", diff)
+					t.Fatalf("rep.Read(_, %d, %#v): %s", len(data), opts, err)
 				}
-				if addr.Addr != test.addAddress.AddressWithPrefix.Address {
-					t.Errorf("got addr.Addr = %s, want = %s", addr.Addr, test.addAddress.AddressWithPrefix.Address)
+				if diff := cmp.Diff(tcpip.ReadResult{
+					Count: buf.Len(),
+					Total: buf.Len(),
+					RemoteAddr: tcpip.FullAddress{
+						Addr: test.addAddress.AddressWithPrefix.Address,
+					},
+				}, res,
+					checker.IgnoreCmpPath("ControlMessages", "RemoteAddr.NIC", "RemoteAddr.Port"),
+				); diff != "" {
+					t.Errorf("rep.Read: unexpected result (-want +got):\n%s", diff)
 				}
-			} else {
-				if err != tcpip.ErrWouldBlock {
-					t.Fatalf("got rep.Read(nil) = (%x, _, %s), want = (_, _, %s)", gotPayload, err, tcpip.ErrWouldBlock)
+				if diff := cmp.Diff(data, buf.Bytes()); diff != "" {
+					t.Errorf("got UDP payload mismatch (-want +got):\n%s", diff)
 				}
+			} else if err != tcpip.ErrWouldBlock {
+				t.Fatalf("got rep.Read = (%v, %s) [with data %x], want = (_, %s)", res, err, buf.Bytes(), tcpip.ErrWouldBlock)
 			}
 		})
 	}
diff --git a/pkg/tcpip/tests/integration/multicast_broadcast_test.go b/pkg/tcpip/tests/integration/multicast_broadcast_test.go
index 20f8a7e6c..fae6c256a 100644
--- a/pkg/tcpip/tests/integration/multicast_broadcast_test.go
+++ b/pkg/tcpip/tests/integration/multicast_broadcast_test.go
@@ -15,12 +15,14 @@
 package integration_test
 
 import (
+	"bytes"
 	"net"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/buffer"
+	"gvisor.dev/gvisor/pkg/tcpip/checker"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/pkg/tcpip/link/channel"
 	"gvisor.dev/gvisor/pkg/tcpip/link/loopback"
@@ -462,17 +464,23 @@ func TestIncomingMulticastAndBroadcast(t *testing.T) {
 			}
 
 			test.rxUDP(e, test.remoteAddr, test.dstAddr, data)
-			if gotPayload, _, err := ep.Read(nil); test.expectRx {
+			var buf bytes.Buffer
+			var opts tcpip.ReadOptions
+			if res, err := ep.Read(&buf, len(data), opts); test.expectRx {
 				if err != nil {
-					t.Fatalf("Read(nil): %s", err)
+					t.Fatalf("ep.Read(_, %d, %#v): %s", len(data), opts, err)
 				}
-				if diff := cmp.Diff(buffer.View(data), gotPayload); diff != "" {
-					t.Errorf("got UDP payload mismatch (-want +got):\n%s", diff)
+				if diff := cmp.Diff(tcpip.ReadResult{
+					Count: buf.Len(),
+					Total: buf.Len(),
+				}, res, checker.IgnoreCmpPath("ControlMessages")); diff != "" {
+					t.Errorf("ep.Read: unexpected result (-want +got):\n%s", diff)
 				}
-			} else {
-				if err != tcpip.ErrWouldBlock {
-					t.Fatalf("got Read(nil) = (%x, _, %s), want = (_, _, %s)", gotPayload, err, tcpip.ErrWouldBlock)
+				if diff := cmp.Diff(data, buf.Bytes()); diff != "" {
+					t.Errorf("got UDP payload mismatch (-want +got):\n%s", diff)
 				}
+			} else if err != tcpip.ErrWouldBlock {
+				t.Fatalf("got Read = (%v, %s) [with data %x], want = (_, %s)", res, err, buf.Bytes(), tcpip.ErrWouldBlock)
 			}
 		})
 	}
@@ -589,9 +597,19 @@ func TestReuseAddrAndBroadcast(t *testing.T) {
 					// Wait for the endpoint to become readable.
 					<-rep.ch
 
-					if gotPayload, _, err := rep.ep.Read(nil); err != nil {
-						t.Errorf("(eps[%d] write) eps[%d].Read(nil): %s", i, j, err)
-					} else if diff := cmp.Diff(buffer.View(data), gotPayload); diff != "" {
+					var buf bytes.Buffer
+					result, err := rep.ep.Read(&buf, len(data), tcpip.ReadOptions{})
+					if err != nil {
+						t.Errorf("(eps[%d] write) eps[%d].Read: %s", i, j, err)
+						continue
+					}
+					if diff := cmp.Diff(tcpip.ReadResult{
+						Count: buf.Len(),
+						Total: buf.Len(),
+					}, result, checker.IgnoreCmpPath("ControlMessages")); diff != "" {
+						t.Errorf("(eps[%d] write) eps[%d].Read: unexpected result (-want +got):\n%s", i, j, diff)
+					}
+					if diff := cmp.Diff([]byte(data), buf.Bytes()); diff != "" {
 						t.Errorf("(eps[%d] write) got UDP payload from eps[%d] mismatch (-want +got):\n%s", i, j, diff)
 					}
 				}
@@ -719,10 +737,20 @@ func TestUDPAddRemoveMembershipSocketOption(t *testing.T) {
 						t.Fatalf("ep.SetSockOpt(&%#v): %s", addOpt, err)
 					}
 					test.rxUDP(e, test.remoteAddr, test.multicastAddr, data)
-					if gotPayload, _, err := ep.Read(nil); err != nil {
-						t.Fatalf("ep.Read(nil): %s", err)
-					} else if diff := cmp.Diff(buffer.View(data), gotPayload); diff != "" {
-						t.Errorf("got UDP payload mismatch (-want +got):\n%s", diff)
+					var buf bytes.Buffer
+					result, err := ep.Read(&buf, len(data), tcpip.ReadOptions{})
+					if err != nil {
+						t.Fatalf("ep.Read: %s", err)
+					} else {
+						if diff := cmp.Diff(tcpip.ReadResult{
+							Count: buf.Len(),
+							Total: buf.Len(),
+						}, result, checker.IgnoreCmpPath("ControlMessages")); diff != "" {
+							t.Errorf("ep.Read: unexpected result (-want +got):\n%s", diff)
+						}
+						if diff := cmp.Diff(data, buf.Bytes()); diff != "" {
+							t.Errorf("got UDP payload mismatch (-want +got):\n%s", diff)
+						}
 					}
 
 					// We should not receive UDP packets to the group once we leave
@@ -731,8 +759,8 @@ func TestUDPAddRemoveMembershipSocketOption(t *testing.T) {
 					if err := ep.SetSockOpt(&removeOpt); err != nil {
 						t.Fatalf("ep.SetSockOpt(&%#v): %s", removeOpt, err)
 					}
-					if gotPayload, _, err := ep.Read(nil); err != tcpip.ErrWouldBlock {
-						t.Fatalf("got ep.Read(nil) = (%x, _, %s), want = (nil, _, %s)", gotPayload, err, tcpip.ErrWouldBlock)
+					if _, err := ep.Read(&buf, 1, tcpip.ReadOptions{}); err != tcpip.ErrWouldBlock {
+						t.Fatalf("got ep.Read = (_, %s), want = (_, %s)", err, tcpip.ErrWouldBlock)
 					}
 				})
 			}
diff --git a/pkg/tcpip/tests/integration/route_test.go b/pkg/tcpip/tests/integration/route_test.go
index 02fc47015..52cf89b54 100644
--- a/pkg/tcpip/tests/integration/route_test.go
+++ b/pkg/tcpip/tests/integration/route_test.go
@@ -15,11 +15,14 @@
 package integration_test
 
 import (
+	"bytes"
+	"math"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/buffer"
+	"gvisor.dev/gvisor/pkg/tcpip/checker"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/pkg/tcpip/link/channel"
 	"gvisor.dev/gvisor/pkg/tcpip/link/loopback"
@@ -203,16 +206,25 @@ func TestLocalPing(t *testing.T) {
 			// Wait for the endpoint to become readable.
 			<-ch
 
-			var addr tcpip.FullAddress
-			v, _, err := ep.Read(&addr)
+			var buf bytes.Buffer
+			opts := tcpip.ReadOptions{NeedRemoteAddr: true}
+			res, err := ep.Read(&buf, math.MaxUint16, opts)
 			if err != nil {
-				t.Fatalf("ep.Read(_): %s", err)
+				t.Fatalf("ep.Read(_, %d, %#v): %s", math.MaxUint16, opts, err)
 			}
-			if diff := cmp.Diff(v[icmpDataOffset:], buffer.View(payload[icmpDataOffset:])); diff != "" {
-				t.Errorf("received data mismatch (-want +got):\n%s", diff)
+			if diff := cmp.Diff(tcpip.ReadResult{
+				Count:      buf.Len(),
+				Total:      buf.Len(),
+				RemoteAddr: tcpip.FullAddress{Addr: test.localAddr},
+			}, res, checker.IgnoreCmpPath(
+				"ControlMessages",
+				"RemoteAddr.NIC",
+				"RemoteAddr.Port",
+			)); diff != "" {
+				t.Errorf("ep.Read: unexpected result (-want +got):\n%s", diff)
 			}
-			if addr.Addr != test.localAddr {
-				t.Errorf("got addr.Addr = %s, want = %s", addr.Addr, test.localAddr)
+			if diff := cmp.Diff(buf.Bytes()[icmpDataOffset:], []byte(payload[icmpDataOffset:])); diff != "" {
+				t.Errorf("received data mismatch (-want +got):\n%s", diff)
 			}
 
 			test.checkLinkEndpoint(t, e)
@@ -338,14 +350,27 @@ func TestLocalUDP(t *testing.T) {
 					<-serverCH
 
 					var clientAddr tcpip.FullAddress
-					if v, _, err := server.Read(&clientAddr); err != nil {
+					var readBuf bytes.Buffer
+					if read, err := server.Read(&readBuf, math.MaxUint16, tcpip.ReadOptions{NeedRemoteAddr: true}); err != nil {
 						t.Fatalf("server.Read(_): %s", err)
 					} else {
-						if diff := cmp.Diff(buffer.View(clientPayload), v); diff != "" {
-							t.Errorf("server read clientPayload mismatch (-want +got):\n%s", diff)
+						clientAddr = read.RemoteAddr
+
+						if diff := cmp.Diff(tcpip.ReadResult{
+							Count: readBuf.Len(),
+							Total: readBuf.Len(),
+							RemoteAddr: tcpip.FullAddress{
+								Addr: test.canBePrimaryAddr.AddressWithPrefix.Address,
+							},
+						}, read, checker.IgnoreCmpPath(
+							"ControlMessages",
+							"RemoteAddr.NIC",
+							"RemoteAddr.Port",
+						)); diff != "" {
+							t.Errorf("server.Read: unexpected result (-want +got):\n%s", diff)
 						}
-						if clientAddr.Addr != test.canBePrimaryAddr.AddressWithPrefix.Address {
-							t.Errorf("got clientAddr.Addr = %s, want = %s", clientAddr.Addr, test.canBePrimaryAddr.AddressWithPrefix.Address)
+						if diff := cmp.Diff(buffer.View(clientPayload), buffer.View(readBuf.Bytes())); diff != "" {
+							t.Errorf("server read clientPayload mismatch (-want +got):\n%s", diff)
 						}
 						if t.Failed() {
 							t.FailNow()
@@ -367,15 +392,23 @@ func TestLocalUDP(t *testing.T) {
 					// Wait for the client endpoint to become readable.
 					<-clientCH
 
-					var gotServerAddr tcpip.FullAddress
-					if v, _, err := client.Read(&gotServerAddr); err != nil {
+					readBuf.Reset()
+					if read, err := client.Read(&readBuf, math.MaxUint16, tcpip.ReadOptions{NeedRemoteAddr: true}); err != nil {
 						t.Fatalf("client.Read(_): %s", err)
 					} else {
-						if diff := cmp.Diff(buffer.View(serverPayload), v); diff != "" {
-							t.Errorf("client read serverPayload mismatch (-want +got):\n%s", diff)
+						if diff := cmp.Diff(tcpip.ReadResult{
+							Count:      readBuf.Len(),
+							Total:      readBuf.Len(),
+							RemoteAddr: tcpip.FullAddress{Addr: serverAddr.Addr},
+						}, read, checker.IgnoreCmpPath(
+							"ControlMessages",
+							"RemoteAddr.NIC",
+							"RemoteAddr.Port",
+						)); diff != "" {
+							t.Errorf("client.Read: unexpected result (-want +got):\n%s", diff)
 						}
-						if gotServerAddr.Addr != serverAddr.Addr {
-							t.Errorf("got gotServerAddr.Addr = %s, want = %s", gotServerAddr.Addr, serverAddr.Addr)
+						if diff := cmp.Diff(buffer.View(serverPayload), buffer.View(readBuf.Bytes())); diff != "" {
+							t.Errorf("client read serverPayload mismatch (-want +got):\n%s", diff)
 						}
 						if t.Failed() {
 							t.FailNow()