| // 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) | |
| } | |
| } |