mirror of
https://github.com/autc04/Retro68.git
synced 2024-12-03 10:49:58 +00:00
330 lines
7.1 KiB
Go
330 lines
7.1 KiB
Go
// Copyright 2009 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 {
|
|
machport uint32 // return address for mach ipc
|
|
waitsema uint32 // semaphore for parking on locks
|
|
}
|
|
|
|
//go:noescape
|
|
//extern mach_msg_trap
|
|
func mach_msg_trap(h unsafe.Pointer, op int32, send_size, rcv_size, rcv_name, timeout, notify uint32) int32
|
|
|
|
//extern mach_reply_port
|
|
func mach_reply_port() uint32
|
|
|
|
//extern mach_task_self
|
|
func mach_task_self() uint32
|
|
|
|
func unimplemented(name string) {
|
|
println(name, "not implemented")
|
|
*(*int)(unsafe.Pointer(uintptr(1231))) = 1231
|
|
}
|
|
|
|
//go:nosplit
|
|
func semawakeup(mp *m) {
|
|
mach_semrelease(mp.mos.waitsema)
|
|
}
|
|
|
|
//go:nosplit
|
|
func semacreate(mp *m) {
|
|
if mp.mos.waitsema != 0 {
|
|
return
|
|
}
|
|
systemstack(func() {
|
|
mp.mos.waitsema = mach_semcreate()
|
|
})
|
|
}
|
|
|
|
// Mach IPC, to get at semaphores
|
|
// Definitions are in /usr/include/mach on a Mac.
|
|
|
|
func macherror(r int32, fn string) {
|
|
print("mach error ", fn, ": ", r, "\n")
|
|
throw("mach error")
|
|
}
|
|
|
|
const _DebugMach = false
|
|
|
|
var zerondr machndr
|
|
|
|
func mach_msgh_bits(a, b uint32) uint32 {
|
|
return a | b<<8
|
|
}
|
|
|
|
func mach_msg(h *machheader, op int32, send_size, rcv_size, rcv_name, timeout, notify uint32) int32 {
|
|
// TODO: Loop on interrupt.
|
|
return mach_msg_trap(unsafe.Pointer(h), op, send_size, rcv_size, rcv_name, timeout, notify)
|
|
}
|
|
|
|
// Mach RPC (MIG)
|
|
const (
|
|
_MinMachMsg = 48
|
|
_MachReply = 100
|
|
)
|
|
|
|
type codemsg struct {
|
|
h machheader
|
|
ndr machndr
|
|
code int32
|
|
}
|
|
|
|
func machcall(h *machheader, maxsize int32, rxsize int32) int32 {
|
|
_g_ := getg()
|
|
port := _g_.m.mos.machport
|
|
if port == 0 {
|
|
port = mach_reply_port()
|
|
_g_.m.mos.machport = port
|
|
}
|
|
|
|
h.msgh_bits |= mach_msgh_bits(_MACH_MSG_TYPE_COPY_SEND, _MACH_MSG_TYPE_MAKE_SEND_ONCE)
|
|
h.msgh_local_port = port
|
|
h.msgh_reserved = 0
|
|
id := h.msgh_id
|
|
|
|
if _DebugMach {
|
|
p := (*[10000]unsafe.Pointer)(unsafe.Pointer(h))
|
|
print("send:\t")
|
|
var i uint32
|
|
for i = 0; i < h.msgh_size/uint32(unsafe.Sizeof(p[0])); i++ {
|
|
print(" ", p[i])
|
|
if i%8 == 7 {
|
|
print("\n\t")
|
|
}
|
|
}
|
|
if i%8 != 0 {
|
|
print("\n")
|
|
}
|
|
}
|
|
ret := mach_msg(h, _MACH_SEND_MSG|_MACH_RCV_MSG, h.msgh_size, uint32(maxsize), port, 0, 0)
|
|
if ret != 0 {
|
|
if _DebugMach {
|
|
print("mach_msg error ", ret, "\n")
|
|
}
|
|
return ret
|
|
}
|
|
if _DebugMach {
|
|
p := (*[10000]unsafe.Pointer)(unsafe.Pointer(h))
|
|
var i uint32
|
|
for i = 0; i < h.msgh_size/uint32(unsafe.Sizeof(p[0])); i++ {
|
|
print(" ", p[i])
|
|
if i%8 == 7 {
|
|
print("\n\t")
|
|
}
|
|
}
|
|
if i%8 != 0 {
|
|
print("\n")
|
|
}
|
|
}
|
|
if h.msgh_id != id+_MachReply {
|
|
if _DebugMach {
|
|
print("mach_msg _MachReply id mismatch ", h.msgh_id, " != ", id+_MachReply, "\n")
|
|
}
|
|
return -303 // MIG_REPLY_MISMATCH
|
|
}
|
|
// Look for a response giving the return value.
|
|
// Any call can send this back with an error,
|
|
// and some calls only have return values so they
|
|
// send it back on success too. I don't quite see how
|
|
// you know it's one of these and not the full response
|
|
// format, so just look if the message is right.
|
|
c := (*codemsg)(unsafe.Pointer(h))
|
|
if uintptr(h.msgh_size) == unsafe.Sizeof(*c) && h.msgh_bits&_MACH_MSGH_BITS_COMPLEX == 0 {
|
|
if _DebugMach {
|
|
print("mig result ", c.code, "\n")
|
|
}
|
|
return c.code
|
|
}
|
|
if h.msgh_size != uint32(rxsize) {
|
|
if _DebugMach {
|
|
print("mach_msg _MachReply size mismatch ", h.msgh_size, " != ", rxsize, "\n")
|
|
}
|
|
return -307 // MIG_ARRAY_TOO_LARGE
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// Semaphores!
|
|
|
|
const (
|
|
tmach_semcreate = 3418
|
|
rmach_semcreate = tmach_semcreate + _MachReply
|
|
|
|
tmach_semdestroy = 3419
|
|
rmach_semdestroy = tmach_semdestroy + _MachReply
|
|
|
|
_KERN_ABORTED = 14
|
|
_KERN_OPERATION_TIMED_OUT = 49
|
|
)
|
|
|
|
type tmach_semcreatemsg struct {
|
|
h machheader
|
|
ndr machndr
|
|
policy int32
|
|
value int32
|
|
}
|
|
|
|
type rmach_semcreatemsg struct {
|
|
h machheader
|
|
body machbody
|
|
semaphore machport
|
|
}
|
|
|
|
type tmach_semdestroymsg struct {
|
|
h machheader
|
|
body machbody
|
|
semaphore machport
|
|
}
|
|
|
|
func mach_semcreate() uint32 {
|
|
var m [256]uint8
|
|
tx := (*tmach_semcreatemsg)(unsafe.Pointer(&m))
|
|
rx := (*rmach_semcreatemsg)(unsafe.Pointer(&m))
|
|
|
|
tx.h.msgh_bits = 0
|
|
tx.h.msgh_size = uint32(unsafe.Sizeof(*tx))
|
|
tx.h.msgh_remote_port = mach_task_self()
|
|
tx.h.msgh_id = tmach_semcreate
|
|
tx.ndr = zerondr
|
|
|
|
tx.policy = 0 // 0 = SYNC_POLICY_FIFO
|
|
tx.value = 0
|
|
|
|
for {
|
|
r := machcall(&tx.h, int32(unsafe.Sizeof(m)), int32(unsafe.Sizeof(*rx)))
|
|
if r == 0 {
|
|
break
|
|
}
|
|
if r == _KERN_ABORTED { // interrupted
|
|
continue
|
|
}
|
|
macherror(r, "semaphore_create")
|
|
}
|
|
if rx.body.msgh_descriptor_count != 1 {
|
|
unimplemented("mach_semcreate desc count")
|
|
}
|
|
return rx.semaphore.name
|
|
}
|
|
|
|
func mach_semdestroy(sem uint32) {
|
|
var m [256]uint8
|
|
tx := (*tmach_semdestroymsg)(unsafe.Pointer(&m))
|
|
|
|
tx.h.msgh_bits = _MACH_MSGH_BITS_COMPLEX
|
|
tx.h.msgh_size = uint32(unsafe.Sizeof(*tx))
|
|
tx.h.msgh_remote_port = mach_task_self()
|
|
tx.h.msgh_id = tmach_semdestroy
|
|
tx.body.msgh_descriptor_count = 1
|
|
tx.semaphore.name = sem
|
|
tx.semaphore.disposition = _MACH_MSG_TYPE_MOVE_SEND
|
|
tx.semaphore._type = 0
|
|
|
|
for {
|
|
r := machcall(&tx.h, int32(unsafe.Sizeof(m)), 0)
|
|
if r == 0 {
|
|
break
|
|
}
|
|
if r == _KERN_ABORTED { // interrupted
|
|
continue
|
|
}
|
|
macherror(r, "semaphore_destroy")
|
|
}
|
|
}
|
|
|
|
//extern semaphore_wait
|
|
func mach_semaphore_wait(sema uint32) int32
|
|
|
|
//extern semaphore_timedwait
|
|
func mach_semaphore_timedwait(sema, sec, nsec uint32) int32
|
|
|
|
//extern semaphore_signal
|
|
func mach_semaphore_signal(sema uint32) int32
|
|
|
|
//extern semaphore_signal_all
|
|
func mach_semaphore_signal_all(sema uint32) int32
|
|
|
|
func semasleep1(ns int64) int32 {
|
|
_g_ := getg()
|
|
|
|
if ns >= 0 {
|
|
var nsecs int32
|
|
secs := timediv(ns, 1000000000, &nsecs)
|
|
r := mach_semaphore_timedwait(_g_.m.mos.waitsema, uint32(secs), uint32(nsecs))
|
|
if r == _KERN_ABORTED || r == _KERN_OPERATION_TIMED_OUT {
|
|
return -1
|
|
}
|
|
if r != 0 {
|
|
macherror(r, "semaphore_wait")
|
|
}
|
|
return 0
|
|
}
|
|
|
|
for {
|
|
r := mach_semaphore_wait(_g_.m.mos.waitsema)
|
|
if r == 0 {
|
|
break
|
|
}
|
|
// Note: We don't know how this call (with no timeout) can get _KERN_OPERATION_TIMED_OUT,
|
|
// but it does reliably, though at a very low rate, on OS X 10.8, 10.9, 10.10, and 10.11.
|
|
// See golang.org/issue/17161.
|
|
if r == _KERN_ABORTED || r == _KERN_OPERATION_TIMED_OUT { // interrupted
|
|
continue
|
|
}
|
|
macherror(r, "semaphore_wait")
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//go:nosplit
|
|
func semasleep(ns int64) int32 {
|
|
var r int32
|
|
systemstack(func() {
|
|
r = semasleep1(ns)
|
|
})
|
|
return r
|
|
}
|
|
|
|
//go:nosplit
|
|
func mach_semrelease(sem uint32) {
|
|
for {
|
|
r := mach_semaphore_signal(sem)
|
|
if r == 0 {
|
|
break
|
|
}
|
|
if r == _KERN_ABORTED { // interrupted
|
|
continue
|
|
}
|
|
|
|
// mach_semrelease must be completely nosplit,
|
|
// because it is called from Go code.
|
|
// If we're going to die, start that process on the system stack
|
|
// to avoid a Go stack split.
|
|
systemstack(func() { macherror(r, "semaphore_signal") })
|
|
}
|
|
}
|
|
|
|
type machheader struct {
|
|
msgh_bits uint32
|
|
msgh_size uint32
|
|
msgh_remote_port uint32
|
|
msgh_local_port uint32
|
|
msgh_reserved uint32
|
|
msgh_id int32
|
|
}
|
|
|
|
type machndr struct {
|
|
mig_vers uint8
|
|
if_vers uint8
|
|
reserved1 uint8
|
|
mig_encoding uint8
|
|
int_rep uint8
|
|
char_rep uint8
|
|
float_rep uint8
|
|
reserved2 uint8
|
|
}
|