| // 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. |
| |
| package runtime |
| |
| import ( |
| "runtime/internal/atomic" |
| "unsafe" |
| ) |
| |
| type mOS struct { |
| waitsemacount uint32 |
| } |
| |
| //go:noescape |
| //extern thrsleep |
| func thrsleep(ident uintptr, clock_id int32, tsp *timespec, lock uintptr, abort *uint32) int32 |
| |
| //go:noescape |
| //extern thrwakeup |
| func thrwakeup(ident uintptr, n int32) int32 |
| |
| //go:noescape |
| //extern sysctl |
| func sysctl(*uint32, uint32, *byte, *uintptr, *byte, uintptr) int32 |
| |
| // From OpenBSD's <sys/sysctl.h> |
| const ( |
| _CTL_KERN = 1 |
| _KERN_OSREV = 3 |
| |
| _CTL_HW = 6 |
| _HW_NCPU = 3 |
| _HW_PAGESIZE = 7 |
| _HW_NCPUONLINE = 25 |
| ) |
| |
| func sysctlInt(mib []uint32) (int32, bool) { |
| var out int32 |
| nout := unsafe.Sizeof(out) |
| ret := sysctl(&mib[0], uint32(len(mib)), (*byte)(unsafe.Pointer(&out)), &nout, nil, 0) |
| if ret < 0 { |
| return 0, false |
| } |
| return out, true |
| } |
| |
| func getncpu() int32 { |
| // Try hw.ncpuonline first because hw.ncpu would report a number twice as |
| // high as the actual CPUs running on OpenBSD 6.4 with hyperthreading |
| // disabled (hw.smt=0). See https://golang.org/issue/30127 |
| if n, ok := sysctlInt([]uint32{_CTL_HW, _HW_NCPUONLINE}); ok { |
| return int32(n) |
| } |
| if n, ok := sysctlInt([]uint32{_CTL_HW, _HW_NCPU}); ok { |
| return int32(n) |
| } |
| return 1 |
| } |
| |
| func getPageSize() uintptr { |
| if ps, ok := sysctlInt([]uint32{_CTL_HW, _HW_PAGESIZE}); ok { |
| return uintptr(ps) |
| } |
| return 0 |
| } |
| |
| func getOSRev() int { |
| if osrev, ok := sysctlInt([]uint32{_CTL_KERN, _KERN_OSREV}); ok { |
| return int(osrev) |
| } |
| return 0 |
| } |
| |
| //go:nosplit |
| func semacreate(mp *m) { |
| } |
| |
| //go:nosplit |
| func semasleep(ns int64) int32 { |
| _g_ := getg() |
| |
| // Compute sleep deadline. |
| var tsp *timespec |
| if ns >= 0 { |
| var ts timespec |
| ts.setNsec(ns + nanotime()) |
| tsp = &ts |
| } |
| |
| for { |
| v := atomic.Load(&_g_.m.mos.waitsemacount) |
| if v > 0 { |
| if atomic.Cas(&_g_.m.mos.waitsemacount, v, v-1) { |
| return 0 // semaphore acquired |
| } |
| continue |
| } |
| |
| // Sleep until woken by semawakeup or timeout; or abort if waitsemacount != 0. |
| // |
| // From OpenBSD's __thrsleep(2) manual: |
| // "The abort argument, if not NULL, points to an int that will |
| // be examined [...] immediately before blocking. If that int |
| // is non-zero then __thrsleep() will immediately return EINTR |
| // without blocking." |
| ret := thrsleep(uintptr(unsafe.Pointer(&_g_.m.mos.waitsemacount)), _CLOCK_MONOTONIC, tsp, 0, &_g_.m.mos.waitsemacount) |
| if ret == _EWOULDBLOCK { |
| return -1 |
| } |
| } |
| } |
| |
| //go:nosplit |
| func semawakeup(mp *m) { |
| atomic.Xadd(&mp.mos.waitsemacount, 1) |
| ret := thrwakeup(uintptr(unsafe.Pointer(&mp.mos.waitsemacount)), 1) |
| if ret != 0 && ret != _ESRCH { |
| // semawakeup can be called on signal stack. |
| systemstack(func() { |
| print("thrwakeup addr=", &mp.mos.waitsemacount, " sem=", mp.mos.waitsemacount, " ret=", ret, "\n") |
| }) |
| } |
| } |
| |
| func osinit() { |
| ncpu = getncpu() |
| physPageSize = getPageSize() |
| haveMapStack = getOSRev() >= 201805 // OpenBSD 6.3 |
| } |
| |
| var haveMapStack = false |