github.com/robhaswell/grandperspective-scan@v0.1.0/test/go-go1.7.1/src/runtime/os3_solaris.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 "unsafe" 8 9 //go:cgo_export_dynamic runtime.end _end 10 //go:cgo_export_dynamic runtime.etext _etext 11 //go:cgo_export_dynamic runtime.edata _edata 12 13 //go:cgo_import_dynamic libc____errno ___errno "libc.so" 14 //go:cgo_import_dynamic libc_clock_gettime clock_gettime "libc.so" 15 //go:cgo_import_dynamic libc_close close "libc.so" 16 //go:cgo_import_dynamic libc_exit exit "libc.so" 17 //go:cgo_import_dynamic libc_fstat fstat "libc.so" 18 //go:cgo_import_dynamic libc_getcontext getcontext "libc.so" 19 //go:cgo_import_dynamic libc_getrlimit getrlimit "libc.so" 20 //go:cgo_import_dynamic libc_kill kill "libc.so" 21 //go:cgo_import_dynamic libc_madvise madvise "libc.so" 22 //go:cgo_import_dynamic libc_malloc malloc "libc.so" 23 //go:cgo_import_dynamic libc_mmap mmap "libc.so" 24 //go:cgo_import_dynamic libc_munmap munmap "libc.so" 25 //go:cgo_import_dynamic libc_open open "libc.so" 26 //go:cgo_import_dynamic libc_pthread_attr_destroy pthread_attr_destroy "libc.so" 27 //go:cgo_import_dynamic libc_pthread_attr_getstack pthread_attr_getstack "libc.so" 28 //go:cgo_import_dynamic libc_pthread_attr_init pthread_attr_init "libc.so" 29 //go:cgo_import_dynamic libc_pthread_attr_setdetachstate pthread_attr_setdetachstate "libc.so" 30 //go:cgo_import_dynamic libc_pthread_attr_setstack pthread_attr_setstack "libc.so" 31 //go:cgo_import_dynamic libc_pthread_create pthread_create "libc.so" 32 //go:cgo_import_dynamic libc_raise raise "libc.so" 33 //go:cgo_import_dynamic libc_read read "libc.so" 34 //go:cgo_import_dynamic libc_select select "libc.so" 35 //go:cgo_import_dynamic libc_sched_yield sched_yield "libc.so" 36 //go:cgo_import_dynamic libc_sem_init sem_init "libc.so" 37 //go:cgo_import_dynamic libc_sem_post sem_post "libc.so" 38 //go:cgo_import_dynamic libc_sem_reltimedwait_np sem_reltimedwait_np "libc.so" 39 //go:cgo_import_dynamic libc_sem_wait sem_wait "libc.so" 40 //go:cgo_import_dynamic libc_setitimer setitimer "libc.so" 41 //go:cgo_import_dynamic libc_sigaction sigaction "libc.so" 42 //go:cgo_import_dynamic libc_sigaltstack sigaltstack "libc.so" 43 //go:cgo_import_dynamic libc_sigprocmask sigprocmask "libc.so" 44 //go:cgo_import_dynamic libc_sysconf sysconf "libc.so" 45 //go:cgo_import_dynamic libc_usleep usleep "libc.so" 46 //go:cgo_import_dynamic libc_write write "libc.so" 47 48 //go:linkname libc____errno libc____errno 49 //go:linkname libc_clock_gettime libc_clock_gettime 50 //go:linkname libc_close libc_close 51 //go:linkname libc_exit libc_exit 52 //go:linkname libc_fstat libc_fstat 53 //go:linkname libc_getcontext libc_getcontext 54 //go:linkname libc_getrlimit libc_getrlimit 55 //go:linkname libc_kill libc_kill 56 //go:linkname libc_madvise libc_madvise 57 //go:linkname libc_malloc libc_malloc 58 //go:linkname libc_mmap libc_mmap 59 //go:linkname libc_munmap libc_munmap 60 //go:linkname libc_open libc_open 61 //go:linkname libc_pthread_attr_destroy libc_pthread_attr_destroy 62 //go:linkname libc_pthread_attr_getstack libc_pthread_attr_getstack 63 //go:linkname libc_pthread_attr_init libc_pthread_attr_init 64 //go:linkname libc_pthread_attr_setdetachstate libc_pthread_attr_setdetachstate 65 //go:linkname libc_pthread_attr_setstack libc_pthread_attr_setstack 66 //go:linkname libc_pthread_create libc_pthread_create 67 //go:linkname libc_raise libc_raise 68 //go:linkname libc_read libc_read 69 //go:linkname libc_select libc_select 70 //go:linkname libc_sched_yield libc_sched_yield 71 //go:linkname libc_sem_init libc_sem_init 72 //go:linkname libc_sem_post libc_sem_post 73 //go:linkname libc_sem_reltimedwait_np libc_sem_reltimedwait_np 74 //go:linkname libc_sem_wait libc_sem_wait 75 //go:linkname libc_setitimer libc_setitimer 76 //go:linkname libc_sigaction libc_sigaction 77 //go:linkname libc_sigaltstack libc_sigaltstack 78 //go:linkname libc_sigprocmask libc_sigprocmask 79 //go:linkname libc_sysconf libc_sysconf 80 //go:linkname libc_usleep libc_usleep 81 //go:linkname libc_write libc_write 82 83 var ( 84 libc____errno, 85 libc_clock_gettime, 86 libc_close, 87 libc_exit, 88 libc_fstat, 89 libc_getcontext, 90 libc_getrlimit, 91 libc_kill, 92 libc_madvise, 93 libc_malloc, 94 libc_mmap, 95 libc_munmap, 96 libc_open, 97 libc_pthread_attr_destroy, 98 libc_pthread_attr_getstack, 99 libc_pthread_attr_init, 100 libc_pthread_attr_setdetachstate, 101 libc_pthread_attr_setstack, 102 libc_pthread_create, 103 libc_raise, 104 libc_read, 105 libc_sched_yield, 106 libc_select, 107 libc_sem_init, 108 libc_sem_post, 109 libc_sem_reltimedwait_np, 110 libc_sem_wait, 111 libc_setitimer, 112 libc_sigaction, 113 libc_sigaltstack, 114 libc_sigprocmask, 115 libc_sysconf, 116 libc_usleep, 117 libc_write libcFunc 118 ) 119 120 var sigset_all = sigset{[4]uint32{^uint32(0), ^uint32(0), ^uint32(0), ^uint32(0)}} 121 122 func getncpu() int32 { 123 n := int32(sysconf(__SC_NPROCESSORS_ONLN)) 124 if n < 1 { 125 return 1 126 } 127 return n 128 } 129 130 func osinit() { 131 ncpu = getncpu() 132 } 133 134 func tstart_sysvicall() 135 136 // May run with m.p==nil, so write barriers are not allowed. 137 //go:nowritebarrier 138 func newosproc(mp *m, _ unsafe.Pointer) { 139 var ( 140 attr pthreadattr 141 oset sigset 142 tid pthread 143 ret int32 144 size uint64 145 ) 146 147 if pthread_attr_init(&attr) != 0 { 148 throw("pthread_attr_init") 149 } 150 if pthread_attr_setstack(&attr, 0, 0x200000) != 0 { 151 throw("pthread_attr_setstack") 152 } 153 if pthread_attr_getstack(&attr, unsafe.Pointer(&mp.g0.stack.hi), &size) != 0 { 154 throw("pthread_attr_getstack") 155 } 156 mp.g0.stack.lo = mp.g0.stack.hi - uintptr(size) 157 if pthread_attr_setdetachstate(&attr, _PTHREAD_CREATE_DETACHED) != 0 { 158 throw("pthread_attr_setdetachstate") 159 } 160 161 // Disable signals during create, so that the new thread starts 162 // with signals disabled. It will enable them in minit. 163 sigprocmask(_SIG_SETMASK, &sigset_all, &oset) 164 ret = pthread_create(&tid, &attr, funcPC(tstart_sysvicall), unsafe.Pointer(mp)) 165 sigprocmask(_SIG_SETMASK, &oset, nil) 166 if ret != 0 { 167 print("runtime: failed to create new OS thread (have ", mcount(), " already; errno=", ret, ")\n") 168 if ret == -_EAGAIN { 169 println("runtime: may need to increase max user processes (ulimit -u)") 170 } 171 throw("newosproc") 172 } 173 } 174 175 var urandom_dev = []byte("/dev/urandom\x00") 176 177 //go:nosplit 178 func getRandomData(r []byte) { 179 fd := open(&urandom_dev[0], 0 /* O_RDONLY */, 0) 180 n := read(fd, unsafe.Pointer(&r[0]), int32(len(r))) 181 closefd(fd) 182 extendRandom(r, int(n)) 183 } 184 185 func goenvs() { 186 goenvs_unix() 187 } 188 189 // Called to initialize a new m (including the bootstrap m). 190 // Called on the parent thread (main thread in case of bootstrap), can allocate memory. 191 func mpreinit(mp *m) { 192 mp.gsignal = malg(32 * 1024) 193 mp.gsignal.m = mp 194 } 195 196 func miniterrno() 197 198 //go:nosplit 199 func msigsave(mp *m) { 200 sigprocmask(_SIG_SETMASK, nil, &mp.sigmask) 201 } 202 203 //go:nosplit 204 func msigrestore(sigmask sigset) { 205 sigprocmask(_SIG_SETMASK, &sigmask, nil) 206 } 207 208 //go:nosplit 209 func sigblock() { 210 sigprocmask(_SIG_SETMASK, &sigset_all, nil) 211 } 212 213 // Called to initialize a new m (including the bootstrap m). 214 // Called on the new thread, cannot allocate memory. 215 func minit() { 216 _g_ := getg() 217 asmcgocall(unsafe.Pointer(funcPC(miniterrno)), unsafe.Pointer(&libc____errno)) 218 // Initialize signal handling 219 var st sigaltstackt 220 sigaltstack(nil, &st) 221 if st.ss_flags&_SS_DISABLE != 0 { 222 signalstack(&_g_.m.gsignal.stack) 223 _g_.m.newSigstack = true 224 } else { 225 // Use existing signal stack. 226 stsp := uintptr(unsafe.Pointer(st.ss_sp)) 227 _g_.m.gsignal.stack.lo = stsp 228 _g_.m.gsignal.stack.hi = stsp + uintptr(st.ss_size) 229 _g_.m.gsignal.stackguard0 = stsp + _StackGuard 230 _g_.m.gsignal.stackguard1 = stsp + _StackGuard 231 _g_.m.gsignal.stackAlloc = uintptr(st.ss_size) 232 _g_.m.newSigstack = false 233 } 234 235 // restore signal mask from m.sigmask and unblock essential signals 236 nmask := _g_.m.sigmask 237 for i := range sigtable { 238 if sigtable[i].flags&_SigUnblock != 0 { 239 nmask.__sigbits[(i-1)/32] &^= 1 << ((uint32(i) - 1) & 31) 240 } 241 } 242 sigprocmask(_SIG_SETMASK, &nmask, nil) 243 } 244 245 // Called from dropm to undo the effect of an minit. 246 func unminit() { 247 if getg().m.newSigstack { 248 signalstack(nil) 249 } 250 } 251 252 func memlimit() uintptr { 253 /* 254 TODO: Convert to Go when something actually uses the result. 255 Rlimit rl; 256 extern byte runtime·text[], runtime·end[]; 257 uintptr used; 258 259 if(runtime·getrlimit(RLIMIT_AS, &rl) != 0) 260 return 0; 261 if(rl.rlim_cur >= 0x7fffffff) 262 return 0; 263 264 // Estimate our VM footprint excluding the heap. 265 // Not an exact science: use size of binary plus 266 // some room for thread stacks. 267 used = runtime·end - runtime·text + (64<<20); 268 if(used >= rl.rlim_cur) 269 return 0; 270 271 // If there's not at least 16 MB left, we're probably 272 // not going to be able to do much. Treat as no limit. 273 rl.rlim_cur -= used; 274 if(rl.rlim_cur < (16<<20)) 275 return 0; 276 277 return rl.rlim_cur - used; 278 */ 279 280 return 0 281 } 282 283 func sigtramp() 284 285 //go:nosplit 286 //go:nowritebarrierrec 287 func setsig(i int32, fn uintptr, restart bool) { 288 var sa sigactiont 289 290 sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK 291 sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK 292 if restart { 293 sa.sa_flags |= _SA_RESTART 294 } 295 sa.sa_mask = sigset_all 296 if fn == funcPC(sighandler) { 297 fn = funcPC(sigtramp) 298 } 299 *((*uintptr)(unsafe.Pointer(&sa._funcptr))) = fn 300 sigaction(i, &sa, nil) 301 } 302 303 //go:nosplit 304 //go:nowritebarrierrec 305 func setsigstack(i int32) { 306 var sa sigactiont 307 sigaction(i, nil, &sa) 308 handler := *((*uintptr)(unsafe.Pointer(&sa._funcptr))) 309 if handler == 0 || handler == _SIG_DFL || handler == _SIG_IGN || sa.sa_flags&_SA_ONSTACK != 0 { 310 return 311 } 312 sa.sa_flags |= _SA_ONSTACK 313 sigaction(i, &sa, nil) 314 } 315 316 //go:nosplit 317 //go:nowritebarrierrec 318 func getsig(i int32) uintptr { 319 var sa sigactiont 320 sigaction(i, nil, &sa) 321 if *((*uintptr)(unsafe.Pointer(&sa._funcptr))) == funcPC(sigtramp) { 322 return funcPC(sighandler) 323 } 324 return *((*uintptr)(unsafe.Pointer(&sa._funcptr))) 325 } 326 327 //go:nosplit 328 func signalstack(s *stack) { 329 var st sigaltstackt 330 if s == nil { 331 st.ss_flags = _SS_DISABLE 332 } else { 333 st.ss_sp = (*byte)(unsafe.Pointer(s.lo)) 334 st.ss_size = uint64(s.hi - s.lo) 335 st.ss_flags = 0 336 } 337 sigaltstack(&st, nil) 338 } 339 340 //go:nosplit 341 //go:nowritebarrierrec 342 func updatesigmask(m sigmask) { 343 var mask sigset 344 copy(mask.__sigbits[:], m[:]) 345 sigprocmask(_SIG_SETMASK, &mask, nil) 346 } 347 348 func unblocksig(sig int32) { 349 var mask sigset 350 mask.__sigbits[(sig-1)/32] |= 1 << ((uint32(sig) - 1) & 31) 351 sigprocmask(_SIG_UNBLOCK, &mask, nil) 352 } 353 354 //go:nosplit 355 func semacreate(mp *m) { 356 if mp.waitsema != 0 { 357 return 358 } 359 360 var sem *semt 361 _g_ := getg() 362 363 // Call libc's malloc rather than malloc. This will 364 // allocate space on the C heap. We can't call malloc 365 // here because it could cause a deadlock. 366 _g_.m.libcall.fn = uintptr(unsafe.Pointer(&libc_malloc)) 367 _g_.m.libcall.n = 1 368 memclr(unsafe.Pointer(&_g_.m.scratch), uintptr(len(_g_.m.scratch.v))) 369 _g_.m.scratch.v[0] = unsafe.Sizeof(*sem) 370 _g_.m.libcall.args = uintptr(unsafe.Pointer(&_g_.m.scratch)) 371 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&_g_.m.libcall)) 372 sem = (*semt)(unsafe.Pointer(_g_.m.libcall.r1)) 373 if sem_init(sem, 0, 0) != 0 { 374 throw("sem_init") 375 } 376 mp.waitsema = uintptr(unsafe.Pointer(sem)) 377 } 378 379 //go:nosplit 380 func semasleep(ns int64) int32 { 381 _m_ := getg().m 382 if ns >= 0 { 383 _m_.ts.tv_sec = ns / 1000000000 384 _m_.ts.tv_nsec = ns % 1000000000 385 386 _m_.libcall.fn = uintptr(unsafe.Pointer(&libc_sem_reltimedwait_np)) 387 _m_.libcall.n = 2 388 memclr(unsafe.Pointer(&_m_.scratch), uintptr(len(_m_.scratch.v))) 389 _m_.scratch.v[0] = _m_.waitsema 390 _m_.scratch.v[1] = uintptr(unsafe.Pointer(&_m_.ts)) 391 _m_.libcall.args = uintptr(unsafe.Pointer(&_m_.scratch)) 392 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&_m_.libcall)) 393 if *_m_.perrno != 0 { 394 if *_m_.perrno == _ETIMEDOUT || *_m_.perrno == _EAGAIN || *_m_.perrno == _EINTR { 395 return -1 396 } 397 throw("sem_reltimedwait_np") 398 } 399 return 0 400 } 401 for { 402 _m_.libcall.fn = uintptr(unsafe.Pointer(&libc_sem_wait)) 403 _m_.libcall.n = 1 404 memclr(unsafe.Pointer(&_m_.scratch), uintptr(len(_m_.scratch.v))) 405 _m_.scratch.v[0] = _m_.waitsema 406 _m_.libcall.args = uintptr(unsafe.Pointer(&_m_.scratch)) 407 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&_m_.libcall)) 408 if _m_.libcall.r1 == 0 { 409 break 410 } 411 if *_m_.perrno == _EINTR { 412 continue 413 } 414 throw("sem_wait") 415 } 416 return 0 417 } 418 419 //go:nosplit 420 func semawakeup(mp *m) { 421 if sem_post((*semt)(unsafe.Pointer(mp.waitsema))) != 0 { 422 throw("sem_post") 423 } 424 } 425 426 //go:nosplit 427 func closefd(fd int32) int32 { 428 return int32(sysvicall1(&libc_close, uintptr(fd))) 429 } 430 431 //go:nosplit 432 func exit(r int32) { 433 sysvicall1(&libc_exit, uintptr(r)) 434 } 435 436 //go:nosplit 437 func getcontext(context *ucontext) /* int32 */ { 438 sysvicall1(&libc_getcontext, uintptr(unsafe.Pointer(context))) 439 } 440 441 //go:nosplit 442 func madvise(addr unsafe.Pointer, n uintptr, flags int32) { 443 sysvicall3(&libc_madvise, uintptr(addr), uintptr(n), uintptr(flags)) 444 } 445 446 //go:nosplit 447 func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) unsafe.Pointer { 448 p, err := doMmap(uintptr(addr), n, uintptr(prot), uintptr(flags), uintptr(fd), uintptr(off)) 449 if p == ^uintptr(0) { 450 return unsafe.Pointer(err) 451 } 452 return unsafe.Pointer(p) 453 } 454 455 //go:nosplit 456 func doMmap(addr, n, prot, flags, fd, off uintptr) (uintptr, uintptr) { 457 var libcall libcall 458 libcall.fn = uintptr(unsafe.Pointer(&libc_mmap)) 459 libcall.n = 6 460 libcall.args = uintptr(noescape(unsafe.Pointer(&addr))) 461 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&libcall)) 462 return libcall.r1, libcall.err 463 } 464 465 //go:nosplit 466 func munmap(addr unsafe.Pointer, n uintptr) { 467 sysvicall2(&libc_munmap, uintptr(addr), uintptr(n)) 468 } 469 470 func nanotime1() 471 472 //go:nosplit 473 func nanotime() int64 { 474 return int64(sysvicall0((*libcFunc)(unsafe.Pointer(funcPC(nanotime1))))) 475 } 476 477 //go:nosplit 478 func open(path *byte, mode, perm int32) int32 { 479 return int32(sysvicall3(&libc_open, uintptr(unsafe.Pointer(path)), uintptr(mode), uintptr(perm))) 480 } 481 482 func pthread_attr_destroy(attr *pthreadattr) int32 { 483 return int32(sysvicall1(&libc_pthread_attr_destroy, uintptr(unsafe.Pointer(attr)))) 484 } 485 486 func pthread_attr_getstack(attr *pthreadattr, addr unsafe.Pointer, size *uint64) int32 { 487 return int32(sysvicall3(&libc_pthread_attr_getstack, uintptr(unsafe.Pointer(attr)), uintptr(addr), uintptr(unsafe.Pointer(size)))) 488 } 489 490 func pthread_attr_init(attr *pthreadattr) int32 { 491 return int32(sysvicall1(&libc_pthread_attr_init, uintptr(unsafe.Pointer(attr)))) 492 } 493 494 func pthread_attr_setdetachstate(attr *pthreadattr, state int32) int32 { 495 return int32(sysvicall2(&libc_pthread_attr_setdetachstate, uintptr(unsafe.Pointer(attr)), uintptr(state))) 496 } 497 498 func pthread_attr_setstack(attr *pthreadattr, addr uintptr, size uint64) int32 { 499 return int32(sysvicall3(&libc_pthread_attr_setstack, uintptr(unsafe.Pointer(attr)), uintptr(addr), uintptr(size))) 500 } 501 502 func pthread_create(thread *pthread, attr *pthreadattr, fn uintptr, arg unsafe.Pointer) int32 { 503 return int32(sysvicall4(&libc_pthread_create, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(fn), uintptr(arg))) 504 } 505 506 //go:nosplit 507 //go:nowritebarrierrec 508 func raise(sig int32) /* int32 */ { 509 sysvicall1(&libc_raise, uintptr(sig)) 510 } 511 512 func raiseproc(sig int32) /* int32 */ { 513 pid := sysvicall0(&libc_getpid) 514 sysvicall2(&libc_kill, pid, uintptr(sig)) 515 } 516 517 //go:nosplit 518 func read(fd int32, buf unsafe.Pointer, nbyte int32) int32 { 519 return int32(sysvicall3(&libc_read, uintptr(fd), uintptr(buf), uintptr(nbyte))) 520 } 521 522 //go:nosplit 523 func sem_init(sem *semt, pshared int32, value uint32) int32 { 524 return int32(sysvicall3(&libc_sem_init, uintptr(unsafe.Pointer(sem)), uintptr(pshared), uintptr(value))) 525 } 526 527 //go:nosplit 528 func sem_post(sem *semt) int32 { 529 return int32(sysvicall1(&libc_sem_post, uintptr(unsafe.Pointer(sem)))) 530 } 531 532 //go:nosplit 533 func sem_reltimedwait_np(sem *semt, timeout *timespec) int32 { 534 return int32(sysvicall2(&libc_sem_reltimedwait_np, uintptr(unsafe.Pointer(sem)), uintptr(unsafe.Pointer(timeout)))) 535 } 536 537 //go:nosplit 538 func sem_wait(sem *semt) int32 { 539 return int32(sysvicall1(&libc_sem_wait, uintptr(unsafe.Pointer(sem)))) 540 } 541 542 func setitimer(which int32, value *itimerval, ovalue *itimerval) /* int32 */ { 543 sysvicall3(&libc_setitimer, uintptr(which), uintptr(unsafe.Pointer(value)), uintptr(unsafe.Pointer(ovalue))) 544 } 545 546 //go:nosplit 547 //go:nowritebarrierrec 548 func sigaction(sig int32, act *sigactiont, oact *sigactiont) /* int32 */ { 549 sysvicall3(&libc_sigaction, uintptr(sig), uintptr(unsafe.Pointer(act)), uintptr(unsafe.Pointer(oact))) 550 } 551 552 //go:nosplit 553 //go:nowritebarrierrec 554 func sigaltstack(ss *sigaltstackt, oss *sigaltstackt) /* int32 */ { 555 sysvicall2(&libc_sigaltstack, uintptr(unsafe.Pointer(ss)), uintptr(unsafe.Pointer(oss))) 556 } 557 558 //go:nosplit 559 //go:nowritebarrierrec 560 func sigprocmask(how int32, set *sigset, oset *sigset) /* int32 */ { 561 sysvicall3(&libc_sigprocmask, uintptr(how), uintptr(unsafe.Pointer(set)), uintptr(unsafe.Pointer(oset))) 562 } 563 564 func sysconf(name int32) int64 { 565 return int64(sysvicall1(&libc_sysconf, uintptr(name))) 566 } 567 568 func usleep1(uint32) 569 570 //go:nosplit 571 func usleep(µs uint32) { 572 usleep1(µs) 573 } 574 575 //go:nosplit 576 func write(fd uintptr, buf unsafe.Pointer, nbyte int32) int32 { 577 return int32(sysvicall3(&libc_write, uintptr(fd), uintptr(buf), uintptr(nbyte))) 578 } 579 580 func osyield1() 581 582 //go:nosplit 583 func osyield() { 584 _g_ := getg() 585 586 // Check the validity of m because we might be called in cgo callback 587 // path early enough where there isn't a m available yet. 588 if _g_ != nil && _g_.m != nil { 589 sysvicall0(&libc_sched_yield) 590 return 591 } 592 osyield1() 593 }