c0401cf78c
Remove the old locking code written in C.
Add a shell script mkrsysinfo.sh to generate the runtime_sysinfo.go
file, so that we can get Go copies of the system time structures and
other types.
Tweak the compiler so that when compiling the runtime package the
address operator does not cause local variables to escape. When the gc
compiler compiles the runtime, an escaping local variable is treated as
an error. We should implement that, instead of this change, when escape
analysis is turned on.
Tweak the compiler so that the generated C header does not include names
that start with an underscore followed by a non-upper-case letter,
except for the special cases of _defer and _panic. Otherwise we
translate C types to Go in runtime_sysinfo.go and then generate those Go
types back as C types in runtime.inc, which is useless and painful for
the C code.
Change entersyscall and friends to take a dummy argument, as the gc
versions do, to simplify calls from the shared code.
Reviewed-on: https://go-review.googlesource.com/30079
From-SVN: r240657
63 lines
1.5 KiB
Go
63 lines
1.5 KiB
Go
// Copyright 2014 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.
|
|
|
|
package runtime
|
|
|
|
import "unsafe"
|
|
|
|
type mOS struct {
|
|
unused byte
|
|
}
|
|
|
|
//go:noescape
|
|
//extern umtx_sleep
|
|
func sys_umtx_sleep(addr *uint32, val, timeout int32) int32
|
|
|
|
//go:noescape
|
|
//extern umtx_wakeup
|
|
func sys_umtx_wakeup(addr *uint32, val int32) int32
|
|
|
|
//go:nosplit
|
|
func futexsleep(addr *uint32, val uint32, ns int64) {
|
|
systemstack(func() {
|
|
futexsleep1(addr, val, ns)
|
|
})
|
|
}
|
|
|
|
func futexsleep1(addr *uint32, val uint32, ns int64) {
|
|
var timeout int32
|
|
if ns >= 0 {
|
|
// The timeout is specified in microseconds - ensure that we
|
|
// do not end up dividing to zero, which would put us to sleep
|
|
// indefinitely...
|
|
timeout = timediv(ns, 1000, nil)
|
|
if timeout == 0 {
|
|
timeout = 1
|
|
}
|
|
}
|
|
|
|
// sys_umtx_sleep will return EWOULDBLOCK (EAGAIN) when the timeout
|
|
// expires or EBUSY if the mutex value does not match.
|
|
ret := sys_umtx_sleep(addr, int32(val), timeout)
|
|
if ret >= 0 || ret == -_EINTR || ret == -_EAGAIN || ret == -_EBUSY {
|
|
return
|
|
}
|
|
|
|
print("umtx_sleep addr=", addr, " val=", val, " ret=", ret, "\n")
|
|
*(*int32)(unsafe.Pointer(uintptr(0x1005))) = 0x1005
|
|
}
|
|
|
|
//go:nosplit
|
|
func futexwakeup(addr *uint32, cnt uint32) {
|
|
ret := sys_umtx_wakeup(addr, int32(cnt))
|
|
if ret >= 0 {
|
|
return
|
|
}
|
|
|
|
systemstack(func() {
|
|
print("umtx_wake_addr=", addr, " ret=", ret, "\n")
|
|
*(*int32)(unsafe.Pointer(uintptr(0x1006))) = 0x1006
|
|
})
|
|
}
|