internal/runtime/syscall: rename to internal/runtime/syscall/linux

All code in internal/runtime/syscall is Linux-specific, so better
move it to a new linux sub-directory. This way it will be easier
to factor out runtime syscall code from other platforms, e.g.
Windows.

Updates #51087.

Change-Id: Idd2a52444b33bf3ad576b47fd232e990cdc8ae75
Reviewed-on: https://go-review.googlesource.com/c/go/+/689155
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Michael Pratt <mpratt@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

4 files changed, 26 insertions, 26 deletions

diff --git a/src/runtime/netpoll_epoll.go b/src/runtime/netpoll_epoll.go
index c43bab0882..48c03d119f 100644
--- a/src/runtime/netpoll_epoll.go
+++ b/src/runtime/netpoll_epoll.go
@@ -8,7 +8,7 @@ package runtime
 
 import (
 	"internal/runtime/atomic"
-	"internal/runtime/syscall"
+	"internal/runtime/syscall/linux"
 	"unsafe"
 )
 
@@ -20,21 +20,21 @@ var (
 
 func netpollinit() {
 	var errno uintptr
-	epfd, errno = syscall.EpollCreate1(syscall.EPOLL_CLOEXEC)
+	epfd, errno = linux.EpollCreate1(linux.EPOLL_CLOEXEC)
 	if errno != 0 {
 		println("runtime: epollcreate failed with", errno)
 		throw("runtime: netpollinit failed")
 	}
-	efd, errno := syscall.Eventfd(0, syscall.EFD_CLOEXEC|syscall.EFD_NONBLOCK)
+	efd, errno := linux.Eventfd(0, linux.EFD_CLOEXEC|linux.EFD_NONBLOCK)
 	if errno != 0 {
 		println("runtime: eventfd failed with", -errno)
 		throw("runtime: eventfd failed")
 	}
-	ev := syscall.EpollEvent{
-		Events: syscall.EPOLLIN,
+	ev := linux.EpollEvent{
+		Events: linux.EPOLLIN,
 	}
 	*(**uintptr)(unsafe.Pointer(&ev.Data)) = &netpollEventFd
-	errno = syscall.EpollCtl(epfd, syscall.EPOLL_CTL_ADD, efd, &ev)
+	errno = linux.EpollCtl(epfd, linux.EPOLL_CTL_ADD, efd, &ev)
 	if errno != 0 {
 		println("runtime: epollctl failed with", errno)
 		throw("runtime: epollctl failed")
@@ -47,16 +47,16 @@ func netpollIsPollDescriptor(fd uintptr) bool {
 }
 
 func netpollopen(fd uintptr, pd *pollDesc) uintptr {
-	var ev syscall.EpollEvent
-	ev.Events = syscall.EPOLLIN | syscall.EPOLLOUT | syscall.EPOLLRDHUP | syscall.EPOLLET
+	var ev linux.EpollEvent
+	ev.Events = linux.EPOLLIN | linux.EPOLLOUT | linux.EPOLLRDHUP | linux.EPOLLET
 	tp := taggedPointerPack(unsafe.Pointer(pd), pd.fdseq.Load())
 	*(*taggedPointer)(unsafe.Pointer(&ev.Data)) = tp
-	return syscall.EpollCtl(epfd, syscall.EPOLL_CTL_ADD, int32(fd), &ev)
+	return linux.EpollCtl(epfd, linux.EPOLL_CTL_ADD, int32(fd), &ev)
 }
 
 func netpollclose(fd uintptr) uintptr {
-	var ev syscall.EpollEvent
-	return syscall.EpollCtl(epfd, syscall.EPOLL_CTL_DEL, int32(fd), &ev)
+	var ev linux.EpollEvent
+	return linux.EpollCtl(epfd, linux.EPOLL_CTL_DEL, int32(fd), &ev)
 }
 
 func netpollarm(pd *pollDesc, mode int) {
@@ -114,9 +114,9 @@ func netpoll(delay int64) (gList, int32) {
 		// 1e9 ms == ~11.5 days.
 		waitms = 1e9
 	}
-	var events [128]syscall.EpollEvent
+	var events [128]linux.EpollEvent
 retry:
-	n, errno := syscall.EpollWait(epfd, events[:], int32(len(events)), waitms)
+	n, errno := linux.EpollWait(epfd, events[:], int32(len(events)), waitms)
 	if errno != 0 {
 		if errno != _EINTR {
 			println("runtime: epollwait on fd", epfd, "failed with", errno)
@@ -138,7 +138,7 @@ retry:
 		}
 
 		if *(**uintptr)(unsafe.Pointer(&ev.Data)) == &netpollEventFd {
-			if ev.Events != syscall.EPOLLIN {
+			if ev.Events != linux.EPOLLIN {
 				println("runtime: netpoll: eventfd ready for", ev.Events)
 				throw("runtime: netpoll: eventfd ready for something unexpected")
 			}
@@ -156,10 +156,10 @@ retry:
 		}
 
 		var mode int32
-		if ev.Events&(syscall.EPOLLIN|syscall.EPOLLRDHUP|syscall.EPOLLHUP|syscall.EPOLLERR) != 0 {
+		if ev.Events&(linux.EPOLLIN|linux.EPOLLRDHUP|linux.EPOLLHUP|linux.EPOLLERR) != 0 {
 			mode += 'r'
 		}
-		if ev.Events&(syscall.EPOLLOUT|syscall.EPOLLHUP|syscall.EPOLLERR) != 0 {
+		if ev.Events&(linux.EPOLLOUT|linux.EPOLLHUP|linux.EPOLLERR) != 0 {
 			mode += 'w'
 		}
 		if mode != 0 {
@@ -167,7 +167,7 @@ retry:
 			pd := (*pollDesc)(tp.pointer())
 			tag := tp.tag()
 			if pd.fdseq.Load() == tag {
-				pd.setEventErr(ev.Events == syscall.EPOLLERR, tag)
+				pd.setEventErr(ev.Events == linux.EPOLLERR, tag)
 				delta += netpollready(&toRun, pd, mode)
 			}
 		}
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index fd560ddf5a..0ec5e43007 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -9,7 +9,7 @@ import (
 	"internal/goarch"
 	"internal/runtime/atomic"
 	"internal/runtime/strconv"
-	"internal/runtime/syscall"
+	"internal/runtime/syscall/linux"
 	"unsafe"
 )
 
@@ -470,7 +470,7 @@ func pipe2(flags int32) (r, w int32, errno int32)
 
 //go:nosplit
 func fcntl(fd, cmd, arg int32) (ret int32, errno int32) {
-	r, _, err := syscall.Syscall6(syscall.SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg), 0, 0, 0)
+	r, _, err := linux.Syscall6(linux.SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg), 0, 0, 0)
 	return int32(r), int32(err)
 }
 
@@ -773,7 +773,7 @@ func syscall_runtime_doAllThreadsSyscall(trap, a1, a2, a3, a4, a5, a6 uintptr) (
 	// ensuring all threads execute system calls from multiple calls in the
 	// same order.
 
-	r1, r2, errno := syscall.Syscall6(trap, a1, a2, a3, a4, a5, a6)
+	r1, r2, errno := linux.Syscall6(trap, a1, a2, a3, a4, a5, a6)
 	if GOARCH == "ppc64" || GOARCH == "ppc64le" {
 		// TODO(https://go.dev/issue/51192 ): ppc64 doesn't use r2.
 		r2 = 0
@@ -884,7 +884,7 @@ func runPerThreadSyscall() {
 	}
 
 	args := perThreadSyscall
-	r1, r2, errno := syscall.Syscall6(args.trap, args.a1, args.a2, args.a3, args.a4, args.a5, args.a6)
+	r1, r2, errno := linux.Syscall6(args.trap, args.a1, args.a2, args.a3, args.a4, args.a5, args.a6)
 	if GOARCH == "ppc64" || GOARCH == "ppc64le" {
 		// TODO(https://go.dev/issue/51192 ): ppc64 doesn't use r2.
 		r2 = 0
@@ -923,6 +923,6 @@ func (c *sigctxt) sigFromSeccomp() bool {
 
 //go:nosplit
 func mprotect(addr unsafe.Pointer, n uintptr, prot int32) (ret int32, errno int32) {
-	r, _, err := syscall.Syscall6(syscall.SYS_MPROTECT, uintptr(addr), n, uintptr(prot), 0, 0, 0)
+	r, _, err := linux.Syscall6(linux.SYS_MPROTECT, uintptr(addr), n, uintptr(prot), 0, 0, 0)
 	return int32(r), int32(err)
 }
diff --git a/src/runtime/os_linux_riscv64.go b/src/runtime/os_linux_riscv64.go
index c4a4d4e50d..65fa601a29 100644
--- a/src/runtime/os_linux_riscv64.go
+++ b/src/runtime/os_linux_riscv64.go
@@ -5,7 +5,7 @@
 package runtime
 
 import (
-	"internal/runtime/syscall"
+	"internal/runtime/syscall/linux"
 	"unsafe"
 )
 
@@ -32,6 +32,6 @@ func internal_cpu_riscvHWProbe(pairs []riscvHWProbePairs, flags uint) bool {
 	}
 	// Passing in a cpuCount of 0 and a cpu of nil ensures that only extensions supported by all the
 	// cores are returned, which is the behaviour we want in internal/cpu.
-	_, _, e1 := syscall.Syscall6(sys_RISCV_HWPROBE, uintptr(unsafe.Pointer(&pairs[0])), uintptr(len(pairs)), uintptr(0), uintptr(unsafe.Pointer(nil)), uintptr(flags), 0)
+	_, _, e1 := linux.Syscall6(sys_RISCV_HWPROBE, uintptr(unsafe.Pointer(&pairs[0])), uintptr(len(pairs)), uintptr(0), uintptr(unsafe.Pointer(nil)), uintptr(flags), 0)
 	return e1 == 0
 }
diff --git a/src/runtime/set_vma_name_linux.go b/src/runtime/set_vma_name_linux.go
index 100c2bfeca..9b6654f332 100644
--- a/src/runtime/set_vma_name_linux.go
+++ b/src/runtime/set_vma_name_linux.go
@@ -8,7 +8,7 @@ package runtime
 
 import (
 	"internal/runtime/atomic"
-	"internal/runtime/syscall"
+	"internal/runtime/syscall/linux"
 	"unsafe"
 )
 
@@ -24,7 +24,7 @@ func setVMAName(start unsafe.Pointer, length uintptr, name string) {
 	n := copy(sysName[:], " Go: ")
 	copy(sysName[n:79], name) // leave final byte zero
 
-	_, _, err := syscall.Syscall6(syscall.SYS_PRCTL, syscall.PR_SET_VMA, syscall.PR_SET_VMA_ANON_NAME, uintptr(start), length, uintptr(unsafe.Pointer(&sysName[0])), 0)
+	_, _, err := linux.Syscall6(linux.SYS_PRCTL, linux.PR_SET_VMA, linux.PR_SET_VMA_ANON_NAME, uintptr(start), length, uintptr(unsafe.Pointer(&sysName[0])), 0)
 	if err == _EINVAL {
 		prSetVMAUnsupported.Store(true)
 	}