os_openbsd.go

Documentation: runtime

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package runtime
     6  
     7  import (
     8  	"runtime/internal/atomic"
     9  	"unsafe"
    10  )
    11  
    12  type mOS struct {
    13  	waitsemacount uint32
    14  }
    15  
    16  const (
    17  	_ESRCH       = 3
    18  	_EWOULDBLOCK = _EAGAIN
    19  	_ENOTSUP     = 91
    20  
    21  	// From OpenBSD's sys/time.h
    22  	_CLOCK_REALTIME  = 0
    23  	_CLOCK_VIRTUAL   = 1
    24  	_CLOCK_PROF      = 2
    25  	_CLOCK_MONOTONIC = 3
    26  )
    27  
    28  type sigset uint32
    29  
    30  var sigset_all = ^sigset(0)
    31  
    32  // From OpenBSD's <sys/sysctl.h>
    33  const (
    34  	_CTL_KERN   = 1
    35  	_KERN_OSREV = 3
    36  
    37  	_CTL_HW        = 6
    38  	_HW_NCPU       = 3
    39  	_HW_PAGESIZE   = 7
    40  	_HW_NCPUONLINE = 25
    41  )
    42  
    43  func sysctlInt(mib []uint32) (int32, bool) {
    44  	var out int32
    45  	nout := unsafe.Sizeof(out)
    46  	ret := sysctl(&mib[0], uint32(len(mib)), (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
    47  	if ret < 0 {
    48  		return 0, false
    49  	}
    50  	return out, true
    51  }
    52  
    53  func getncpu() int32 {
    54  	// Try hw.ncpuonline first because hw.ncpu would report a number twice as
    55  	// high as the actual CPUs running on OpenBSD 6.4 with hyperthreading
    56  	// disabled (hw.smt=0). See https://golang.org/issue/30127
    57  	if n, ok := sysctlInt([]uint32{_CTL_HW, _HW_NCPUONLINE}); ok {
    58  		return int32(n)
    59  	}
    60  	if n, ok := sysctlInt([]uint32{_CTL_HW, _HW_NCPU}); ok {
    61  		return int32(n)
    62  	}
    63  	return 1
    64  }
    65  
    66  func getPageSize() uintptr {
    67  	if ps, ok := sysctlInt([]uint32{_CTL_HW, _HW_PAGESIZE}); ok {
    68  		return uintptr(ps)
    69  	}
    70  	return 0
    71  }
    72  
    73  func getOSRev() int {
    74  	if osrev, ok := sysctlInt([]uint32{_CTL_KERN, _KERN_OSREV}); ok {
    75  		return int(osrev)
    76  	}
    77  	return 0
    78  }
    79  
    80  //go:nosplit
    81  func semacreate(mp *m) {
    82  }
    83  
    84  //go:nosplit
    85  func semasleep(ns int64) int32 {
    86  	_g_ := getg()
    87  
    88  	// Compute sleep deadline.
    89  	var tsp *timespec
    90  	if ns >= 0 {
    91  		var ts timespec
    92  		ts.setNsec(ns + nanotime())
    93  		tsp = &ts
    94  	}
    95  
    96  	for {
    97  		v := atomic.Load(&_g_.m.waitsemacount)
    98  		if v > 0 {
    99  			if atomic.Cas(&_g_.m.waitsemacount, v, v-1) {
   100  				return 0 // semaphore acquired
   101  			}
   102  			continue
   103  		}
   104  
   105  		// Sleep until woken by semawakeup or timeout; or abort if waitsemacount != 0.
   106  		//
   107  		// From OpenBSD's __thrsleep(2) manual:
   108  		// "The abort argument, if not NULL, points to an int that will
   109  		// be examined [...] immediately before blocking. If that int
   110  		// is non-zero then __thrsleep() will immediately return EINTR
   111  		// without blocking."
   112  		ret := thrsleep(uintptr(unsafe.Pointer(&_g_.m.waitsemacount)), _CLOCK_MONOTONIC, tsp, 0, &_g_.m.waitsemacount)
   113  		if ret == _EWOULDBLOCK {
   114  			return -1
   115  		}
   116  	}
   117  }
   118  
   119  //go:nosplit
   120  func semawakeup(mp *m) {
   121  	atomic.Xadd(&mp.waitsemacount, 1)
   122  	ret := thrwakeup(uintptr(unsafe.Pointer(&mp.waitsemacount)), 1)
   123  	if ret != 0 && ret != _ESRCH {
   124  		// semawakeup can be called on signal stack.
   125  		systemstack(func() {
   126  			print("thrwakeup addr=", &mp.waitsemacount, " sem=", mp.waitsemacount, " ret=", ret, "\n")
   127  		})
   128  	}
   129  }
   130  
   131  func osinit() {
   132  	ncpu = getncpu()
   133  	physPageSize = getPageSize()
   134  	haveMapStack = getOSRev() >= 201805 // OpenBSD 6.3
   135  }
   136  
   137  var urandom_dev = []byte("/dev/urandom\x00")
   138  
   139  //go:nosplit
   140  func getRandomData(r []byte) {
   141  	fd := open(&urandom_dev[0], 0 /* O_RDONLY */, 0)
   142  	n := read(fd, unsafe.Pointer(&r[0]), int32(len(r)))
   143  	closefd(fd)
   144  	extendRandom(r, int(n))
   145  }
   146  
   147  func goenvs() {
   148  	goenvs_unix()
   149  }
   150  
   151  // Called to initialize a new m (including the bootstrap m).
   152  // Called on the parent thread (main thread in case of bootstrap), can allocate memory.
   153  func mpreinit(mp *m) {
   154  	gsignalSize := int32(32 * 1024)
   155  	if GOARCH == "mips64" {
   156  		gsignalSize = int32(64 * 1024)
   157  	}
   158  	mp.gsignal = malg(gsignalSize)
   159  	mp.gsignal.m = mp
   160  }
   161  
   162  // Called to initialize a new m (including the bootstrap m).
   163  // Called on the new thread, can not allocate memory.
   164  func minit() {
   165  	getg().m.procid = uint64(getthrid())
   166  	minitSignals()
   167  }
   168  
   169  // Called from dropm to undo the effect of an minit.
   170  //go:nosplit
   171  func unminit() {
   172  	unminitSignals()
   173  }
   174  
   175  // Called from exitm, but not from drop, to undo the effect of thread-owned
   176  // resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
   177  func mdestroy(mp *m) {
   178  }
   179  
   180  func sigtramp()
   181  
   182  type sigactiont struct {
   183  	sa_sigaction uintptr
   184  	sa_mask      uint32
   185  	sa_flags     int32
   186  }
   187  
   188  //go:nosplit
   189  //go:nowritebarrierrec
   190  func setsig(i uint32, fn uintptr) {
   191  	var sa sigactiont
   192  	sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK | _SA_RESTART
   193  	sa.sa_mask = uint32(sigset_all)
   194  	if fn == funcPC(sighandler) {
   195  		fn = funcPC(sigtramp)
   196  	}
   197  	sa.sa_sigaction = fn
   198  	sigaction(i, &sa, nil)
   199  }
   200  
   201  //go:nosplit
   202  //go:nowritebarrierrec
   203  func setsigstack(i uint32) {
   204  	throw("setsigstack")
   205  }
   206  
   207  //go:nosplit
   208  //go:nowritebarrierrec
   209  func getsig(i uint32) uintptr {
   210  	var sa sigactiont
   211  	sigaction(i, nil, &sa)
   212  	return sa.sa_sigaction
   213  }
   214  
   215  // setSignaltstackSP sets the ss_sp field of a stackt.
   216  //go:nosplit
   217  func setSignalstackSP(s *stackt, sp uintptr) {
   218  	s.ss_sp = sp
   219  }
   220  
   221  //go:nosplit
   222  //go:nowritebarrierrec
   223  func sigaddset(mask *sigset, i int) {
   224  	*mask |= 1 << (uint32(i) - 1)
   225  }
   226  
   227  func sigdelset(mask *sigset, i int) {
   228  	*mask &^= 1 << (uint32(i) - 1)
   229  }
   230  
   231  //go:nosplit
   232  func (c *sigctxt) fixsigcode(sig uint32) {
   233  }
   234  
   235  var haveMapStack = false
   236  
   237  func osStackAlloc(s *mspan) {
   238  	// OpenBSD 6.4+ requires that stacks be mapped with MAP_STACK.
   239  	// It will check this on entry to system calls, traps, and
   240  	// when switching to the alternate system stack.
   241  	//
   242  	// This function is called before s is used for any data, so
   243  	// it's safe to simply re-map it.
   244  	osStackRemap(s, _MAP_STACK)
   245  }
   246  
   247  func osStackFree(s *mspan) {
   248  	// Undo MAP_STACK.
   249  	osStackRemap(s, 0)
   250  }
   251  
   252  func osStackRemap(s *mspan, flags int32) {
   253  	if !haveMapStack {
   254  		// OpenBSD prior to 6.3 did not have MAP_STACK and so
   255  		// the following mmap will fail. But it also didn't
   256  		// require MAP_STACK (obviously), so there's no need
   257  		// to do the mmap.
   258  		return
   259  	}
   260  	a, err := mmap(unsafe.Pointer(s.base()), s.npages*pageSize, _PROT_READ|_PROT_WRITE, _MAP_PRIVATE|_MAP_ANON|_MAP_FIXED|flags, -1, 0)
   261  	if err != 0 || uintptr(a) != s.base() {
   262  		print("runtime: remapping stack memory ", hex(s.base()), " ", s.npages*pageSize, " a=", a, " err=", err, "\n")
   263  		throw("remapping stack memory failed")
   264  	}
   265  }
   266  
   267  //go:nosplit
   268  func raise(sig uint32) {
   269  	thrkill(getthrid(), int(sig))
   270  }
   271  
   272  func signalM(mp *m, sig int) {
   273  	thrkill(int32(mp.procid), sig)
   274  }
   275
View as plain text