os_dragonfly.go

     1  // Copyright 2014 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  	"internal/abi"
     9  	"internal/goarch"
    10  	"unsafe"
    11  )
    12  
    13  const (
    14  	_NSIG        = 33
    15  	_SI_USER     = 0
    16  	_SS_DISABLE  = 4
    17  	_SIG_BLOCK   = 1
    18  	_SIG_UNBLOCK = 2
    19  	_SIG_SETMASK = 3
    20  )
    21  
    22  type mOS struct {
    23  	waitsema uint32 // semaphore for parking on locks
    24  }
    25  
    26  //go:noescape
    27  func lwp_create(param *lwpparams) int32
    28  
    29  //go:noescape
    30  func sigaltstack(new, old *stackt)
    31  
    32  //go:noescape
    33  func sigaction(sig uint32, new, old *sigactiont)
    34  
    35  //go:noescape
    36  func sigprocmask(how int32, new, old *sigset)
    37  
    38  //go:noescape
    39  func setitimer(mode int32, new, old *itimerval)
    40  
    41  //go:noescape
    42  func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
    43  
    44  func raiseproc(sig uint32)
    45  
    46  func lwp_gettid() int32
    47  func lwp_kill(pid, tid int32, sig int)
    48  
    49  //go:noescape
    50  func sys_umtx_sleep(addr *uint32, val, timeout int32) int32
    51  
    52  //go:noescape
    53  func sys_umtx_wakeup(addr *uint32, val int32) int32
    54  
    55  func osyield()
    56  
    57  //go:nosplit
    58  func osyield_no_g() {
    59  	osyield()
    60  }
    61  
    62  func kqueue() int32
    63  
    64  //go:noescape
    65  func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32
    66  
    67  func pipe2(flags int32) (r, w int32, errno int32)
    68  func fcntl(fd, cmd, arg int32) (ret int32, errno int32)
    69  
    70  func issetugid() int32
    71  
    72  // From DragonFly's <sys/sysctl.h>
    73  const (
    74  	_CTL_HW      = 6
    75  	_HW_NCPU     = 3
    76  	_HW_PAGESIZE = 7
    77  )
    78  
    79  var sigset_all = sigset{[4]uint32{^uint32(0), ^uint32(0), ^uint32(0), ^uint32(0)}}
    80  
    81  func getncpu() int32 {
    82  	mib := [2]uint32{_CTL_HW, _HW_NCPU}
    83  	out := uint32(0)
    84  	nout := unsafe.Sizeof(out)
    85  	ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
    86  	if ret >= 0 {
    87  		return int32(out)
    88  	}
    89  	return 1
    90  }
    91  
    92  func getPageSize() uintptr {
    93  	mib := [2]uint32{_CTL_HW, _HW_PAGESIZE}
    94  	out := uint32(0)
    95  	nout := unsafe.Sizeof(out)
    96  	ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
    97  	if ret >= 0 {
    98  		return uintptr(out)
    99  	}
   100  	return 0
   101  }
   102  
   103  //go:nosplit
   104  func futexsleep(addr *uint32, val uint32, ns int64) {
   105  	systemstack(func() {
   106  		futexsleep1(addr, val, ns)
   107  	})
   108  }
   109  
   110  func futexsleep1(addr *uint32, val uint32, ns int64) {
   111  	var timeout int32
   112  	if ns >= 0 {
   113  		// The timeout is specified in microseconds - ensure that we
   114  		// do not end up dividing to zero, which would put us to sleep
   115  		// indefinitely...
   116  		timeout = timediv(ns, 1000, nil)
   117  		if timeout == 0 {
   118  			timeout = 1
   119  		}
   120  	}
   121  
   122  	// sys_umtx_sleep will return EWOULDBLOCK (EAGAIN) when the timeout
   123  	// expires or EBUSY if the mutex value does not match.
   124  	ret := sys_umtx_sleep(addr, int32(val), timeout)
   125  	if ret >= 0 || ret == -_EINTR || ret == -_EAGAIN || ret == -_EBUSY {
   126  		return
   127  	}
   128  
   129  	print("umtx_sleep addr=", addr, " val=", val, " ret=", ret, "\n")
   130  	*(*int32)(unsafe.Pointer(uintptr(0x1005))) = 0x1005
   131  }
   132  
   133  //go:nosplit
   134  func futexwakeup(addr *uint32, cnt uint32) {
   135  	ret := sys_umtx_wakeup(addr, int32(cnt))
   136  	if ret >= 0 {
   137  		return
   138  	}
   139  
   140  	systemstack(func() {
   141  		print("umtx_wake_addr=", addr, " ret=", ret, "\n")
   142  		*(*int32)(unsafe.Pointer(uintptr(0x1006))) = 0x1006
   143  	})
   144  }
   145  
   146  func lwp_start(uintptr)
   147  
   148  // May run with m.p==nil, so write barriers are not allowed.
   149  //
   150  //go:nowritebarrier
   151  func newosproc(mp *m) {
   152  	stk := unsafe.Pointer(mp.g0.stack.hi)
   153  	if false {
   154  		print("newosproc stk=", stk, " m=", mp, " g=", mp.g0, " lwp_start=", abi.FuncPCABI0(lwp_start), " id=", mp.id, " ostk=", &mp, "\n")
   155  	}
   156  
   157  	var oset sigset
   158  	sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
   159  
   160  	params := lwpparams{
   161  		start_func: abi.FuncPCABI0(lwp_start),
   162  		arg:        unsafe.Pointer(mp),
   163  		stack:      uintptr(stk),
   164  		tid1:       nil, // minit will record tid
   165  		tid2:       nil,
   166  	}
   167  
   168  	// TODO: Check for error.
   169  	retryOnEAGAIN(func() int32 {
   170  		lwp_create(&params)
   171  		return 0
   172  	})
   173  	sigprocmask(_SIG_SETMASK, &oset, nil)
   174  }
   175  
   176  func osinit() {
   177  	ncpu = getncpu()
   178  	if physPageSize == 0 {
   179  		physPageSize = getPageSize()
   180  	}
   181  }
   182  
   183  var urandom_dev = []byte("/dev/urandom\x00")
   184  
   185  //go:nosplit
   186  func readRandom(r []byte) int {
   187  	fd := open(&urandom_dev[0], 0 /* O_RDONLY */, 0)
   188  	n := read(fd, unsafe.Pointer(&r[0]), int32(len(r)))
   189  	closefd(fd)
   190  	return int(n)
   191  }
   192  
   193  func goenvs() {
   194  	goenvs_unix()
   195  }
   196  
   197  // Called to initialize a new m (including the bootstrap m).
   198  // Called on the parent thread (main thread in case of bootstrap), can allocate memory.
   199  func mpreinit(mp *m) {
   200  	mp.gsignal = malg(32 * 1024)
   201  	mp.gsignal.m = mp
   202  }
   203  
   204  // Called to initialize a new m (including the bootstrap m).
   205  // Called on the new thread, cannot allocate memory.
   206  func minit() {
   207  	getg().m.procid = uint64(lwp_gettid())
   208  	minitSignals()
   209  }
   210  
   211  // Called from dropm to undo the effect of an minit.
   212  //
   213  //go:nosplit
   214  func unminit() {
   215  	unminitSignals()
   216  	getg().m.procid = 0
   217  }
   218  
   219  // Called from mexit, but not from dropm, to undo the effect of thread-owned
   220  // resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
   221  //
   222  // This always runs without a P, so //go:nowritebarrierrec is required.
   223  //go:nowritebarrierrec
   224  func mdestroy(mp *m) {
   225  }
   226  
   227  func sigtramp()
   228  
   229  type sigactiont struct {
   230  	sa_sigaction uintptr
   231  	sa_flags     int32
   232  	sa_mask      sigset
   233  }
   234  
   235  //go:nosplit
   236  //go:nowritebarrierrec
   237  func setsig(i uint32, fn uintptr) {
   238  	var sa sigactiont
   239  	sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK | _SA_RESTART
   240  	sa.sa_mask = sigset_all
   241  	if fn == abi.FuncPCABIInternal(sighandler) { // abi.FuncPCABIInternal(sighandler) matches the callers in signal_unix.go
   242  		fn = abi.FuncPCABI0(sigtramp)
   243  	}
   244  	sa.sa_sigaction = fn
   245  	sigaction(i, &sa, nil)
   246  }
   247  
   248  //go:nosplit
   249  //go:nowritebarrierrec
   250  func setsigstack(i uint32) {
   251  	throw("setsigstack")
   252  }
   253  
   254  //go:nosplit
   255  //go:nowritebarrierrec
   256  func getsig(i uint32) uintptr {
   257  	var sa sigactiont
   258  	sigaction(i, nil, &sa)
   259  	return sa.sa_sigaction
   260  }
   261  
   262  // setSignalstackSP sets the ss_sp field of a stackt.
   263  //
   264  //go:nosplit
   265  func setSignalstackSP(s *stackt, sp uintptr) {
   266  	s.ss_sp = sp
   267  }
   268  
   269  //go:nosplit
   270  //go:nowritebarrierrec
   271  func sigaddset(mask *sigset, i int) {
   272  	mask.__bits[(i-1)/32] |= 1 << ((uint32(i) - 1) & 31)
   273  }
   274  
   275  func sigdelset(mask *sigset, i int) {
   276  	mask.__bits[(i-1)/32] &^= 1 << ((uint32(i) - 1) & 31)
   277  }
   278  
   279  //go:nosplit
   280  func (c *sigctxt) fixsigcode(sig uint32) {
   281  }
   282  
   283  func setProcessCPUProfiler(hz int32) {
   284  	setProcessCPUProfilerTimer(hz)
   285  }
   286  
   287  func setThreadCPUProfiler(hz int32) {
   288  	setThreadCPUProfilerHz(hz)
   289  }
   290  
   291  //go:nosplit
   292  func validSIGPROF(mp *m, c *sigctxt) bool {
   293  	return true
   294  }
   295  
   296  func sysargs(argc int32, argv **byte) {
   297  	n := argc + 1
   298  
   299  	// skip over argv, envp to get to auxv
   300  	for argv_index(argv, n) != nil {
   301  		n++
   302  	}
   303  
   304  	// skip NULL separator
   305  	n++
   306  
   307  	auxvp := (*[1 << 28]uintptr)(add(unsafe.Pointer(argv), uintptr(n)*goarch.PtrSize))
   308  	pairs := sysauxv(auxvp[:])
   309  	auxv = auxvp[: pairs*2 : pairs*2]
   310  }
   311  
   312  const (
   313  	_AT_NULL   = 0
   314  	_AT_PAGESZ = 6
   315  )
   316  
   317  func sysauxv(auxv []uintptr) (pairs int) {
   318  	var i int
   319  	for i = 0; auxv[i] != _AT_NULL; i += 2 {
   320  		tag, val := auxv[i], auxv[i+1]
   321  		switch tag {
   322  		case _AT_PAGESZ:
   323  			physPageSize = val
   324  		}
   325  	}
   326  	return i / 2
   327  }
   328  
   329  // raise sends a signal to the calling thread.
   330  //
   331  // It must be nosplit because it is used by the signal handler before
   332  // it definitely has a Go stack.
   333  //
   334  //go:nosplit
   335  func raise(sig uint32) {
   336  	lwp_kill(-1, lwp_gettid(), int(sig))
   337  }
   338  
   339  func signalM(mp *m, sig int) {
   340  	lwp_kill(-1, int32(mp.procid), sig)
   341  }
   342  
   343  // sigPerThreadSyscall is only used on linux, so we assign a bogus signal
   344  // number.
   345  const sigPerThreadSyscall = 1 << 31
   346  
   347  //go:nosplit
   348  func runPerThreadSyscall() {
   349  	throw("runPerThreadSyscall only valid on linux")
   350  }
   351
View as plain text