[op] Replace syscall package usage with golang.org/x/sys/unix in test/.

The syscall package has been deprecated in favor of golang.org/x/sys.

Note that syscall is still used in some places because the following don't seem
to have an equivalent in unix package:
- syscall.SysProcIDMap
- syscall.Credential

Updates #214

PiperOrigin-RevId: 361332034

20 files changed, 154 insertions, 156 deletions

diff --git a/test/benchmarks/tcp/tcp_proxy.go b/test/benchmarks/tcp/tcp_proxy.go
index 780e4f7ae..be74e4d4a 100644
--- a/test/benchmarks/tcp/tcp_proxy.go
+++ b/test/benchmarks/tcp/tcp_proxy.go
@@ -29,7 +29,6 @@ import (
 	"runtime"
 	"runtime/pprof"
 	"strconv"
-	"syscall"
 	"time"
 
 	"golang.org/x/sys/unix"
@@ -112,33 +111,33 @@ func setupNetwork(ifaceName string, numChannels int) (fds []int, err error) {
 		const protocol = 0x0300 // htons(ETH_P_ALL)
 		fds := make([]int, numChannels)
 		for i := range fds {
-			fd, err := syscall.Socket(syscall.AF_PACKET, syscall.SOCK_RAW, protocol)
+			fd, err := unix.Socket(unix.AF_PACKET, unix.SOCK_RAW, protocol)
 			if err != nil {
 				return nil, fmt.Errorf("unable to create raw socket: %v", err)
 			}
 
 			// Bind to the appropriate device.
-			ll := syscall.SockaddrLinklayer{
+			ll := unix.SockaddrLinklayer{
 				Protocol: protocol,
 				Ifindex:  iface.Index,
-				Pkttype:  syscall.PACKET_HOST,
+				Pkttype:  unix.PACKET_HOST,
 			}
-			if err := syscall.Bind(fd, &ll); err != nil {
+			if err := unix.Bind(fd, &ll); err != nil {
 				return nil, fmt.Errorf("unable to bind to %q: %v", iface.Name, err)
 			}
 
 			// RAW Sockets by default have a very small SO_RCVBUF of 256KB,
 			// up it to at least 4MB to reduce packet drops.
-			if err := syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_RCVBUF, bufSize); err != nil {
+			if err := unix.SetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_RCVBUF, bufSize); err != nil {
 				return nil, fmt.Errorf("setsockopt(..., SO_RCVBUF, %v,..) = %v", bufSize, err)
 			}
 
-			if err := syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_SNDBUF, bufSize); err != nil {
+			if err := unix.SetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_SNDBUF, bufSize); err != nil {
 				return nil, fmt.Errorf("setsockopt(..., SO_SNDBUF, %v,..) = %v", bufSize, err)
 			}
 
 			if !*swgso && *gso != 0 {
-				if err := syscall.SetsockoptInt(fd, syscall.SOL_PACKET, unix.PACKET_VNET_HDR, 1); err != nil {
+				if err := unix.SetsockoptInt(fd, unix.SOL_PACKET, unix.PACKET_VNET_HDR, 1); err != nil {
 					return nil, fmt.Errorf("unable to enable the PACKET_VNET_HDR option: %v", err)
 				}
 			}
@@ -403,7 +402,7 @@ func main() {
 	log.Printf("client=%v, server=%v, ready.", *client, *server)
 
 	sigs := make(chan os.Signal, 1)
-	signal.Notify(sigs, syscall.SIGTERM)
+	signal.Notify(sigs, unix.SIGTERM)
 	go func() {
 		<-sigs
 		if *cpuprofile != "" {
diff --git a/test/iptables/BUILD b/test/iptables/BUILD
index ae4bba847..94d4ca2d4 100644
--- a/test/iptables/BUILD
+++ b/test/iptables/BUILD
@@ -18,6 +18,7 @@ go_library(
         "//pkg/binary",
         "//pkg/test/testutil",
         "//pkg/usermem",
+        "@org_golang_x_sys//unix:go_default_library",
     ],
 )
 
diff --git a/test/iptables/iptables_unsafe.go b/test/iptables/iptables_unsafe.go
index bd85a8fea..dd1a1c082 100644
--- a/test/iptables/iptables_unsafe.go
+++ b/test/iptables/iptables_unsafe.go
@@ -16,12 +16,13 @@ package iptables
 
 import (
 	"fmt"
-	"syscall"
 	"unsafe"
+
+	"golang.org/x/sys/unix"
 )
 
 type originalDstError struct {
-	errno syscall.Errno
+	errno unix.Errno
 }
 
 func (e originalDstError) Error() string {
@@ -32,27 +33,27 @@ func (e originalDstError) Error() string {
 // getsockopt.
 const SO_ORIGINAL_DST = 80
 
-func originalDestination4(connfd int) (syscall.RawSockaddrInet4, error) {
-	var addr syscall.RawSockaddrInet4
-	var addrLen uint32 = syscall.SizeofSockaddrInet4
-	if errno := originalDestination(connfd, syscall.SOL_IP, unsafe.Pointer(&addr), &addrLen); errno != 0 {
-		return syscall.RawSockaddrInet4{}, originalDstError{errno}
+func originalDestination4(connfd int) (unix.RawSockaddrInet4, error) {
+	var addr unix.RawSockaddrInet4
+	var addrLen uint32 = unix.SizeofSockaddrInet4
+	if errno := originalDestination(connfd, unix.SOL_IP, unsafe.Pointer(&addr), &addrLen); errno != 0 {
+		return unix.RawSockaddrInet4{}, originalDstError{errno}
 	}
 	return addr, nil
 }
 
-func originalDestination6(connfd int) (syscall.RawSockaddrInet6, error) {
-	var addr syscall.RawSockaddrInet6
-	var addrLen uint32 = syscall.SizeofSockaddrInet6
-	if errno := originalDestination(connfd, syscall.SOL_IPV6, unsafe.Pointer(&addr), &addrLen); errno != 0 {
-		return syscall.RawSockaddrInet6{}, originalDstError{errno}
+func originalDestination6(connfd int) (unix.RawSockaddrInet6, error) {
+	var addr unix.RawSockaddrInet6
+	var addrLen uint32 = unix.SizeofSockaddrInet6
+	if errno := originalDestination(connfd, unix.SOL_IPV6, unsafe.Pointer(&addr), &addrLen); errno != 0 {
+		return unix.RawSockaddrInet6{}, originalDstError{errno}
 	}
 	return addr, nil
 }
 
-func originalDestination(connfd int, level uintptr, optval unsafe.Pointer, optlen *uint32) syscall.Errno {
-	_, _, errno := syscall.Syscall6(
-		syscall.SYS_GETSOCKOPT,
+func originalDestination(connfd int, level uintptr, optval unsafe.Pointer, optlen *uint32) unix.Errno {
+	_, _, errno := unix.Syscall6(
+		unix.SYS_GETSOCKOPT,
 		uintptr(connfd),
 		level,
 		SO_ORIGINAL_DST,
diff --git a/test/iptables/nat.go b/test/iptables/nat.go
index 7f1d6d7ad..70d8a1832 100644
--- a/test/iptables/nat.go
+++ b/test/iptables/nat.go
@@ -19,8 +19,8 @@ import (
 	"errors"
 	"fmt"
 	"net"
-	"syscall"
 
+	"golang.org/x/sys/unix"
 	"gvisor.dev/gvisor/pkg/binary"
 	"gvisor.dev/gvisor/pkg/usermem"
 )
@@ -584,33 +584,33 @@ func listenForRedirectedConn(ctx context.Context, ipv6 bool, originalDsts []net.
 	// traditional syscalls.
 
 	// Create the listening socket, bind, listen, and accept.
-	family := syscall.AF_INET
+	family := unix.AF_INET
 	if ipv6 {
-		family = syscall.AF_INET6
+		family = unix.AF_INET6
 	}
-	sockfd, err := syscall.Socket(family, syscall.SOCK_STREAM, 0)
+	sockfd, err := unix.Socket(family, unix.SOCK_STREAM, 0)
 	if err != nil {
 		return err
 	}
-	defer syscall.Close(sockfd)
+	defer unix.Close(sockfd)
 
-	var bindAddr syscall.Sockaddr
+	var bindAddr unix.Sockaddr
 	if ipv6 {
-		bindAddr = &syscall.SockaddrInet6{
+		bindAddr = &unix.SockaddrInet6{
 			Port: acceptPort,
 			Addr: [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // in6addr_any
 		}
 	} else {
-		bindAddr = &syscall.SockaddrInet4{
+		bindAddr = &unix.SockaddrInet4{
 			Port: acceptPort,
 			Addr: [4]byte{0, 0, 0, 0}, // INADDR_ANY
 		}
 	}
-	if err := syscall.Bind(sockfd, bindAddr); err != nil {
+	if err := unix.Bind(sockfd, bindAddr); err != nil {
 		return err
 	}
 
-	if err := syscall.Listen(sockfd, 1); err != nil {
+	if err := unix.Listen(sockfd, 1); err != nil {
 		return err
 	}
 
@@ -619,8 +619,8 @@ func listenForRedirectedConn(ctx context.Context, ipv6 bool, originalDsts []net.
 	errCh := make(chan error)
 	go func() {
 		for {
-			connFD, _, err := syscall.Accept(sockfd)
-			if errors.Is(err, syscall.EINTR) {
+			connFD, _, err := unix.Accept(sockfd)
+			if errors.Is(err, unix.EINTR) {
 				continue
 			}
 			if err != nil {
@@ -641,7 +641,7 @@ func listenForRedirectedConn(ctx context.Context, ipv6 bool, originalDsts []net.
 		return err
 	case connFD = <-connCh:
 	}
-	defer syscall.Close(connFD)
+	defer unix.Close(connFD)
 
 	// Verify that, despite listening on acceptPort, SO_ORIGINAL_DST
 	// indicates the packet was sent to originalDst:dropPort.
@@ -764,35 +764,35 @@ func recvWithRECVORIGDSTADDR(ctx context.Context, ipv6 bool, expectedDst *net.IP
 
 	// Create the listening socket.
 	var (
-		family                    = syscall.AF_INET
-		level                     = syscall.SOL_IP
-		option                    = syscall.IP_RECVORIGDSTADDR
-		bindAddr syscall.Sockaddr = &syscall.SockaddrInet4{
+		family                 = unix.AF_INET
+		level                  = unix.SOL_IP
+		option                 = unix.IP_RECVORIGDSTADDR
+		bindAddr unix.Sockaddr = &unix.SockaddrInet4{
 			Port: int(port),
 			Addr: [4]byte{0, 0, 0, 0}, // INADDR_ANY
 		}
 	)
 	if ipv6 {
-		family = syscall.AF_INET6
-		level = syscall.SOL_IPV6
+		family = unix.AF_INET6
+		level = unix.SOL_IPV6
 		option = 74 // IPV6_RECVORIGDSTADDR, which is missing from the syscall package.
-		bindAddr = &syscall.SockaddrInet6{
+		bindAddr = &unix.SockaddrInet6{
 			Port: int(port),
 			Addr: [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // in6addr_any
 		}
 	}
-	sockfd, err := syscall.Socket(family, syscall.SOCK_DGRAM, 0)
+	sockfd, err := unix.Socket(family, unix.SOCK_DGRAM, 0)
 	if err != nil {
-		return fmt.Errorf("failed Socket(%d, %d, 0): %w", family, syscall.SOCK_DGRAM, err)
+		return fmt.Errorf("failed Socket(%d, %d, 0): %w", family, unix.SOCK_DGRAM, err)
 	}
-	defer syscall.Close(sockfd)
+	defer unix.Close(sockfd)
 
-	if err := syscall.Bind(sockfd, bindAddr); err != nil {
+	if err := unix.Bind(sockfd, bindAddr); err != nil {
 		return fmt.Errorf("failed Bind(%d, %+v): %v", sockfd, bindAddr, err)
 	}
 
 	// Enable IP_RECVORIGDSTADDR.
-	if err := syscall.SetsockoptInt(sockfd, level, option, 1); err != nil {
+	if err := unix.SetsockoptInt(sockfd, level, option, 1); err != nil {
 		return fmt.Errorf("failed SetsockoptByte(%d, %d, %d, 1): %v", sockfd, level, option, err)
 	}
 
@@ -837,41 +837,41 @@ func recvWithRECVORIGDSTADDR(ctx context.Context, ipv6 bool, expectedDst *net.IP
 
 	// Verify that the address has the post-NAT port and address.
 	if ipv6 {
-		return addrMatches6(addr.(syscall.RawSockaddrInet6), localAddrs, redirectPort)
+		return addrMatches6(addr.(unix.RawSockaddrInet6), localAddrs, redirectPort)
 	}
-	return addrMatches4(addr.(syscall.RawSockaddrInet4), localAddrs, redirectPort)
+	return addrMatches4(addr.(unix.RawSockaddrInet4), localAddrs, redirectPort)
 }
 
-func recvOrigDstAddr4(sockfd int) (syscall.RawSockaddrInet4, error) {
-	buf, err := recvOrigDstAddr(sockfd, syscall.SOL_IP, syscall.SizeofSockaddrInet4)
+func recvOrigDstAddr4(sockfd int) (unix.RawSockaddrInet4, error) {
+	buf, err := recvOrigDstAddr(sockfd, unix.SOL_IP, unix.SizeofSockaddrInet4)
 	if err != nil {
-		return syscall.RawSockaddrInet4{}, err
+		return unix.RawSockaddrInet4{}, err
 	}
-	var addr syscall.RawSockaddrInet4
+	var addr unix.RawSockaddrInet4
 	binary.Unmarshal(buf, usermem.ByteOrder, &addr)
 	return addr, nil
 }
 
-func recvOrigDstAddr6(sockfd int) (syscall.RawSockaddrInet6, error) {
-	buf, err := recvOrigDstAddr(sockfd, syscall.SOL_IP, syscall.SizeofSockaddrInet6)
+func recvOrigDstAddr6(sockfd int) (unix.RawSockaddrInet6, error) {
+	buf, err := recvOrigDstAddr(sockfd, unix.SOL_IP, unix.SizeofSockaddrInet6)
 	if err != nil {
-		return syscall.RawSockaddrInet6{}, err
+		return unix.RawSockaddrInet6{}, err
 	}
-	var addr syscall.RawSockaddrInet6
+	var addr unix.RawSockaddrInet6
 	binary.Unmarshal(buf, usermem.ByteOrder, &addr)
 	return addr, nil
 }
 
 func recvOrigDstAddr(sockfd int, level uintptr, addrSize int) ([]byte, error) {
 	buf := make([]byte, 64)
-	oob := make([]byte, syscall.CmsgSpace(addrSize))
+	oob := make([]byte, unix.CmsgSpace(addrSize))
 	for {
-		_, oobn, _, _, err := syscall.Recvmsg(
+		_, oobn, _, _, err := unix.Recvmsg(
 			sockfd,
 			buf, // Message buffer.
 			oob, // Out-of-band buffer.
 			0)   // Flags.
-		if errors.Is(err, syscall.EINTR) {
+		if errors.Is(err, unix.EINTR) {
 			continue
 		}
 		if err != nil {
@@ -880,7 +880,7 @@ func recvOrigDstAddr(sockfd int, level uintptr, addrSize int) ([]byte, error) {
 		oob = oob[:oobn]
 
 		// Parse out the control message.
-		msgs, err := syscall.ParseSocketControlMessage(oob)
+		msgs, err := unix.ParseSocketControlMessage(oob)
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse control message: %w", err)
 		}
@@ -888,10 +888,10 @@ func recvOrigDstAddr(sockfd int, level uintptr, addrSize int) ([]byte, error) {
 	}
 }
 
-func addrMatches4(got syscall.RawSockaddrInet4, wantAddrs []net.IP, port uint16) error {
+func addrMatches4(got unix.RawSockaddrInet4, wantAddrs []net.IP, port uint16) error {
 	for _, wantAddr := range wantAddrs {
-		want := syscall.RawSockaddrInet4{
-			Family: syscall.AF_INET,
+		want := unix.RawSockaddrInet4{
+			Family: unix.AF_INET,
 			Port:   htons(port),
 		}
 		copy(want.Addr[:], wantAddr.To4())
@@ -902,10 +902,10 @@ func addrMatches4(got syscall.RawSockaddrInet4, wantAddrs []net.IP, port uint16)
 	return fmt.Errorf("got %+v, but wanted one of %+v (note: port numbers are in network byte order)", got, wantAddrs)
 }
 
-func addrMatches6(got syscall.RawSockaddrInet6, wantAddrs []net.IP, port uint16) error {
+func addrMatches6(got unix.RawSockaddrInet6, wantAddrs []net.IP, port uint16) error {
 	for _, wantAddr := range wantAddrs {
-		want := syscall.RawSockaddrInet6{
-			Family: syscall.AF_INET6,
+		want := unix.RawSockaddrInet6{
+			Family: unix.AF_INET6,
 			Port:   htons(port),
 		}
 		copy(want.Addr[:], wantAddr.To16())
diff --git a/test/packetimpact/testbench/dut.go b/test/packetimpact/testbench/dut.go
index aeae5e5d3..f4c83ab96 100644
--- a/test/packetimpact/testbench/dut.go
+++ b/test/packetimpact/testbench/dut.go
@@ -19,7 +19,6 @@ import (
 	"encoding/binary"
 	"fmt"
 	"net"
-	"syscall"
 	"testing"
 	"time"
 
@@ -199,7 +198,7 @@ func (dut *DUT) AcceptWithErrno(ctx context.Context, t *testing.T, sockfd int32)
 	if err != nil {
 		t.Fatalf("failed to call Accept: %s", err)
 	}
-	return resp.GetFd(), dut.protoToSockaddr(t, resp.GetAddr()), syscall.Errno(resp.GetErrno_())
+	return resp.GetFd(), dut.protoToSockaddr(t, resp.GetAddr()), unix.Errno(resp.GetErrno_())
 }
 
 // Bind calls bind on the DUT and causes a fatal test failure if it doesn't
@@ -228,7 +227,7 @@ func (dut *DUT) BindWithErrno(ctx context.Context, t *testing.T, fd int32, sa un
 	if err != nil {
 		t.Fatalf("failed to call Bind: %s", err)
 	}
-	return resp.GetRet(), syscall.Errno(resp.GetErrno_())
+	return resp.GetRet(), unix.Errno(resp.GetErrno_())
 }
 
 // Close calls close on the DUT and causes a fatal test failure if it doesn't
@@ -256,7 +255,7 @@ func (dut *DUT) CloseWithErrno(ctx context.Context, t *testing.T, fd int32) (int
 	if err != nil {
 		t.Fatalf("failed to call Close: %s", err)
 	}
-	return resp.GetRet(), syscall.Errno(resp.GetErrno_())
+	return resp.GetRet(), unix.Errno(resp.GetErrno_())
 }
 
 // Connect calls connect on the DUT and causes a fatal test failure if it
@@ -270,7 +269,7 @@ func (dut *DUT) Connect(t *testing.T, fd int32, sa unix.Sockaddr) {
 	ret, err := dut.ConnectWithErrno(ctx, t, fd, sa)
 	// Ignore 'operation in progress' error that can be returned when the socket
 	// is non-blocking.
-	if err != syscall.Errno(unix.EINPROGRESS) && ret != 0 {
+	if err != unix.EINPROGRESS && ret != 0 {
 		t.Fatalf("failed to connect socket: %s", err)
 	}
 }
@@ -287,7 +286,7 @@ func (dut *DUT) ConnectWithErrno(ctx context.Context, t *testing.T, fd int32, sa
 	if err != nil {
 		t.Fatalf("failed to call Connect: %s", err)
 	}
-	return resp.GetRet(), syscall.Errno(resp.GetErrno_())
+	return resp.GetRet(), unix.Errno(resp.GetErrno_())
 }
 
 // GetSockName calls getsockname on the DUT and causes a fatal test failure if
@@ -316,7 +315,7 @@ func (dut *DUT) GetSockNameWithErrno(ctx context.Context, t *testing.T, sockfd i
 	if err != nil {
 		t.Fatalf("failed to call Bind: %s", err)
 	}
-	return resp.GetRet(), dut.protoToSockaddr(t, resp.GetAddr()), syscall.Errno(resp.GetErrno_())
+	return resp.GetRet(), dut.protoToSockaddr(t, resp.GetAddr()), unix.Errno(resp.GetErrno_())
 }
 
 func (dut *DUT) getSockOpt(ctx context.Context, t *testing.T, sockfd, level, optname, optlen int32, typ pb.GetSockOptRequest_SockOptType) (int32, *pb.SockOptVal, error) {
@@ -337,7 +336,7 @@ func (dut *DUT) getSockOpt(ctx context.Context, t *testing.T, sockfd, level, opt
 	if optval == nil {
 		t.Fatalf("GetSockOpt response does not contain a value")
 	}
-	return resp.GetRet(), optval, syscall.Errno(resp.GetErrno_())
+	return resp.GetRet(), optval, unix.Errno(resp.GetErrno_())
 }
 
 // GetSockOpt calls getsockopt on the DUT and causes a fatal test failure if it
@@ -455,7 +454,7 @@ func (dut *DUT) ListenWithErrno(ctx context.Context, t *testing.T, sockfd, backl
 	if err != nil {
 		t.Fatalf("failed to call Listen: %s", err)
 	}
-	return resp.GetRet(), syscall.Errno(resp.GetErrno_())
+	return resp.GetRet(), unix.Errno(resp.GetErrno_())
 }
 
 // PollOne calls poll on the DUT and asserts that the expected event must be
@@ -522,7 +521,7 @@ func (dut *DUT) PollWithErrno(ctx context.Context, t *testing.T, pfds []unix.Pol
 			Revents: int16(protoPfd.GetEvents()),
 		})
 	}
-	return resp.GetRet(), result, syscall.Errno(resp.GetErrno_())
+	return resp.GetRet(), result, unix.Errno(resp.GetErrno_())
 }
 
 // Send calls send on the DUT and causes a fatal test failure if it doesn't
@@ -553,7 +552,7 @@ func (dut *DUT) SendWithErrno(ctx context.Context, t *testing.T, sockfd int32, b
 	if err != nil {
 		t.Fatalf("failed to call Send: %s", err)
 	}
-	return resp.GetRet(), syscall.Errno(resp.GetErrno_())
+	return resp.GetRet(), unix.Errno(resp.GetErrno_())
 }
 
 // SendTo calls sendto on the DUT and causes a fatal test failure if it doesn't
@@ -585,7 +584,7 @@ func (dut *DUT) SendToWithErrno(ctx context.Context, t *testing.T, sockfd int32,
 	if err != nil {
 		t.Fatalf("failed to call SendTo: %s", err)
 	}
-	return resp.GetRet(), syscall.Errno(resp.GetErrno_())
+	return resp.GetRet(), unix.Errno(resp.GetErrno_())
 }
 
 // SetNonBlocking will set O_NONBLOCK flag for fd if nonblocking
@@ -605,7 +604,7 @@ func (dut *DUT) SetNonBlocking(t *testing.T, fd int32, nonblocking bool) {
 		t.Fatalf("failed to call SetNonblocking: %s", err)
 	}
 	if resp.GetRet() == -1 {
-		t.Fatalf("fcntl(%d, %s) failed: %s", fd, resp.GetCmd(), syscall.Errno(resp.GetErrno_()))
+		t.Fatalf("fcntl(%d, %s) failed: %s", fd, resp.GetCmd(), unix.Errno(resp.GetErrno_()))
 	}
 }
 
@@ -622,7 +621,7 @@ func (dut *DUT) setSockOpt(ctx context.Context, t *testing.T, sockfd, level, opt
 	if err != nil {
 		t.Fatalf("failed to call SetSockOpt: %s", err)
 	}
-	return resp.GetRet(), syscall.Errno(resp.GetErrno_())
+	return resp.GetRet(), unix.Errno(resp.GetErrno_())
 }
 
 // SetSockOpt calls setsockopt on the DUT and causes a fatal test failure if it
@@ -723,7 +722,7 @@ func (dut *DUT) SocketWithErrno(t *testing.T, domain, typ, proto int32) (int32,
 	if err != nil {
 		t.Fatalf("failed to call Socket: %s", err)
 	}
-	return resp.GetFd(), syscall.Errno(resp.GetErrno_())
+	return resp.GetFd(), unix.Errno(resp.GetErrno_())
 }
 
 // Recv calls recv on the DUT and causes a fatal test failure if it doesn't
@@ -754,7 +753,7 @@ func (dut *DUT) RecvWithErrno(ctx context.Context, t *testing.T, sockfd, len, fl
 	if err != nil {
 		t.Fatalf("failed to call Recv: %s", err)
 	}
-	return resp.GetRet(), resp.GetBuf(), syscall.Errno(resp.GetErrno_())
+	return resp.GetRet(), resp.GetBuf(), unix.Errno(resp.GetErrno_())
 }
 
 // SetSockLingerOption sets SO_LINGER socket option on the DUT.
@@ -794,5 +793,5 @@ func (dut *DUT) ShutdownWithErrno(ctx context.Context, t *testing.T, fd, how int
 	if err != nil {
 		t.Fatalf("failed to call Shutdown: %s", err)
 	}
-	return syscall.Errno(resp.GetErrno_())
+	return unix.Errno(resp.GetErrno_())
 }
diff --git a/test/packetimpact/tests/tcp_linger_test.go b/test/packetimpact/tests/tcp_linger_test.go
index bc4b64388..6c57b6d37 100644
--- a/test/packetimpact/tests/tcp_linger_test.go
+++ b/test/packetimpact/tests/tcp_linger_test.go
@@ -17,7 +17,6 @@ package tcp_linger_test
 import (
 	"context"
 	"flag"
-	"syscall"
 	"testing"
 	"time"
 
@@ -183,7 +182,7 @@ func TestTCPLingerShutdownZeroTimeout(t *testing.T) {
 	defer closeAll(t, dut, listenFD, conn)
 
 	dut.SetSockLingerOption(t, acceptFD, 0, true)
-	dut.Shutdown(t, acceptFD, syscall.SHUT_RDWR)
+	dut.Shutdown(t, acceptFD, unix.SHUT_RDWR)
 	dut.Close(t, acceptFD)
 
 	// Shutdown will send FIN-ACK with read/write option.
@@ -220,7 +219,7 @@ func TestTCPLingerShutdownSendNonZeroTimeout(t *testing.T) {
 			sampleData := []byte("Sample Data")
 			dut.Send(t, acceptFD, sampleData, 0)
 
-			dut.Shutdown(t, acceptFD, syscall.SHUT_RDWR)
+			dut.Shutdown(t, acceptFD, unix.SHUT_RDWR)
 
 			// Increase timeout as Close will take longer time to
 			// return when SO_LINGER is set with non-zero timeout.
diff --git a/test/packetimpact/tests/tcp_network_unreachable_test.go b/test/packetimpact/tests/tcp_network_unreachable_test.go
index 53dc903e4..4e5b418e4 100644
--- a/test/packetimpact/tests/tcp_network_unreachable_test.go
+++ b/test/packetimpact/tests/tcp_network_unreachable_test.go
@@ -17,7 +17,6 @@ package tcp_synsent_reset_test
 import (
 	"context"
 	"flag"
-	"syscall"
 	"testing"
 	"time"
 
@@ -46,7 +45,7 @@ func TestTCPSynSentUnreachable(t *testing.T) {
 	defer cancel()
 	sa := unix.SockaddrInet4{Port: int(port)}
 	copy(sa.Addr[:], dut.Net.LocalIPv4)
-	if _, err := dut.ConnectWithErrno(ctx, t, clientFD, &sa); err != syscall.Errno(unix.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(ctx, t, clientFD, &sa); err != unix.EINPROGRESS {
 		t.Errorf("got connect() = %v, want EINPROGRESS", err)
 	}
 
@@ -100,7 +99,7 @@ func TestTCPSynSentUnreachable6(t *testing.T) {
 		ZoneId: dut.Net.RemoteDevID,
 	}
 	copy(sa.Addr[:], dut.Net.LocalIPv6)
-	if _, err := dut.ConnectWithErrno(ctx, t, clientFD, &sa); err != syscall.Errno(unix.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(ctx, t, clientFD, &sa); err != unix.EINPROGRESS {
 		t.Errorf("got connect() = %v, want EINPROGRESS", err)
 	}
 
@@ -156,7 +155,7 @@ func getConnectError(t *testing.T, dut *testbench.DUT, fd int32) error {
 	// failure).
 	dut.PollOne(t, fd, unix.POLLOUT, 10*time.Second)
 	if errno := dut.GetSockOptInt(t, fd, unix.SOL_SOCKET, unix.SO_ERROR); errno != 0 {
-		return syscall.Errno(errno)
+		return unix.Errno(errno)
 	}
 	return nil
 }
diff --git a/test/packetimpact/tests/tcp_queue_send_recv_in_syn_sent_test.go b/test/packetimpact/tests/tcp_queue_send_recv_in_syn_sent_test.go
index 7dd1c326a..74616a54c 100644
--- a/test/packetimpact/tests/tcp_queue_send_recv_in_syn_sent_test.go
+++ b/test/packetimpact/tests/tcp_queue_send_recv_in_syn_sent_test.go
@@ -21,7 +21,6 @@ import (
 	"errors"
 	"flag"
 	"sync"
-	"syscall"
 	"testing"
 	"time"
 
@@ -45,7 +44,7 @@ func TestQueueSendInSynSentHandshake(t *testing.T) {
 	sampleData := []byte("Sample Data")
 
 	dut.SetNonBlocking(t, socket, true)
-	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, syscall.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, unix.EINPROGRESS) {
 		t.Fatalf("failed to bring DUT to SYN-SENT, got: %s, want EINPROGRESS", err)
 	}
 	if _, err := conn.Expect(t, testbench.TCP{Flags: testbench.Uint8(header.TCPFlagSyn)}, time.Second); err != nil {
@@ -113,15 +112,15 @@ func TestQueueRecvInSynSentHandshake(t *testing.T) {
 	sampleData := []byte("Sample Data")
 
 	dut.SetNonBlocking(t, socket, true)
-	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, syscall.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, unix.EINPROGRESS) {
 		t.Fatalf("failed to bring DUT to SYN-SENT, got: %s, want EINPROGRESS", err)
 	}
 	if _, err := conn.Expect(t, testbench.TCP{Flags: testbench.Uint8(header.TCPFlagSyn)}, time.Second); err != nil {
 		t.Fatalf("expected a SYN from DUT, but got none: %s", err)
 	}
 
-	if _, _, err := dut.RecvWithErrno(context.Background(), t, socket, int32(len(sampleData)), 0); err != syscall.Errno(unix.EWOULDBLOCK) {
-		t.Fatalf("expected error %s, got %s", syscall.Errno(unix.EWOULDBLOCK), err)
+	if _, _, err := dut.RecvWithErrno(context.Background(), t, socket, int32(len(sampleData)), 0); err != unix.EWOULDBLOCK {
+		t.Fatalf("expected error %s, got %s", unix.EWOULDBLOCK, err)
 	}
 
 	// Test blocking read.
@@ -183,7 +182,7 @@ func TestQueueSendInSynSentRST(t *testing.T) {
 	sampleData := []byte("Sample Data")
 
 	dut.SetNonBlocking(t, socket, true)
-	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, syscall.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, unix.EINPROGRESS) {
 		t.Fatalf("failed to bring DUT to SYN-SENT, got: %s, want EINPROGRESS", err)
 	}
 	if _, err := conn.Expect(t, testbench.TCP{Flags: testbench.Uint8(header.TCPFlagSyn)}, time.Second); err != nil {
@@ -207,8 +206,8 @@ func TestQueueSendInSynSentRST(t *testing.T) {
 		// Issue SEND call in SYN-SENT, this should be queued for
 		// process until the connection is established.
 		n, err := dut.SendWithErrno(ctx, t, socket, sampleData, 0)
-		if err != syscall.Errno(unix.ECONNREFUSED) {
-			t.Errorf("expected error %s, got %s", syscall.Errno(unix.ECONNREFUSED), err)
+		if err != unix.ECONNREFUSED {
+			t.Errorf("expected error %s, got %s", unix.ECONNREFUSED, err)
 		}
 		if n != -1 {
 			t.Errorf("expected return value %d, got %d", -1, n)
@@ -238,15 +237,15 @@ func TestQueueRecvInSynSentRST(t *testing.T) {
 	sampleData := []byte("Sample Data")
 
 	dut.SetNonBlocking(t, socket, true)
-	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, syscall.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, unix.EINPROGRESS) {
 		t.Fatalf("failed to bring DUT to SYN-SENT, got: %s, want EINPROGRESS", err)
 	}
 	if _, err := conn.Expect(t, testbench.TCP{Flags: testbench.Uint8(header.TCPFlagSyn)}, time.Second); err != nil {
 		t.Fatalf("expected a SYN from DUT, but got none: %s", err)
 	}
 
-	if _, _, err := dut.RecvWithErrno(context.Background(), t, socket, int32(len(sampleData)), 0); err != syscall.Errno(unix.EWOULDBLOCK) {
-		t.Fatalf("expected error %s, got %s", syscall.Errno(unix.EWOULDBLOCK), err)
+	if _, _, err := dut.RecvWithErrno(context.Background(), t, socket, int32(len(sampleData)), 0); err != unix.EWOULDBLOCK {
+		t.Fatalf("expected error %s, got %s", unix.EWOULDBLOCK, err)
 	}
 
 	// Test blocking read.
@@ -266,8 +265,8 @@ func TestQueueRecvInSynSentRST(t *testing.T) {
 		// Issue RECEIVE call in SYN-SENT, this should be queued for
 		// process until the connection is established.
 		n, _, err := dut.RecvWithErrno(ctx, t, socket, int32(len(sampleData)), 0)
-		if err != syscall.Errno(unix.ECONNREFUSED) {
-			t.Errorf("expected error %s, got %s", syscall.Errno(unix.ECONNREFUSED), err)
+		if err != unix.ECONNREFUSED {
+			t.Errorf("expected error %s, got %s", unix.ECONNREFUSED, err)
 		}
 		if n != -1 {
 			t.Errorf("expected return value %d, got %d", -1, n)
diff --git a/test/packetimpact/tests/tcp_rcv_buf_space_test.go b/test/packetimpact/tests/tcp_rcv_buf_space_test.go
index d6ad5cda6..042da8fee 100644
--- a/test/packetimpact/tests/tcp_rcv_buf_space_test.go
+++ b/test/packetimpact/tests/tcp_rcv_buf_space_test.go
@@ -17,7 +17,6 @@ package tcp_rcv_buf_space_test
 import (
 	"context"
 	"flag"
-	"syscall"
 	"testing"
 
 	"golang.org/x/sys/unix"
@@ -73,7 +72,7 @@ func TestReduceRecvBuf(t *testing.T) {
 	// Second read should return EAGAIN as the last segment should have been
 	// dropped due to it exceeding the receive buffer space available in the
 	// socket.
-	if ret, got, err := dut.RecvWithErrno(context.Background(), t, acceptFd, int32(len(sampleData)), syscall.MSG_DONTWAIT); got != nil || ret != -1 || err != syscall.EAGAIN {
+	if ret, got, err := dut.RecvWithErrno(context.Background(), t, acceptFd, int32(len(sampleData)), unix.MSG_DONTWAIT); got != nil || ret != -1 || err != unix.EAGAIN {
 		t.Fatalf("expected no packets but got: %s", got)
 	}
 }
diff --git a/test/packetimpact/tests/tcp_unacc_seq_ack_test.go b/test/packetimpact/tests/tcp_unacc_seq_ack_test.go
index ea962c818..b76369dbe 100644
--- a/test/packetimpact/tests/tcp_unacc_seq_ack_test.go
+++ b/test/packetimpact/tests/tcp_unacc_seq_ack_test.go
@@ -17,7 +17,6 @@ package tcp_unacc_seq_ack_test
 import (
 	"flag"
 	"fmt"
-	"syscall"
 	"testing"
 	"time"
 
@@ -171,7 +170,7 @@ func TestActiveCloseUnaccpSeqAck(t *testing.T) {
 			acceptFD, _ := dut.Accept(t, listenFD)
 
 			// Trigger active close.
-			dut.Shutdown(t, acceptFD, syscall.SHUT_WR)
+			dut.Shutdown(t, acceptFD, unix.SHUT_WR)
 
 			// Get to FIN_WAIT2
 			gotTCP, err := conn.Expect(t, testbench.TCP{Flags: testbench.Uint8(header.TCPFlagFin | header.TCPFlagAck)}, time.Second)
diff --git a/test/packetimpact/tests/udp_discard_mcast_source_addr_test.go b/test/packetimpact/tests/udp_discard_mcast_source_addr_test.go
index 52c6f9d91..f63cfcc9a 100644
--- a/test/packetimpact/tests/udp_discard_mcast_source_addr_test.go
+++ b/test/packetimpact/tests/udp_discard_mcast_source_addr_test.go
@@ -19,7 +19,6 @@ import (
 	"flag"
 	"fmt"
 	"net"
-	"syscall"
 	"testing"
 
 	"golang.org/x/sys/unix"
@@ -56,7 +55,7 @@ func TestDiscardsUDPPacketsWithMcastSourceAddressV4(t *testing.T) {
 			)
 
 			ret, payload, errno := dut.RecvWithErrno(context.Background(), t, remoteFD, 100, 0)
-			if errno != syscall.EAGAIN || errno != syscall.EWOULDBLOCK {
+			if errno != unix.EAGAIN || errno != unix.EWOULDBLOCK {
 				t.Errorf("Recv got unexpected result, ret=%d, payload=%q, errno=%s", ret, payload, errno)
 			}
 		})
@@ -86,7 +85,7 @@ func TestDiscardsUDPPacketsWithMcastSourceAddressV6(t *testing.T) {
 				&testbench.Payload{Bytes: []byte("test payload")},
 			)
 			ret, payload, errno := dut.RecvWithErrno(context.Background(), t, remoteFD, 100, 0)
-			if errno != syscall.EAGAIN || errno != syscall.EWOULDBLOCK {
+			if errno != unix.EAGAIN || errno != unix.EWOULDBLOCK {
 				t.Errorf("Recv got unexpected result, ret=%d, payload=%q, errno=%s", ret, payload, errno)
 			}
 		})
diff --git a/test/packetimpact/tests/udp_icmp_error_propagation_test.go b/test/packetimpact/tests/udp_icmp_error_propagation_test.go
index 3fca8c7a3..3159d5b89 100644
--- a/test/packetimpact/tests/udp_icmp_error_propagation_test.go
+++ b/test/packetimpact/tests/udp_icmp_error_propagation_test.go
@@ -20,7 +20,6 @@ import (
 	"fmt"
 	"net"
 	"sync"
-	"syscall"
 	"testing"
 	"time"
 
@@ -86,16 +85,16 @@ type testData struct {
 	remotePort uint16
 	cleanFD    int32
 	cleanPort  uint16
-	wantErrno  syscall.Errno
+	wantErrno  unix.Errno
 }
 
 // wantErrno computes the errno to expect given the connection mode of a UDP
 // socket and the ICMP error it will receive.
-func wantErrno(c connectionMode, icmpErr icmpError) syscall.Errno {
+func wantErrno(c connectionMode, icmpErr icmpError) unix.Errno {
 	if c && icmpErr == portUnreachable {
-		return syscall.Errno(unix.ECONNREFUSED)
+		return unix.ECONNREFUSED
 	}
-	return syscall.Errno(0)
+	return unix.Errno(0)
 }
 
 // sendICMPError sends an ICMP error message in response to a UDP datagram.
@@ -123,7 +122,7 @@ func sendICMPError(t *testing.T, conn *testbench.UDPIPv4, icmpErr icmpError, udp
 	conn.SendFrameStateless(t, layers)
 }
 
-// testRecv tests observing the ICMP error through the recv syscall. A packet
+// testRecv tests observing the ICMP error through the recv unix. A packet
 // is sent to the DUT, and if wantErrno is non-zero, then the first recv should
 // fail and the second should succeed. Otherwise if wantErrno is zero then the
 // first recv should succeed immediately.
@@ -136,7 +135,7 @@ func testRecv(ctx context.Context, t *testing.T, d testData) {
 
 	d.conn.Send(t, testbench.UDP{})
 
-	if d.wantErrno != syscall.Errno(0) {
+	if d.wantErrno != unix.Errno(0) {
 		ctx, cancel := context.WithTimeout(ctx, time.Second)
 		defer cancel()
 		ret, _, err := d.dut.RecvWithErrno(ctx, t, d.remoteFD, 100, 0)
@@ -162,7 +161,7 @@ func testSendTo(ctx context.Context, t *testing.T, d testData) {
 		t.Fatalf("did not receive UDP packet from clean socket on DUT: %s", err)
 	}
 
-	if d.wantErrno != syscall.Errno(0) {
+	if d.wantErrno != unix.Errno(0) {
 		ctx, cancel := context.WithTimeout(ctx, time.Second)
 		defer cancel()
 		ret, err := d.dut.SendToWithErrno(ctx, t, d.remoteFD, nil, 0, d.conn.LocalAddr(t))
@@ -183,11 +182,11 @@ func testSendTo(ctx context.Context, t *testing.T, d testData) {
 
 func testSockOpt(_ context.Context, t *testing.T, d testData) {
 	// Check that there's no pending error on the clean socket.
-	if errno := syscall.Errno(d.dut.GetSockOptInt(t, d.cleanFD, unix.SOL_SOCKET, unix.SO_ERROR)); errno != syscall.Errno(0) {
+	if errno := unix.Errno(d.dut.GetSockOptInt(t, d.cleanFD, unix.SOL_SOCKET, unix.SO_ERROR)); errno != unix.Errno(0) {
 		t.Fatalf("unexpected error (%[1]d) %[1]v on clean socket", errno)
 	}
 
-	if errno := syscall.Errno(d.dut.GetSockOptInt(t, d.remoteFD, unix.SOL_SOCKET, unix.SO_ERROR)); errno != d.wantErrno {
+	if errno := unix.Errno(d.dut.GetSockOptInt(t, d.remoteFD, unix.SOL_SOCKET, unix.SO_ERROR)); errno != d.wantErrno {
 		t.Fatalf("SO_ERROR sockopt after ICMP error is (%[1]d) %[1]v, expected (%[2]d) %[2]v", errno, d.wantErrno)
 	}
 
@@ -310,7 +309,7 @@ func TestICMPErrorDuringUDPRecv(t *testing.T) {
 				go func() {
 					defer wg.Done()
 
-					if wantErrno != syscall.Errno(0) {
+					if wantErrno != unix.Errno(0) {
 						ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 						defer cancel()
 
diff --git a/test/packetimpact/tests/udp_send_recv_dgram_test.go b/test/packetimpact/tests/udp_send_recv_dgram_test.go
index 894d156cf..230b012c7 100644
--- a/test/packetimpact/tests/udp_send_recv_dgram_test.go
+++ b/test/packetimpact/tests/udp_send_recv_dgram_test.go
@@ -19,7 +19,6 @@ import (
 	"flag"
 	"fmt"
 	"net"
-	"syscall"
 	"testing"
 	"time"
 
@@ -241,7 +240,7 @@ func TestUDP(t *testing.T) {
 								},
 							)
 							ret, recvPayload, errno := dut.RecvWithErrno(context.Background(), t, socketFD, 100, 0)
-							if errno != syscall.EAGAIN || errno != syscall.EWOULDBLOCK {
+							if errno != unix.EAGAIN || errno != unix.EWOULDBLOCK {
 								t.Errorf("Recv got unexpected result, ret=%d, payload=%q, errno=%s", ret, recvPayload, errno)
 							}
 						}
diff --git a/test/runner/runner.go b/test/runner/runner.go
index e72c59200..1dc3c2818 100644
--- a/test/runner/runner.go
+++ b/test/runner/runner.go
@@ -103,18 +103,18 @@ func runTestCaseNative(testBin string, tc gtest.TestCase, t *testing.T) {
 	cmd.Env = env
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	cmd.SysProcAttr = &syscall.SysProcAttr{}
+	cmd.SysProcAttr = &unix.SysProcAttr{}
 
 	if specutils.HasCapabilities(capability.CAP_SYS_ADMIN) {
-		cmd.SysProcAttr.Cloneflags |= syscall.CLONE_NEWUTS
+		cmd.SysProcAttr.Cloneflags |= unix.CLONE_NEWUTS
 	}
 
 	if specutils.HasCapabilities(capability.CAP_NET_ADMIN) {
-		cmd.SysProcAttr.Cloneflags |= syscall.CLONE_NEWNET
+		cmd.SysProcAttr.Cloneflags |= unix.CLONE_NEWNET
 	}
 
 	if err := cmd.Run(); err != nil {
-		ws := err.(*exec.ExitError).Sys().(syscall.WaitStatus)
+		ws := err.(*exec.ExitError).Sys().(unix.WaitStatus)
 		t.Errorf("test %q exited with status %d, want 0", tc.FullName(), ws.ExitStatus())
 	}
 }
@@ -148,7 +148,7 @@ func runRunsc(tc gtest.TestCase, spec *specs.Spec) error {
 		"-log-format=text",
 		"-TESTONLY-unsafe-nonroot=true",
 		"-net-raw=true",
-		fmt.Sprintf("-panic-signal=%d", syscall.SIGTERM),
+		fmt.Sprintf("-panic-signal=%d", unix.SIGTERM),
 		"-watchdog-action=panic",
 		"-platform", *platform,
 		"-file-access", *fileAccess,
@@ -176,7 +176,7 @@ func runRunsc(tc gtest.TestCase, spec *specs.Spec) error {
 	}
 
 	testLogDir := ""
-	if undeclaredOutputsDir, ok := syscall.Getenv("TEST_UNDECLARED_OUTPUTS_DIR"); ok {
+	if undeclaredOutputsDir, ok := unix.Getenv("TEST_UNDECLARED_OUTPUTS_DIR"); ok {
 		// Create log directory dedicated for this test.
 		testLogDir = filepath.Join(undeclaredOutputsDir, strings.Replace(name, "/", "_", -1))
 		if err := os.MkdirAll(testLogDir, 0755); err != nil {
@@ -200,8 +200,8 @@ func runRunsc(tc gtest.TestCase, spec *specs.Spec) error {
 	// as root inside that namespace to get it.
 	rArgs := append(args, "run", "--bundle", bundleDir, id)
 	cmd := exec.Command(*runscPath, rArgs...)
-	cmd.SysProcAttr = &syscall.SysProcAttr{
-		Cloneflags: syscall.CLONE_NEWUSER | syscall.CLONE_NEWNS,
+	cmd.SysProcAttr = &unix.SysProcAttr{
+		Cloneflags: unix.CLONE_NEWUSER | unix.CLONE_NEWNS,
 		// Set current user/group as root inside the namespace.
 		UidMappings: []syscall.SysProcIDMap{
 			{ContainerID: 0, HostID: os.Getuid(), Size: 1},
@@ -219,7 +219,7 @@ func runRunsc(tc gtest.TestCase, spec *specs.Spec) error {
 	cmd.Stderr = os.Stderr
 	sig := make(chan os.Signal, 1)
 	defer close(sig)
-	signal.Notify(sig, syscall.SIGTERM)
+	signal.Notify(sig, unix.SIGTERM)
 	defer signal.Stop(sig)
 	go func() {
 		s, ok := <-sig
@@ -247,7 +247,7 @@ func runRunsc(tc gtest.TestCase, spec *specs.Spec) error {
 
 		log.Warningf("Send SIGTERM to the sandbox process")
 		dArgs = append(args, "debug",
-			fmt.Sprintf("--signal=%d", syscall.SIGTERM),
+			fmt.Sprintf("--signal=%d", unix.SIGTERM),
 			id)
 		signal := exec.Command(*runscPath, dArgs...)
 		signal.Stdout = os.Stdout
diff --git a/test/runtimes/proctor/BUILD b/test/runtimes/proctor/BUILD
index fdc6d3173..b4a9b12de 100644
--- a/test/runtimes/proctor/BUILD
+++ b/test/runtimes/proctor/BUILD
@@ -7,5 +7,8 @@ go_binary(
     srcs = ["main.go"],
     pure = True,
     visibility = ["//test/runtimes:__pkg__"],
-    deps = ["//test/runtimes/proctor/lib"],
+    deps = [
+        "//test/runtimes/proctor/lib",
+        "@org_golang_x_sys//unix:go_default_library",
+    ],
 )
diff --git a/test/runtimes/proctor/lib/BUILD b/test/runtimes/proctor/lib/BUILD
index 0c8367dfe..f834f1b5a 100644
--- a/test/runtimes/proctor/lib/BUILD
+++ b/test/runtimes/proctor/lib/BUILD
@@ -13,6 +13,7 @@ go_library(
         "python.go",
     ],
     visibility = ["//test/runtimes/proctor:__pkg__"],
+    deps = ["@org_golang_x_sys//unix:go_default_library"],
 )
 
 go_test(
diff --git a/test/runtimes/proctor/lib/lib.go b/test/runtimes/proctor/lib/lib.go
index f2ba82498..36c60088a 100644
--- a/test/runtimes/proctor/lib/lib.go
+++ b/test/runtimes/proctor/lib/lib.go
@@ -22,7 +22,8 @@ import (
 	"os/signal"
 	"path/filepath"
 	"regexp"
-	"syscall"
+
+	"golang.org/x/sys/unix"
 )
 
 // TestRunner is an interface that must be implemented for each runtime
@@ -59,7 +60,7 @@ func TestRunnerForRuntime(runtime string) (TestRunner, error) {
 func PauseAndReap() {
 	// Get notified of any new children.
 	ch := make(chan os.Signal, 1)
-	signal.Notify(ch, syscall.SIGCHLD)
+	signal.Notify(ch, unix.SIGCHLD)
 
 	for {
 		if _, ok := <-ch; !ok {
@@ -69,7 +70,7 @@ func PauseAndReap() {
 
 		// Reap the child.
 		for {
-			if cpid, _ := syscall.Wait4(-1, nil, syscall.WNOHANG, nil); cpid < 1 {
+			if cpid, _ := unix.Wait4(-1, nil, unix.WNOHANG, nil); cpid < 1 {
 				break
 			}
 		}
diff --git a/test/runtimes/proctor/main.go b/test/runtimes/proctor/main.go
index 81cb68381..8c076a499 100644
--- a/test/runtimes/proctor/main.go
+++ b/test/runtimes/proctor/main.go
@@ -22,8 +22,8 @@ import (
 	"log"
 	"os"
 	"strings"
-	"syscall"
 
+	"golang.org/x/sys/unix"
 	"gvisor.dev/gvisor/test/runtimes/proctor/lib"
 )
 
@@ -42,14 +42,14 @@ func setNumFilesLimit() error {
 	// timeout if the NOFILE limit is too high. On gVisor, syscalls are
 	// slower so these tests will need even more time to pass.
 	const nofile = 32768
-	rLimit := syscall.Rlimit{}
-	err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+	rLimit := unix.Rlimit{}
+	err := unix.Getrlimit(unix.RLIMIT_NOFILE, &rLimit)
 	if err != nil {
 		return fmt.Errorf("failed to get RLIMIT_NOFILE: %v", err)
 	}
 	if rLimit.Cur > nofile {
 		rLimit.Cur = nofile
-		err := syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+		err := unix.Setrlimit(unix.RLIMIT_NOFILE, &rLimit)
 		if err != nil {
 			return fmt.Errorf("failed to set RLIMIT_NOFILE: %v", err)
 		}
diff --git a/test/uds/BUILD b/test/uds/BUILD
index 51e2c7ce8..a8f49b50c 100644
--- a/test/uds/BUILD
+++ b/test/uds/BUILD
@@ -12,5 +12,6 @@ go_library(
     deps = [
         "//pkg/log",
         "//pkg/unet",
+        "@org_golang_x_sys//unix:go_default_library",
     ],
 )
diff --git a/test/uds/uds.go b/test/uds/uds.go
index b714c61b0..02a4a7dee 100644
--- a/test/uds/uds.go
+++ b/test/uds/uds.go
@@ -21,8 +21,8 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"syscall"
 
+	"golang.org/x/sys/unix"
 	"gvisor.dev/gvisor/pkg/log"
 	"gvisor.dev/gvisor/pkg/unet"
 )
@@ -31,16 +31,16 @@ import (
 //
 // Only works for stream, seqpacket sockets.
 func createEchoSocket(path string, protocol int) (cleanup func(), err error) {
-	fd, err := syscall.Socket(syscall.AF_UNIX, protocol, 0)
+	fd, err := unix.Socket(unix.AF_UNIX, protocol, 0)
 	if err != nil {
 		return nil, fmt.Errorf("error creating echo(%d) socket: %v", protocol, err)
 	}
 
-	if err := syscall.Bind(fd, &syscall.SockaddrUnix{Name: path}); err != nil {
+	if err := unix.Bind(fd, &unix.SockaddrUnix{Name: path}); err != nil {
 		return nil, fmt.Errorf("error binding echo(%d) socket: %v", protocol, err)
 	}
 
-	if err := syscall.Listen(fd, 0); err != nil {
+	if err := unix.Listen(fd, 0); err != nil {
 		return nil, fmt.Errorf("error listening echo(%d) socket: %v", protocol, err)
 	}
 
@@ -97,17 +97,17 @@ func createEchoSocket(path string, protocol int) (cleanup func(), err error) {
 //
 // Only relevant for stream, seqpacket sockets.
 func createNonListeningSocket(path string, protocol int) (cleanup func(), err error) {
-	fd, err := syscall.Socket(syscall.AF_UNIX, protocol, 0)
+	fd, err := unix.Socket(unix.AF_UNIX, protocol, 0)
 	if err != nil {
 		return nil, fmt.Errorf("error creating nonlistening(%d) socket: %v", protocol, err)
 	}
 
-	if err := syscall.Bind(fd, &syscall.SockaddrUnix{Name: path}); err != nil {
+	if err := unix.Bind(fd, &unix.SockaddrUnix{Name: path}); err != nil {
 		return nil, fmt.Errorf("error binding nonlistening(%d) socket: %v", protocol, err)
 	}
 
 	cleanup = func() {
-		if err := syscall.Close(fd); err != nil {
+		if err := unix.Close(fd); err != nil {
 			log.Warningf("Failed to close nonlistening(%d) socket: %v", protocol, err)
 		}
 	}
@@ -119,12 +119,12 @@ func createNonListeningSocket(path string, protocol int) (cleanup func(), err er
 //
 // Only works for dgram sockets.
 func createNullSocket(path string, protocol int) (cleanup func(), err error) {
-	fd, err := syscall.Socket(syscall.AF_UNIX, protocol, 0)
+	fd, err := unix.Socket(unix.AF_UNIX, protocol, 0)
 	if err != nil {
 		return nil, fmt.Errorf("error creating null(%d) socket: %v", protocol, err)
 	}
 
-	if err := syscall.Bind(fd, &syscall.SockaddrUnix{Name: path}); err != nil {
+	if err := unix.Bind(fd, &unix.SockaddrUnix{Name: path}); err != nil {
 		return nil, fmt.Errorf("error binding null(%d) socket: %v", protocol, err)
 	}
 
@@ -174,7 +174,7 @@ func CreateSocketTree(baseDir string) (dir string, cleanup func(), err error) {
 		sockets  map[string]socketCreator
 	}{
 		{
-			protocol: syscall.SOCK_STREAM,
+			protocol: unix.SOCK_STREAM,
 			name:     "stream",
 			sockets: map[string]socketCreator{
 				"echo":         createEchoSocket,
@@ -182,7 +182,7 @@ func CreateSocketTree(baseDir string) (dir string, cleanup func(), err error) {
 			},
 		},
 		{
-			protocol: syscall.SOCK_SEQPACKET,
+			protocol: unix.SOCK_SEQPACKET,
 			name:     "seqpacket",
 			sockets: map[string]socketCreator{
 				"echo":         createEchoSocket,
@@ -190,7 +190,7 @@ func CreateSocketTree(baseDir string) (dir string, cleanup func(), err error) {
 			},
 		},
 		{
-			protocol: syscall.SOCK_DGRAM,
+			protocol: unix.SOCK_DGRAM,
 			name:     "dgram",
 			sockets: map[string]socketCreator{
 				"null": createNullSocket,