[syserr] Reverse dependency for tcpip.Error

PiperOrigin-RevId: 407638912

pkg/sentry/fs/gofer/BUILD

@@ -49,6 +49,7 @@ go_library(
         "//pkg/sentry/socket/unix/transport",
         "//pkg/sync",
         "//pkg/syserr",
+        "//pkg/tcpip",
         "//pkg/unet",
         "//pkg/usermem",
         "//pkg/waiter",

pkg/sentry/fs/gofer/socket.go

@@ -23,6 +23,7 @@ import (
 	"gvisor.dev/gvisor/pkg/sentry/fs/host"
 	"gvisor.dev/gvisor/pkg/sentry/socket/unix/transport"
 	"gvisor.dev/gvisor/pkg/syserr"
+	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/waiter"
 )
 
@@ -95,7 +96,7 @@ func (e *endpoint) BidirectionalConnect(ctx context.Context, ce transport.Connec
 	}
 	if ce.Listening() {
 		ce.Unlock()
-		return syserr.ErrInvalidEndpointState
+		return tcpip.SyserrInvalidEndpointState
 	}
 
 	hostFile, err := e.file.Connect(cf)

pkg/sentry/fs/host/BUILD

@@ -77,7 +77,6 @@ go_test(
         "//pkg/sentry/kernel/time",
         "//pkg/sentry/socket",
         "//pkg/sentry/socket/unix/transport",
-        "//pkg/syserr",
         "//pkg/tcpip",
         "//pkg/usermem",
         "//pkg/waiter",

pkg/sentry/fs/host/socket.go

@@ -82,7 +82,7 @@ func (c *ConnectedEndpoint) init() *syserr.Error {
 
 	if family != unix.AF_UNIX {
 		// We only allow Unix sockets.
-		return syserr.ErrInvalidEndpointState
+		return tcpip.SyserrInvalidEndpointState
 	}
 
 	stype, err := unix.GetsockoptInt(c.file.FD(), unix.SOL_SOCKET, unix.SO_TYPE)
@@ -200,7 +200,7 @@ func (c *ConnectedEndpoint) Send(ctx context.Context, data [][]byte, controlMess
 	defer c.mu.RUnlock()
 
 	if !controlMessages.Empty() {
-		return 0, false, syserr.ErrInvalidEndpointState
+		return 0, false, tcpip.SyserrInvalidEndpointState
 	}
 
 	// Since stream sockets don't preserve message boundaries, we can write

pkg/sentry/fs/host/socket_test.go

@@ -25,7 +25,6 @@ import (
 	ktime "gvisor.dev/gvisor/pkg/sentry/kernel/time"
 	"gvisor.dev/gvisor/pkg/sentry/socket"
 	"gvisor.dev/gvisor/pkg/sentry/socket/unix/transport"
-	"gvisor.dev/gvisor/pkg/syserr"
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/usermem"
 	"gvisor.dev/gvisor/pkg/waiter"
@@ -178,11 +177,11 @@ func TestListen(t *testing.T) {
 	socket2 := sfile2.FileOperations.(socket.Socket)
 
 	// Socketpairs can not be listened to.
-	if err := socket1.Listen(nil, 64); err != syserr.ErrInvalidEndpointState {
-		t.Fatalf("socket1.Listen(nil, 64) => %v, want syserr.ErrInvalidEndpointState", err)
+	if err := socket1.Listen(nil, 64); err != tcpip.SyserrInvalidEndpointState {
+		t.Fatalf("socket1.Listen(nil, 64) => %v, want tcpip.SyserrInvalidEndpointState", err)
 	}
-	if err := socket2.Listen(nil, 64); err != syserr.ErrInvalidEndpointState {
-		t.Fatalf("socket2.Listen(nil, 64) => %v, want syserr.ErrInvalidEndpointState", err)
+	if err := socket2.Listen(nil, 64); err != tcpip.SyserrInvalidEndpointState {
+		t.Fatalf("socket2.Listen(nil, 64) => %v, want tcpip.SyserrInvalidEndpointState", err)
 	}
 
 	// Create a Unix socket, do not bind it.
@@ -198,8 +197,8 @@ func TestListen(t *testing.T) {
 	socket3 := sfile3.FileOperations.(socket.Socket)
 
 	// This socket is not bound so we can't listen on it.
-	if err := socket3.Listen(nil, 64); err != syserr.ErrInvalidEndpointState {
-		t.Fatalf("socket3.Listen(nil, 64) => %v, want syserr.ErrInvalidEndpointState", err)
+	if err := socket3.Listen(nil, 64); err != tcpip.SyserrInvalidEndpointState {
+		t.Fatalf("socket3.Listen(nil, 64) => %v, want tcpip.SyserrInvalidEndpointState", err)
 	}
 }
 

pkg/sentry/fsimpl/gofer/BUILD

@@ -82,6 +82,7 @@ go_library(
         "//pkg/sentry/vfs",
         "//pkg/sync",
         "//pkg/syserr",
+        "//pkg/tcpip",
         "//pkg/unet",
         "//pkg/usermem",
         "//pkg/waiter",

pkg/sentry/fsimpl/gofer/socket.go

@@ -23,6 +23,7 @@ import (
 	"gvisor.dev/gvisor/pkg/sentry/fsimpl/host"
 	"gvisor.dev/gvisor/pkg/sentry/socket/unix/transport"
 	"gvisor.dev/gvisor/pkg/syserr"
+	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/waiter"
 )
 
@@ -69,7 +70,7 @@ func (e *endpoint) BidirectionalConnect(ctx context.Context, ce transport.Connec
 	}
 	if ce.Listening() {
 		ce.Unlock()
-		return syserr.ErrInvalidEndpointState
+		return tcpip.SyserrInvalidEndpointState
 	}
 
 	c, err := e.newConnectedEndpoint(ctx, ce.Type(), ce.WaiterQueue())

pkg/sentry/fsimpl/host/socket.go

@@ -97,7 +97,7 @@ func (c *ConnectedEndpoint) initFromOptions() *syserr.Error {
 
 	if family != unix.AF_UNIX {
 		// We only allow Unix sockets.
-		return syserr.ErrInvalidEndpointState
+		return tcpip.SyserrInvalidEndpointState
 	}
 
 	stype, err := unix.GetsockoptInt(c.fd, unix.SOL_SOCKET, unix.SO_TYPE)
@@ -147,7 +147,7 @@ func (c *ConnectedEndpoint) Send(ctx context.Context, data [][]byte, controlMess
 	defer c.mu.RUnlock()
 
 	if !controlMessages.Empty() {
-		return 0, false, syserr.ErrInvalidEndpointState
+		return 0, false, tcpip.SyserrInvalidEndpointState
 	}
 
 	// Since stream sockets don't preserve message boundaries, we can write

pkg/sentry/socket/netfilter/netfilter.go

@@ -290,7 +290,7 @@ func SetEntries(task *kernel.Task, stk *stack.Stack, optVal []byte, ipv6 bool) *
 	// - There are no chains without an unconditional final rule.
 	// - There are no chains without an unconditional underflow rule.
 
-	return syserr.TranslateNetstackError(stk.IPTables().ReplaceTable(nameToID[replace.Name.String()], table, ipv6))
+	return tcpip.TranslateNetstackError(stk.IPTables().ReplaceTable(nameToID[replace.Name.String()], table, ipv6))
 }
 
 // parseMatchers parses 0 or more matchers from optVal. optVal should contain

pkg/sentry/socket/netlink/provider.go

@@ -23,6 +23,7 @@ import (
 	"gvisor.dev/gvisor/pkg/sentry/kernel"
 	"gvisor.dev/gvisor/pkg/sentry/socket"
 	"gvisor.dev/gvisor/pkg/syserr"
+	"gvisor.dev/gvisor/pkg/tcpip"
 )
 
 // Protocol is the implementation of a netlink socket protocol.
@@ -104,7 +105,7 @@ func (*socketProvider) Socket(t *kernel.Task, stype linux.SockType, protocol int
 // Pair implements socket.Provider.Pair by returning an error.
 func (*socketProvider) Pair(*kernel.Task, linux.SockType, int) (*fs.File, *fs.File, *syserr.Error) {
 	// Netlink sockets never supports creating socket pairs.
-	return nil, nil, syserr.ErrNotSupported
+	return nil, nil, tcpip.SyserrNotSupported
 }
 
 // LINT.ThenChange(./provider_vfs2.go)

pkg/sentry/socket/netlink/provider_vfs2.go

@@ -20,6 +20,7 @@ import (
 	"gvisor.dev/gvisor/pkg/sentry/kernel"
 	"gvisor.dev/gvisor/pkg/sentry/vfs"
 	"gvisor.dev/gvisor/pkg/syserr"
+	"gvisor.dev/gvisor/pkg/tcpip"
 )
 
 // socketProviderVFS2 implements socket.Provider.
@@ -66,5 +67,5 @@ func (*socketProviderVFS2) Socket(t *kernel.Task, stype linux.SockType, protocol
 // Pair implements socket.Provider.Pair by returning an error.
 func (*socketProviderVFS2) Pair(*kernel.Task, linux.SockType, int) (*vfs.FileDescription, *vfs.FileDescription, *syserr.Error) {
 	// Netlink sockets never supports creating socket pairs.
-	return nil, nil, syserr.ErrNotSupported
+	return nil, nil, tcpip.SyserrNotSupported
 }

pkg/sentry/socket/netlink/route/BUILD

@@ -17,6 +17,7 @@ go_library(
         "//pkg/sentry/kernel/auth",
         "//pkg/sentry/socket/netlink",
         "//pkg/syserr",
+        "//pkg/tcpip",
         "@org_golang_x_sys//unix:go_default_library",
     ],
 )

pkg/sentry/socket/netlink/route/protocol.go

@@ -27,6 +27,7 @@ import (
 	"gvisor.dev/gvisor/pkg/sentry/kernel/auth"
 	"gvisor.dev/gvisor/pkg/sentry/socket/netlink"
 	"gvisor.dev/gvisor/pkg/syserr"
+	"gvisor.dev/gvisor/pkg/tcpip"
 )
 
 // commandKind describes the operational class of a message type.
@@ -360,7 +361,7 @@ func parseForDestination(msg *netlink.Message) ([]byte, *syserr.Error) {
 	// commit bc234301af12. Note we don't check this flag for backward
 	// compatibility.
 	if rtMsg.Flags != 0 && rtMsg.Flags != linux.RTM_F_LOOKUP_TABLE {
-		return nil, syserr.ErrNotSupported
+		return nil, tcpip.SyserrNotSupported
 	}
 
 	// Expect first attribute is RTA_DST.
@@ -393,7 +394,7 @@ func (p *Protocol) dumpRoutes(ctx context.Context, msg *netlink.Message, ms *net
 		route, err := fillRoute(routeTables, dst)
 		if err != nil {
 			// TODO(gvisor.dev/issue/1237): return NLMSG_ERROR with ENETUNREACH.
-			return syserr.ErrNotSupported
+			return tcpip.SyserrNotSupported
 		}
 		routeTables = append([]inet.Route{}, route)
 	} else if hdr.Flags&linux.NLM_F_DUMP == linux.NLM_F_DUMP {
@@ -401,7 +402,7 @@ func (p *Protocol) dumpRoutes(ctx context.Context, msg *netlink.Message, ms *net
 		ms.Multi = true
 	} else {
 		// TODO(b/68878065): Only above cases are supported.
-		return syserr.ErrNotSupported
+		return tcpip.SyserrNotSupported
 	}
 
 	for _, rt := range routeTables {
@@ -489,7 +490,7 @@ func (p *Protocol) newAddr(ctx context.Context, msg *netlink.Message, ms *netlin
 			}
 		case linux.IFA_ADDRESS:
 		default:
-			return syserr.ErrNotSupported
+			return tcpip.SyserrNotSupported
 		}
 	}
 	return nil
@@ -530,11 +531,11 @@ func (p *Protocol) delAddr(ctx context.Context, msg *netlink.Message, ms *netlin
 				Addr:      value,
 			})
 			if err != nil {
-				return syserr.ErrBadLocalAddress
+				return tcpip.SyserrBadLocalAddress
 			}
 		case linux.IFA_ADDRESS:
 		default:
-			return syserr.ErrNotSupported
+			return tcpip.SyserrNotSupported
 		}
 	}
 
@@ -572,7 +573,7 @@ func (p *Protocol) ProcessMessage(ctx context.Context, msg *netlink.Message, ms
 		case linux.RTM_GETROUTE:
 			return p.dumpRoutes(ctx, msg, ms)
 		default:
-			return syserr.ErrNotSupported
+			return tcpip.SyserrNotSupported
 		}
 	} else if hdr.Flags&linux.NLM_F_REQUEST == linux.NLM_F_REQUEST {
 		switch hdr.Type {
@@ -587,10 +588,10 @@ func (p *Protocol) ProcessMessage(ctx context.Context, msg *netlink.Message, ms
 		case linux.RTM_DELADDR:
 			return p.delAddr(ctx, msg, ms)
 		default:
-			return syserr.ErrNotSupported
+			return tcpip.SyserrNotSupported
 		}
 	}
-	return syserr.ErrNotSupported
+	return tcpip.SyserrNotSupported
 }
 
 // init registers the NETLINK_ROUTE provider.

pkg/sentry/socket/netlink/socket.go

@@ -312,19 +312,19 @@ func (s *socketOpsCommon) Connect(t *kernel.Task, sockaddr []byte, blocking bool
 // Accept implements socket.Socket.Accept.
 func (s *socketOpsCommon) Accept(t *kernel.Task, peerRequested bool, flags int, blocking bool) (int32, linux.SockAddr, uint32, *syserr.Error) {
 	// Netlink sockets never support accept.
-	return 0, nil, 0, syserr.ErrNotSupported
+	return 0, nil, 0, tcpip.SyserrNotSupported
 }
 
 // Listen implements socket.Socket.Listen.
 func (s *socketOpsCommon) Listen(t *kernel.Task, backlog int) *syserr.Error {
 	// Netlink sockets never support listen.
-	return syserr.ErrNotSupported
+	return tcpip.SyserrNotSupported
 }
 
 // Shutdown implements socket.Socket.Shutdown.
 func (s *socketOpsCommon) Shutdown(t *kernel.Task, how int) *syserr.Error {
 	// Netlink sockets never support shutdown.
-	return syserr.ErrNotSupported
+	return tcpip.SyserrNotSupported
 }
 
 // GetSockOpt implements socket.Socket.GetSockOpt.

pkg/sentry/socket/netstack/netstack_vfs2.go

@@ -134,7 +134,7 @@ func (s *SocketVFS2) Write(ctx context.Context, src usermem.IOSequence, opts vfs
 		return 0, linuxerr.ErrWouldBlock
 	}
 	if err != nil {
-		return 0, syserr.TranslateNetstackError(err).ToError()
+		return 0, tcpip.TranslateNetstackError(err).ToError()
 	}
 
 	if n < src.NumBytes() {
@@ -155,7 +155,7 @@ func (s *SocketVFS2) Accept(t *kernel.Task, peerRequested bool, flags int, block
 	ep, wq, terr := s.Endpoint.Accept(peerAddr)
 	if terr != nil {
 		if _, ok := terr.(*tcpip.ErrWouldBlock); !ok || !blocking {
-			return 0, nil, 0, syserr.TranslateNetstackError(terr)
+			return 0, nil, 0, tcpip.TranslateNetstackError(terr)
 		}
 
 		var err *syserr.Error

pkg/sentry/socket/netstack/provider.go

@@ -131,7 +131,7 @@ func (p *provider) Socket(t *kernel.Task, stype linux.SockType, protocol int) (*
 		}
 	}
 	if e != nil {
-		return nil, syserr.TranslateNetstackError(e)
+		return nil, tcpip.TranslateNetstackError(e)
 	}
 
 	return New(t, p.family, stype, int(transProto), wq, ep)
@@ -162,7 +162,7 @@ func packetSocket(t *kernel.Task, epStack *Stack, stype linux.SockType, protocol
 	wq := &waiter.Queue{}
 	ep, err := epStack.Stack.NewPacketEndpoint(cooked, netProto, wq)
 	if err != nil {
-		return nil, syserr.TranslateNetstackError(err)
+		return nil, tcpip.TranslateNetstackError(err)
 	}
 
 	return New(t, linux.AF_PACKET, stype, protocol, wq, ep)

pkg/sentry/socket/netstack/provider_vfs2.go

@@ -76,7 +76,7 @@ func (p *providerVFS2) Socket(t *kernel.Task, stype linux.SockType, protocol int
 		}
 	}
 	if e != nil {
-		return nil, syserr.TranslateNetstackError(e)
+		return nil, tcpip.TranslateNetstackError(e)
 	}
 
 	return NewVFS2(t, p.family, stype, int(transProto), wq, ep)
@@ -107,7 +107,7 @@ func packetSocketVFS2(t *kernel.Task, epStack *Stack, stype linux.SockType, prot
 	wq := &waiter.Queue{}
 	ep, err := epStack.Stack.NewPacketEndpoint(cooked, netProto, wq)
 	if err != nil {
-		return nil, syserr.TranslateNetstackError(err)
+		return nil, tcpip.TranslateNetstackError(err)
 	}
 
 	return NewVFS2(t, linux.AF_PACKET, stype, protocol, wq, ep)

pkg/sentry/socket/netstack/stack.go

@@ -74,7 +74,7 @@ func (s *Stack) Interfaces() map[int32]inet.Interface {
 // RemoveInterface implements inet.Stack.RemoveInterface.
 func (s *Stack) RemoveInterface(idx int32) error {
 	nic := tcpip.NICID(idx)
-	return syserr.TranslateNetstackError(s.Stack.RemoveNIC(nic)).ToError()
+	return tcpip.TranslateNetstackError(s.Stack.RemoveNIC(nic)).ToError()
 }
 
 // InterfaceAddrs implements inet.Stack.InterfaceAddrs.
@@ -156,7 +156,7 @@ func (s *Stack) AddInterfaceAddr(idx int32, addr inet.InterfaceAddr) error {
 	// Attach address to interface.
 	nicID := tcpip.NICID(idx)
 	if err := s.Stack.AddProtocolAddress(nicID, protocolAddress, stack.AddressProperties{}); err != nil {
-		return syserr.TranslateNetstackError(err).ToError()
+		return tcpip.TranslateNetstackError(err).ToError()
 	}
 
 	// Add route for local network if it doesn't exist already.
@@ -188,7 +188,7 @@ func (s *Stack) RemoveInterfaceAddr(idx int32, addr inet.InterfaceAddr) error {
 	// Remove addresses matching the address and prefix.
 	nicID := tcpip.NICID(idx)
 	if err := s.Stack.RemoveAddress(nicID, protocolAddress.AddressWithPrefix.Address); err != nil {
-		return syserr.TranslateNetstackError(err).ToError()
+		return tcpip.TranslateNetstackError(err).ToError()
 	}
 
 	// Remove the corresponding local network route if it exists.
@@ -212,7 +212,7 @@ func (s *Stack) TCPReceiveBufferSize() (inet.TCPBufferSize, error) {
 		Min:     rs.Min,
 		Default: rs.Default,
 		Max:     rs.Max,
-	}, syserr.TranslateNetstackError(err).ToError()
+	}, tcpip.TranslateNetstackError(err).ToError()
 }
 
 // SetTCPReceiveBufferSize implements inet.Stack.SetTCPReceiveBufferSize.
@@ -222,7 +222,7 @@ func (s *Stack) SetTCPReceiveBufferSize(size inet.TCPBufferSize) error {
 		Default: size.Default,
 		Max:     size.Max,
 	}
-	return syserr.TranslateNetstackError(s.Stack.SetTransportProtocolOption(tcp.ProtocolNumber, &rs)).ToError()
+	return tcpip.TranslateNetstackError(s.Stack.SetTransportProtocolOption(tcp.ProtocolNumber, &rs)).ToError()
 }
 
 // TCPSendBufferSize implements inet.Stack.TCPSendBufferSize.
@@ -233,7 +233,7 @@ func (s *Stack) TCPSendBufferSize() (inet.TCPBufferSize, error) {
 		Min:     ss.Min,
 		Default: ss.Default,
 		Max:     ss.Max,
-	}, syserr.TranslateNetstackError(err).ToError()
+	}, tcpip.TranslateNetstackError(err).ToError()
 }
 
 // SetTCPSendBufferSize implements inet.Stack.SetTCPSendBufferSize.
@@ -243,27 +243,27 @@ func (s *Stack) SetTCPSendBufferSize(size inet.TCPBufferSize) error {
 		Default: size.Default,
 		Max:     size.Max,
 	}
-	return syserr.TranslateNetstackError(s.Stack.SetTransportProtocolOption(tcp.ProtocolNumber, &ss)).ToError()
+	return tcpip.TranslateNetstackError(s.Stack.SetTransportProtocolOption(tcp.ProtocolNumber, &ss)).ToError()
 }
 
 // TCPSACKEnabled implements inet.Stack.TCPSACKEnabled.
 func (s *Stack) TCPSACKEnabled() (bool, error) {
 	var sack tcpip.TCPSACKEnabled
 	err := s.Stack.TransportProtocolOption(tcp.ProtocolNumber, &sack)
-	return bool(sack), syserr.TranslateNetstackError(err).ToError()
+	return bool(sack), tcpip.TranslateNetstackError(err).ToError()
 }
 
 // SetTCPSACKEnabled implements inet.Stack.SetTCPSACKEnabled.
 func (s *Stack) SetTCPSACKEnabled(enabled bool) error {
 	opt := tcpip.TCPSACKEnabled(enabled)
-	return syserr.TranslateNetstackError(s.Stack.SetTransportProtocolOption(tcp.ProtocolNumber, &opt)).ToError()
+	return tcpip.TranslateNetstackError(s.Stack.SetTransportProtocolOption(tcp.ProtocolNumber, &opt)).ToError()
 }
 
 // TCPRecovery implements inet.Stack.TCPRecovery.
 func (s *Stack) TCPRecovery() (inet.TCPLossRecovery, error) {
 	var recovery tcpip.TCPRecovery
 	if err := s.Stack.TransportProtocolOption(tcp.ProtocolNumber, &recovery); err != nil {
-		return 0, syserr.TranslateNetstackError(err).ToError()
+		return 0, tcpip.TranslateNetstackError(err).ToError()
 	}
 	return inet.TCPLossRecovery(recovery), nil
 }
@@ -271,7 +271,7 @@ func (s *Stack) TCPRecovery() (inet.TCPLossRecovery, error) {
 // SetTCPRecovery implements inet.Stack.SetTCPRecovery.
 func (s *Stack) SetTCPRecovery(recovery inet.TCPLossRecovery) error {
 	opt := tcpip.TCPRecovery(recovery)
-	return syserr.TranslateNetstackError(s.Stack.SetTransportProtocolOption(tcp.ProtocolNumber, &opt)).ToError()
+	return tcpip.TranslateNetstackError(s.Stack.SetTransportProtocolOption(tcp.ProtocolNumber, &opt)).ToError()
 }
 
 // Statistics implements inet.Stack.Statistics.
@@ -479,5 +479,5 @@ func (s *Stack) PortRange() (uint16, uint16) {
 
 // SetPortRange implements inet.Stack.SetPortRange.
 func (s *Stack) SetPortRange(start uint16, end uint16) error {
-	return syserr.TranslateNetstackError(s.Stack.SetPortRange(start, end)).ToError()
+	return tcpip.TranslateNetstackError(s.Stack.SetPortRange(start, end)).ToError()
 }

pkg/sentry/socket/socket.go

@@ -92,7 +92,7 @@ func sockErrCmsgToLinux(sockErr *tcpip.SockError) linux.SockErrCMsg {
 	}
 
 	ee := linux.SockExtendedErr{
-		Errno:  uint32(syserr.TranslateNetstackError(sockErr.Err).ToLinux()),
+		Errno:  uint32(tcpip.TranslateNetstackError(sockErr.Err).ToLinux()),
 		Origin: errOriginToLinux(sockErr.Cause.Origin()),
 		Type:   sockErr.Cause.Type(),
 		Code:   sockErr.Cause.Code(),