github.com/mh-cbon/go@v0.0.0-20160603070303-9e112a3fe4c0/src/runtime/os_freebsd.go (about) 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/sys" 9 "unsafe" 10 ) 11 12 type mOS struct{} 13 14 //go:noescape 15 func thr_new(param *thrparam, size int32) 16 17 //go:noescape 18 func sigaltstack(new, old *stackt) 19 20 //go:noescape 21 func sigaction(sig int32, new, old *sigactiont) 22 23 //go:noescape 24 func sigprocmask(how int32, new, old *sigset) 25 26 //go:noescape 27 func setitimer(mode int32, new, old *itimerval) 28 29 //go:noescape 30 func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32 31 32 //go:noescape 33 func getrlimit(kind int32, limit unsafe.Pointer) int32 34 func raise(sig int32) 35 func raiseproc(sig int32) 36 37 //go:noescape 38 func sys_umtx_op(addr *uint32, mode int32, val uint32, ptr2, ts *timespec) int32 39 40 func osyield() 41 42 // From FreeBSD's <sys/sysctl.h> 43 const ( 44 _CTL_HW = 6 45 _HW_NCPU = 3 46 ) 47 48 var sigset_all = sigset{[4]uint32{^uint32(0), ^uint32(0), ^uint32(0), ^uint32(0)}} 49 50 func getncpu() int32 { 51 mib := [2]uint32{_CTL_HW, _HW_NCPU} 52 out := uint32(0) 53 nout := unsafe.Sizeof(out) 54 ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0) 55 if ret >= 0 { 56 return int32(out) 57 } 58 return 1 59 } 60 61 // FreeBSD's umtx_op syscall is effectively the same as Linux's futex, and 62 // thus the code is largely similar. See Linux implementation 63 // and lock_futex.go for comments. 64 65 //go:nosplit 66 func futexsleep(addr *uint32, val uint32, ns int64) { 67 systemstack(func() { 68 futexsleep1(addr, val, ns) 69 }) 70 } 71 72 func futexsleep1(addr *uint32, val uint32, ns int64) { 73 var tsp *timespec 74 if ns >= 0 { 75 var ts timespec 76 ts.tv_nsec = 0 77 ts.set_sec(int64(timediv(ns, 1000000000, (*int32)(unsafe.Pointer(&ts.tv_nsec))))) 78 tsp = &ts 79 } 80 ret := sys_umtx_op(addr, _UMTX_OP_WAIT_UINT_PRIVATE, val, nil, tsp) 81 if ret >= 0 || ret == -_EINTR { 82 return 83 } 84 print("umtx_wait addr=", addr, " val=", val, " ret=", ret, "\n") 85 *(*int32)(unsafe.Pointer(uintptr(0x1005))) = 0x1005 86 } 87 88 //go:nosplit 89 func futexwakeup(addr *uint32, cnt uint32) { 90 ret := sys_umtx_op(addr, _UMTX_OP_WAKE_PRIVATE, cnt, nil, nil) 91 if ret >= 0 { 92 return 93 } 94 95 systemstack(func() { 96 print("umtx_wake_addr=", addr, " ret=", ret, "\n") 97 }) 98 } 99 100 func thr_start() 101 102 // May run with m.p==nil, so write barriers are not allowed. 103 //go:nowritebarrier 104 func newosproc(mp *m, stk unsafe.Pointer) { 105 if false { 106 print("newosproc stk=", stk, " m=", mp, " g=", mp.g0, " thr_start=", funcPC(thr_start), " id=", mp.id, " ostk=", &mp, "\n") 107 } 108 109 // NOTE(rsc): This code is confused. stackbase is the top of the stack 110 // and is equal to stk. However, it's working, so I'm not changing it. 111 param := thrparam{ 112 start_func: funcPC(thr_start), 113 arg: unsafe.Pointer(mp), 114 stack_base: mp.g0.stack.hi, 115 stack_size: uintptr(stk) - mp.g0.stack.hi, 116 child_tid: unsafe.Pointer(&mp.procid), 117 parent_tid: nil, 118 tls_base: unsafe.Pointer(&mp.tls[0]), 119 tls_size: unsafe.Sizeof(mp.tls), 120 } 121 122 var oset sigset 123 sigprocmask(_SIG_SETMASK, &sigset_all, &oset) 124 thr_new(¶m, int32(unsafe.Sizeof(param))) 125 sigprocmask(_SIG_SETMASK, &oset, nil) 126 } 127 128 func osinit() { 129 ncpu = getncpu() 130 } 131 132 var urandom_dev = []byte("/dev/urandom\x00") 133 134 //go:nosplit 135 func getRandomData(r []byte) { 136 fd := open(&urandom_dev[0], 0 /* O_RDONLY */, 0) 137 n := read(fd, unsafe.Pointer(&r[0]), int32(len(r))) 138 closefd(fd) 139 extendRandom(r, int(n)) 140 } 141 142 func goenvs() { 143 goenvs_unix() 144 } 145 146 // Called to initialize a new m (including the bootstrap m). 147 // Called on the parent thread (main thread in case of bootstrap), can allocate memory. 148 func mpreinit(mp *m) { 149 mp.gsignal = malg(32 * 1024) 150 mp.gsignal.m = mp 151 } 152 153 //go:nosplit 154 func msigsave(mp *m) { 155 sigprocmask(_SIG_SETMASK, nil, &mp.sigmask) 156 } 157 158 //go:nosplit 159 func msigrestore(sigmask sigset) { 160 sigprocmask(_SIG_SETMASK, &sigmask, nil) 161 } 162 163 //go:nosplit 164 func sigblock() { 165 sigprocmask(_SIG_SETMASK, &sigset_all, nil) 166 } 167 168 // Called to initialize a new m (including the bootstrap m). 169 // Called on the new thread, cannot allocate memory. 170 func minit() { 171 _g_ := getg() 172 173 // m.procid is a uint64, but thr_new writes a uint32 on 32-bit systems. 174 // Fix it up. (Only matters on big-endian, but be clean anyway.) 175 if sys.PtrSize == 4 { 176 _g_.m.procid = uint64(*(*uint32)(unsafe.Pointer(&_g_.m.procid))) 177 } 178 179 // Initialize signal handling. 180 var st stackt 181 sigaltstack(nil, &st) 182 if st.ss_flags&_SS_DISABLE != 0 { 183 signalstack(&_g_.m.gsignal.stack) 184 _g_.m.newSigstack = true 185 } else { 186 // Use existing signal stack. 187 stsp := uintptr(unsafe.Pointer(st.ss_sp)) 188 _g_.m.gsignal.stack.lo = stsp 189 _g_.m.gsignal.stack.hi = stsp + st.ss_size 190 _g_.m.gsignal.stackguard0 = stsp + _StackGuard 191 _g_.m.gsignal.stackguard1 = stsp + _StackGuard 192 _g_.m.gsignal.stackAlloc = st.ss_size 193 _g_.m.newSigstack = false 194 } 195 196 // restore signal mask from m.sigmask and unblock essential signals 197 nmask := _g_.m.sigmask 198 for i := range sigtable { 199 if sigtable[i].flags&_SigUnblock != 0 { 200 nmask.__bits[(i-1)/32] &^= 1 << ((uint32(i) - 1) & 31) 201 } 202 } 203 sigprocmask(_SIG_SETMASK, &nmask, nil) 204 } 205 206 // Called from dropm to undo the effect of an minit. 207 //go:nosplit 208 func unminit() { 209 if getg().m.newSigstack { 210 signalstack(nil) 211 } 212 } 213 214 func memlimit() uintptr { 215 /* 216 TODO: Convert to Go when something actually uses the result. 217 Rlimit rl; 218 extern byte runtime·text[], runtime·end[]; 219 uintptr used; 220 221 if(runtime·getrlimit(RLIMIT_AS, &rl) != 0) 222 return 0; 223 if(rl.rlim_cur >= 0x7fffffff) 224 return 0; 225 226 // Estimate our VM footprint excluding the heap. 227 // Not an exact science: use size of binary plus 228 // some room for thread stacks. 229 used = runtime·end - runtime·text + (64<<20); 230 if(used >= rl.rlim_cur) 231 return 0; 232 233 // If there's not at least 16 MB left, we're probably 234 // not going to be able to do much. Treat as no limit. 235 rl.rlim_cur -= used; 236 if(rl.rlim_cur < (16<<20)) 237 return 0; 238 239 return rl.rlim_cur - used; 240 */ 241 242 return 0 243 } 244 245 func sigtramp() 246 247 type sigactiont struct { 248 sa_handler uintptr 249 sa_flags int32 250 sa_mask sigset 251 } 252 253 //go:nosplit 254 //go:nowritebarrierrec 255 func setsig(i int32, fn uintptr, restart bool) { 256 var sa sigactiont 257 sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK 258 if restart { 259 sa.sa_flags |= _SA_RESTART 260 } 261 sa.sa_mask = sigset_all 262 if fn == funcPC(sighandler) { 263 fn = funcPC(sigtramp) 264 } 265 sa.sa_handler = fn 266 sigaction(i, &sa, nil) 267 } 268 269 //go:nosplit 270 //go:nowritebarrierrec 271 func setsigstack(i int32) { 272 throw("setsigstack") 273 } 274 275 //go:nosplit 276 //go:nowritebarrierrec 277 func getsig(i int32) uintptr { 278 var sa sigactiont 279 sigaction(i, nil, &sa) 280 if sa.sa_handler == funcPC(sigtramp) { 281 return funcPC(sighandler) 282 } 283 return sa.sa_handler 284 } 285 286 //go:nosplit 287 func signalstack(s *stack) { 288 var st stackt 289 if s == nil { 290 st.ss_flags = _SS_DISABLE 291 } else { 292 st.ss_sp = s.lo 293 st.ss_size = s.hi - s.lo 294 st.ss_flags = 0 295 } 296 sigaltstack(&st, nil) 297 } 298 299 //go:nosplit 300 //go:nowritebarrierrec 301 func updatesigmask(m [(_NSIG + 31) / 32]uint32) { 302 var mask sigset 303 copy(mask.__bits[:], m[:]) 304 sigprocmask(_SIG_SETMASK, &mask, nil) 305 } 306 307 func unblocksig(sig int32) { 308 var mask sigset 309 mask.__bits[(sig-1)/32] |= 1 << ((uint32(sig) - 1) & 31) 310 sigprocmask(_SIG_UNBLOCK, &mask, nil) 311 }