blob: 3a5078a64c45c0f4ece5d6a1c3d75ab215679981 [file] [log] [blame]
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//go:build aix
package runtime
import (
"internal/abi"
"runtime/internal/atomic"
"unsafe"
)
const (
threadStackSize = 0x100000 // size of a thread stack allocated by OS
)
// funcDescriptor is a structure representing a function descriptor
// A variable with this type is always created in assembler
type funcDescriptor struct {
fn uintptr
toc uintptr
envPointer uintptr // unused in Golang
}
type mOS struct {
waitsema uintptr // semaphore for parking on locks
perrno uintptr // pointer to tls errno
}
//go:nosplit
func semacreate(mp *m) {
if mp.waitsema != 0 {
return
}
var sem *semt
// Call libc's malloc rather than malloc. This will
// allocate space on the C heap. We can't call mallocgc
// here because it could cause a deadlock.
sem = (*semt)(malloc(unsafe.Sizeof(*sem)))
if sem_init(sem, 0, 0) != 0 {
throw("sem_init")
}
mp.waitsema = uintptr(unsafe.Pointer(sem))
}
//go:nosplit
func semasleep(ns int64) int32 {
mp := getg().m
if ns >= 0 {
var ts timespec
if clock_gettime(_CLOCK_REALTIME, &ts) != 0 {
throw("clock_gettime")
}
ts.tv_sec += ns / 1e9
ts.tv_nsec += ns % 1e9
if ts.tv_nsec >= 1e9 {
ts.tv_sec++
ts.tv_nsec -= 1e9
}
if r, err := sem_timedwait((*semt)(unsafe.Pointer(mp.waitsema)), &ts); r != 0 {
if err == _ETIMEDOUT || err == _EAGAIN || err == _EINTR {
return -1
}
println("sem_timedwait err ", err, " ts.tv_sec ", ts.tv_sec, " ts.tv_nsec ", ts.tv_nsec, " ns ", ns, " id ", mp.id)
throw("sem_timedwait")
}
return 0
}
for {
r1, err := sem_wait((*semt)(unsafe.Pointer(mp.waitsema)))
if r1 == 0 {
break
}
if err == _EINTR {
continue
}
throw("sem_wait")
}
return 0
}
//go:nosplit
func semawakeup(mp *m) {
if sem_post((*semt)(unsafe.Pointer(mp.waitsema))) != 0 {
throw("sem_post")
}
}
func osinit() {
// Call miniterrno so that we can safely make system calls
// before calling minit on m0.
miniterrno()
ncpu = int32(sysconf(__SC_NPROCESSORS_ONLN))
physPageSize = sysconf(__SC_PAGE_SIZE)
}
// newosproc0 is a version of newosproc that can be called before the runtime
// is initialized.
//
// This function is not safe to use after initialization as it does not pass an M as fnarg.
//
//go:nosplit
func newosproc0(stacksize uintptr, fn *funcDescriptor) {
var (
attr pthread_attr
oset sigset
tid pthread
)
if pthread_attr_init(&attr) != 0 {
writeErrStr(failthreadcreate)
exit(1)
}
if pthread_attr_setstacksize(&attr, threadStackSize) != 0 {
writeErrStr(failthreadcreate)
exit(1)
}
if pthread_attr_setdetachstate(&attr, _PTHREAD_CREATE_DETACHED) != 0 {
writeErrStr(failthreadcreate)
exit(1)
}
// Disable signals during create, so that the new thread starts
// with signals disabled. It will enable them in minit.
sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
var ret int32
for tries := 0; tries < 20; tries++ {
// pthread_create can fail with EAGAIN for no reasons
// but it will be ok if it retries.
ret = pthread_create(&tid, &attr, fn, nil)
if ret != _EAGAIN {
break
}
usleep(uint32(tries+1) * 1000) // Milliseconds.
}
sigprocmask(_SIG_SETMASK, &oset, nil)
if ret != 0 {
writeErrStr(failthreadcreate)
exit(1)
}
}
// Called to do synchronous initialization of Go code built with
// -buildmode=c-archive or -buildmode=c-shared.
// None of the Go runtime is initialized.
//
//go:nosplit
//go:nowritebarrierrec
func libpreinit() {
initsig(true)
}
// Ms related functions
func mpreinit(mp *m) {
mp.gsignal = malg(32 * 1024) // AIX wants >= 8K
mp.gsignal.m = mp
}
// errno address must be retrieved by calling _Errno libc function.
// This will return a pointer to errno.
func miniterrno() {
mp := getg().m
r, _ := syscall0(&libc__Errno)
mp.perrno = r
}
func minit() {
miniterrno()
minitSignals()
getg().m.procid = uint64(pthread_self())
}
func unminit() {
unminitSignals()
getg().m.procid = 0
}
// Called from exitm, but not from drop, to undo the effect of thread-owned
// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
func mdestroy(mp *m) {
}
// tstart is a function descriptor to _tstart defined in assembly.
var tstart funcDescriptor
func newosproc(mp *m) {
var (
attr pthread_attr
oset sigset
tid pthread
)
if pthread_attr_init(&attr) != 0 {
throw("pthread_attr_init")
}
if pthread_attr_setstacksize(&attr, threadStackSize) != 0 {
throw("pthread_attr_getstacksize")
}
if pthread_attr_setdetachstate(&attr, _PTHREAD_CREATE_DETACHED) != 0 {
throw("pthread_attr_setdetachstate")
}
// Disable signals during create, so that the new thread starts
// with signals disabled. It will enable them in minit.
sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
ret := retryOnEAGAIN(func() int32 {
return pthread_create(&tid, &attr, &tstart, unsafe.Pointer(mp))
})
sigprocmask(_SIG_SETMASK, &oset, nil)
if ret != 0 {
print("runtime: failed to create new OS thread (have ", mcount(), " already; errno=", ret, ")\n")
if ret == _EAGAIN {
println("runtime: may need to increase max user processes (ulimit -u)")
}
throw("newosproc")
}
}
func exitThread(wait *atomic.Uint32) {
// We should never reach exitThread on AIX because we let
// libc clean up threads.
throw("exitThread")
}
var urandom_dev = []byte("/dev/urandom\x00")
//go:nosplit
func readRandom(r []byte) int {
fd := open(&urandom_dev[0], 0 /* O_RDONLY */, 0)
n := read(fd, unsafe.Pointer(&r[0]), int32(len(r)))
closefd(fd)
return int(n)
}
func goenvs() {
goenvs_unix()
}
/* SIGNAL */
const (
_NSIG = 256
)
// sigtramp is a function descriptor to _sigtramp defined in assembly
var sigtramp funcDescriptor
//go:nosplit
//go:nowritebarrierrec
func setsig(i uint32, fn uintptr) {
var sa sigactiont
sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK | _SA_RESTART
sa.sa_mask = sigset_all
if fn == abi.FuncPCABIInternal(sighandler) { // abi.FuncPCABIInternal(sighandler) matches the callers in signal_unix.go
fn = uintptr(unsafe.Pointer(&sigtramp))
}
sa.sa_handler = fn
sigaction(uintptr(i), &sa, nil)
}
//go:nosplit
//go:nowritebarrierrec
func setsigstack(i uint32) {
var sa sigactiont
sigaction(uintptr(i), nil, &sa)
if sa.sa_flags&_SA_ONSTACK != 0 {
return
}
sa.sa_flags |= _SA_ONSTACK
sigaction(uintptr(i), &sa, nil)
}
//go:nosplit
//go:nowritebarrierrec
func getsig(i uint32) uintptr {
var sa sigactiont
sigaction(uintptr(i), nil, &sa)
return sa.sa_handler
}
// setSignalstackSP sets the ss_sp field of a stackt.
//
//go:nosplit
func setSignalstackSP(s *stackt, sp uintptr) {
*(*uintptr)(unsafe.Pointer(&s.ss_sp)) = sp
}
//go:nosplit
func (c *sigctxt) fixsigcode(sig uint32) {
switch sig {
case _SIGPIPE:
// For SIGPIPE, c.sigcode() isn't set to _SI_USER as on Linux.
// Therefore, raisebadsignal won't raise SIGPIPE again if
// it was deliver in a non-Go thread.
c.set_sigcode(_SI_USER)
}
}
//go:nosplit
//go:nowritebarrierrec
func sigaddset(mask *sigset, i int) {
(*mask)[(i-1)/64] |= 1 << ((uint32(i) - 1) & 63)
}
func sigdelset(mask *sigset, i int) {
(*mask)[(i-1)/64] &^= 1 << ((uint32(i) - 1) & 63)
}
func setProcessCPUProfiler(hz int32) {
setProcessCPUProfilerTimer(hz)
}
func setThreadCPUProfiler(hz int32) {
setThreadCPUProfilerHz(hz)
}
//go:nosplit
func validSIGPROF(mp *m, c *sigctxt) bool {
return true
}
const (
_CLOCK_REALTIME = 9
_CLOCK_MONOTONIC = 10
)
//go:nosplit
func nanotime1() int64 {
tp := &timespec{}
if clock_gettime(_CLOCK_REALTIME, tp) != 0 {
throw("syscall clock_gettime failed")
}
return tp.tv_sec*1000000000 + tp.tv_nsec
}
func walltime() (sec int64, nsec int32) {
ts := &timespec{}
if clock_gettime(_CLOCK_REALTIME, ts) != 0 {
throw("syscall clock_gettime failed")
}
return ts.tv_sec, int32(ts.tv_nsec)
}
//go:nosplit
func fcntl(fd, cmd, arg int32) (int32, int32) {
r, errno := syscall3(&libc_fcntl, uintptr(fd), uintptr(cmd), uintptr(arg))
return int32(r), int32(errno)
}
//go:nosplit
func setNonblock(fd int32) {
flags, _ := fcntl(fd, _F_GETFL, 0)
if flags != -1 {
fcntl(fd, _F_SETFL, flags|_O_NONBLOCK)
}
}
// sigPerThreadSyscall is only used on linux, so we assign a bogus signal
// number.
const sigPerThreadSyscall = 1 << 31
//go:nosplit
func runPerThreadSyscall() {
throw("runPerThreadSyscall only valid on linux")
}
//go:nosplit
func getuid() int32 {
r, errno := syscall0(&libc_getuid)
if errno != 0 {
print("getuid failed ", errno)
throw("getuid")
}
return int32(r)
}
//go:nosplit
func geteuid() int32 {
r, errno := syscall0(&libc_geteuid)
if errno != 0 {
print("geteuid failed ", errno)
throw("geteuid")
}
return int32(r)
}
//go:nosplit
func getgid() int32 {
r, errno := syscall0(&libc_getgid)
if errno != 0 {
print("getgid failed ", errno)
throw("getgid")
}
return int32(r)
}
//go:nosplit
func getegid() int32 {
r, errno := syscall0(&libc_getegid)
if errno != 0 {
print("getegid failed ", errno)
throw("getegid")
}
return int32(r)
}