syscall_linux.go

     1  // Copyright 2022 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Package linux provides the syscall primitives required for the runtime.
     6  package linux
     7  
     8  import (
     9  	"internal/goarch"
    10  	"unsafe"
    11  )
    12  
    13  // TODO(https://go.dev/issue/51087): Move remaining syscalls to this package.
    14  
    15  // Syscall6 calls system call number 'num' with arguments a1-6.
    16  func Syscall6(num, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, errno uintptr)
    17  
    18  func EpollCreate1(flags int32) (fd int32, errno uintptr) {
    19  	r1, _, e := Syscall6(SYS_EPOLL_CREATE1, uintptr(flags), 0, 0, 0, 0, 0)
    20  	return int32(r1), e
    21  }
    22  
    23  var _zero uintptr
    24  
    25  func EpollWait(epfd int32, events []EpollEvent, maxev, waitms int32) (n int32, errno uintptr) {
    26  	var ev unsafe.Pointer
    27  	if len(events) > 0 {
    28  		ev = unsafe.Pointer(&events[0])
    29  	} else {
    30  		ev = unsafe.Pointer(&_zero)
    31  	}
    32  	r1, _, e := Syscall6(SYS_EPOLL_PWAIT, uintptr(epfd), uintptr(ev), uintptr(maxev), uintptr(waitms), 0, 0)
    33  	return int32(r1), e
    34  }
    35  
    36  func EpollCtl(epfd, op, fd int32, event *EpollEvent) (errno uintptr) {
    37  	_, _, e := Syscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
    38  	return e
    39  }
    40  
    41  func Eventfd(initval, flags int32) (fd int32, errno uintptr) {
    42  	r1, _, e := Syscall6(SYS_EVENTFD2, uintptr(initval), uintptr(flags), 0, 0, 0, 0)
    43  	return int32(r1), e
    44  }
    45  
    46  func Open(path *byte, mode int, perm uint32) (fd int, errno uintptr) {
    47  	// Use SYS_OPENAT to match the syscall package.
    48  	dfd := AT_FDCWD
    49  	r1, _, e := Syscall6(SYS_OPENAT, uintptr(dfd), uintptr(unsafe.Pointer(path)), uintptr(mode|O_LARGEFILE), uintptr(perm), 0, 0)
    50  	return int(r1), e
    51  }
    52  
    53  func Close(fd int) (errno uintptr) {
    54  	_, _, e := Syscall6(SYS_CLOSE, uintptr(fd), 0, 0, 0, 0, 0)
    55  	return e
    56  }
    57  
    58  func Read(fd int, p []byte) (n int, errno uintptr) {
    59  	var p0 unsafe.Pointer
    60  	if len(p) > 0 {
    61  		p0 = unsafe.Pointer(&p[0])
    62  	} else {
    63  		p0 = unsafe.Pointer(&_zero)
    64  	}
    65  	r1, _, e := Syscall6(SYS_READ, uintptr(fd), uintptr(p0), uintptr(len(p)), 0, 0, 0)
    66  	return int(r1), e
    67  }
    68  
    69  func Pread(fd int, p []byte, offset int64) (n int, errno uintptr) {
    70  	var p0 unsafe.Pointer
    71  	if len(p) > 0 {
    72  		p0 = unsafe.Pointer(&p[0])
    73  	} else {
    74  		p0 = unsafe.Pointer(&_zero)
    75  	}
    76  	var r1, e uintptr
    77  	switch goarch.GOARCH {
    78  	case "386":
    79  		r1, _, e = Syscall6(SYS_PREAD64, uintptr(fd), uintptr(p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
    80  	case "arm", "mipsle":
    81  		r1, _, e = Syscall6(SYS_PREAD64, uintptr(fd), uintptr(p0), uintptr(len(p)), 0, uintptr(offset), uintptr(offset>>32))
    82  	case "mips":
    83  		r1, _, e = Syscall6(SYS_PREAD64, uintptr(fd), uintptr(p0), uintptr(len(p)), 0, uintptr(offset>>32), uintptr(offset))
    84  	default:
    85  		r1, _, e = Syscall6(SYS_PREAD64, uintptr(fd), uintptr(p0), uintptr(len(p)), uintptr(offset), 0, 0)
    86  	}
    87  	return int(r1), e
    88  }
    89
View as plain text