// Copyright 2011 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 dragonfly || freebsd || linux package runtime import ( "internal/runtime/atomic" "unsafe" ) // We use the uintptr mutex.key and note.key as a uint32. // //go:nosplit func key32(p *uintptr) *uint32 { return (*uint32)(unsafe.Pointer(p)) } // One-time notifications. func noteclear(n *note) { n.key = 0 } func notewakeup(n *note) { old := atomic.Xchg(key32(&n.key), 1) if old != 0 { print("notewakeup - double wakeup (", old, ")\n") throw("notewakeup - double wakeup") } futexwakeup(key32(&n.key), 1) } func notesleep(n *note) { gp := getg() if gp != gp.m.g0 { throw("notesleep not on g0") } ns := int64(-1) if *cgo_yield != nil { // Sleep for an arbitrary-but-moderate interval to poll libc interceptors. ns = 10e6 } for atomic.Load(key32(&n.key)) == 0 { gp.m.blocked = true futexsleep(key32(&n.key), 0, ns) if *cgo_yield != nil { asmcgocall(*cgo_yield, nil) } gp.m.blocked = false } } // May run with m.p==nil if called from notetsleep, so write barriers // are not allowed. // //go:nosplit //go:nowritebarrier func notetsleep_internal(n *note, ns int64) bool { gp := getg() if ns < 0 { if *cgo_yield != nil { // Sleep for an arbitrary-but-moderate interval to poll libc interceptors. ns = 10e6 } for atomic.Load(key32(&n.key)) == 0 { gp.m.blocked = true futexsleep(key32(&n.key), 0, ns) if *cgo_yield != nil { asmcgocall(*cgo_yield, nil) } gp.m.blocked = false } return true } if atomic.Load(key32(&n.key)) != 0 { return true } deadline := nanotime() + ns for { if *cgo_yield != nil && ns > 10e6 { ns = 10e6 } gp.m.blocked = true futexsleep(key32(&n.key), 0, ns) if *cgo_yield != nil { asmcgocall(*cgo_yield, nil) } gp.m.blocked = false if atomic.Load(key32(&n.key)) != 0 { break } now := nanotime() if now >= deadline { break } ns = deadline - now } return atomic.Load(key32(&n.key)) != 0 } func notetsleep(n *note, ns int64) bool { gp := getg() if gp != gp.m.g0 && gp.m.preemptoff != "" { throw("notetsleep not on g0") } return notetsleep_internal(n, ns) } // same as runtimeĀ·notetsleep, but called on user g (not g0) // calls only nosplit functions between entersyscallblock/exitsyscall. func notetsleepg(n *note, ns int64) bool { gp := getg() if gp == gp.m.g0 { throw("notetsleepg on g0") } entersyscallblock() ok := notetsleep_internal(n, ns) exitsyscall() return ok } func beforeIdle(int64, int64) (*g, bool) { return nil, false } func checkTimeouts() {} //go:nosplit func semacreate(mp *m) {} //go:nosplit func semasleep(ns int64) int32 { mp := getg().m for v := atomic.Xadd(&mp.waitsema, -1); ; v = atomic.Load(&mp.waitsema) { if int32(v) >= 0 { return 0 } futexsleep(&mp.waitsema, v, ns) if ns >= 0 { if int32(v) >= 0 { return 0 } else { return -1 } } } } //go:nosplit func semawakeup(mp *m) { v := atomic.Xadd(&mp.waitsema, 1) if v == 0 { futexwakeup(&mp.waitsema, 1) } }