github.com/miolini/go@v0.0.0-20160405192216-fca68c8cb408/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 throw("newosproc") 169 } 170 } 171 172 var urandom_dev = []byte("/dev/urandom\x00") 173 174 //go:nosplit 175 func getRandomData(r []byte) { 176 fd := open(&urandom_dev[0], 0 /* O_RDONLY */, 0) 177 n := read(fd, unsafe.Pointer(&r[0]), int32(len(r))) 178 closefd(fd) 179 extendRandom(r, int(n)) 180 } 181 182 func goenvs() { 183 goenvs_unix() 184 } 185 186 // Called to initialize a new m (including the bootstrap m). 187 // Called on the parent thread (main thread in case of bootstrap), can allocate memory. 188 func mpreinit(mp *m) { 189 mp.gsignal = malg(32 * 1024) 190 mp.gsignal.m = mp 191 } 192 193 func miniterrno() 194 195 //go:nosplit 196 func msigsave(mp *m) { 197 sigprocmask(_SIG_SETMASK, nil, &mp.sigmask) 198 } 199 200 //go:nosplit 201 func msigrestore(sigmask sigset) { 202 sigprocmask(_SIG_SETMASK, &sigmask, nil) 203 } 204 205 //go:nosplit 206 func sigblock() { 207 sigprocmask(_SIG_SETMASK, &sigset_all, nil) 208 } 209 210 // Called to initialize a new m (including the bootstrap m). 211 // Called on the new thread, cannot allocate memory. 212 func minit() { 213 _g_ := getg() 214 asmcgocall(unsafe.Pointer(funcPC(miniterrno)), unsafe.Pointer(&libc____errno)) 215 // Initialize signal handling 216 var st sigaltstackt 217 sigaltstack(nil, &st) 218 if st.ss_flags&_SS_DISABLE != 0 { 219 signalstack(&_g_.m.gsignal.stack) 220 _g_.m.newSigstack = true 221 } else { 222 // Use existing signal stack. 223 stsp := uintptr(unsafe.Pointer(st.ss_sp)) 224 _g_.m.gsignal.stack.lo = stsp 225 _g_.m.gsignal.stack.hi = stsp + uintptr(st.ss_size) 226 _g_.m.gsignal.stackguard0 = stsp + _StackGuard 227 _g_.m.gsignal.stackguard1 = stsp + _StackGuard 228 _g_.m.gsignal.stackAlloc = uintptr(st.ss_size) 229 _g_.m.newSigstack = false 230 } 231 232 // restore signal mask from m.sigmask and unblock essential signals 233 nmask := _g_.m.sigmask 234 for i := range sigtable { 235 if sigtable[i].flags&_SigUnblock != 0 { 236 nmask.__sigbits[(i-1)/32] &^= 1 << ((uint32(i) - 1) & 31) 237 } 238 } 239 sigprocmask(_SIG_SETMASK, &nmask, nil) 240 } 241 242 // Called from dropm to undo the effect of an minit. 243 func unminit() { 244 if getg().m.newSigstack { 245 signalstack(nil) 246 } 247 } 248 249 func memlimit() uintptr { 250 /* 251 TODO: Convert to Go when something actually uses the result. 252 Rlimit rl; 253 extern byte runtime·text[], runtime·end[]; 254 uintptr used; 255 256 if(runtime·getrlimit(RLIMIT_AS, &rl) != 0) 257 return 0; 258 if(rl.rlim_cur >= 0x7fffffff) 259 return 0; 260 261 // Estimate our VM footprint excluding the heap. 262 // Not an exact science: use size of binary plus 263 // some room for thread stacks. 264 used = runtime·end - runtime·text + (64<<20); 265 if(used >= rl.rlim_cur) 266 return 0; 267 268 // If there's not at least 16 MB left, we're probably 269 // not going to be able to do much. Treat as no limit. 270 rl.rlim_cur -= used; 271 if(rl.rlim_cur < (16<<20)) 272 return 0; 273 274 return rl.rlim_cur - used; 275 */ 276 277 return 0 278 } 279 280 func sigtramp() 281 282 //go:nosplit 283 //go:nowritebarrierrec 284 func setsig(i int32, fn uintptr, restart bool) { 285 var sa sigactiont 286 287 sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK 288 sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK 289 if restart { 290 sa.sa_flags |= _SA_RESTART 291 } 292 sa.sa_mask = sigset_all 293 if fn == funcPC(sighandler) { 294 fn = funcPC(sigtramp) 295 } 296 *((*uintptr)(unsafe.Pointer(&sa._funcptr))) = fn 297 sigaction(i, &sa, nil) 298 } 299 300 //go:nosplit 301 //go:nowritebarrierrec 302 func setsigstack(i int32) { 303 var sa sigactiont 304 sigaction(i, nil, &sa) 305 handler := *((*uintptr)(unsafe.Pointer(&sa._funcptr))) 306 if handler == 0 || handler == _SIG_DFL || handler == _SIG_IGN || sa.sa_flags&_SA_ONSTACK != 0 { 307 return 308 } 309 sa.sa_flags |= _SA_ONSTACK 310 sigaction(i, &sa, nil) 311 } 312 313 //go:nosplit 314 //go:nowritebarrierrec 315 func getsig(i int32) uintptr { 316 var sa sigactiont 317 sigaction(i, nil, &sa) 318 if *((*uintptr)(unsafe.Pointer(&sa._funcptr))) == funcPC(sigtramp) { 319 return funcPC(sighandler) 320 } 321 return *((*uintptr)(unsafe.Pointer(&sa._funcptr))) 322 } 323 324 //go:nosplit 325 func signalstack(s *stack) { 326 var st sigaltstackt 327 if s == nil { 328 st.ss_flags = _SS_DISABLE 329 } else { 330 st.ss_sp = (*byte)(unsafe.Pointer(s.lo)) 331 st.ss_size = uint64(s.hi - s.lo) 332 st.ss_flags = 0 333 } 334 sigaltstack(&st, nil) 335 } 336 337 //go:nosplit 338 //go:nowritebarrierrec 339 func updatesigmask(m sigmask) { 340 var mask sigset 341 copy(mask.__sigbits[:], m[:]) 342 sigprocmask(_SIG_SETMASK, &mask, nil) 343 } 344 345 func unblocksig(sig int32) { 346 var mask sigset 347 mask.__sigbits[(sig-1)/32] |= 1 << ((uint32(sig) - 1) & 31) 348 sigprocmask(_SIG_UNBLOCK, &mask, nil) 349 } 350 351 //go:nosplit 352 func semacreate(mp *m) { 353 if mp.waitsema != 0 { 354 return 355 } 356 357 var sem *semt 358 _g_ := getg() 359 360 // Call libc's malloc rather than malloc. This will 361 // allocate space on the C heap. We can't call malloc 362 // here because it could cause a deadlock. 363 _g_.m.libcall.fn = uintptr(unsafe.Pointer(&libc_malloc)) 364 _g_.m.libcall.n = 1 365 memclr(unsafe.Pointer(&_g_.m.scratch), uintptr(len(_g_.m.scratch.v))) 366 _g_.m.scratch.v[0] = unsafe.Sizeof(*sem) 367 _g_.m.libcall.args = uintptr(unsafe.Pointer(&_g_.m.scratch)) 368 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&_g_.m.libcall)) 369 sem = (*semt)(unsafe.Pointer(_g_.m.libcall.r1)) 370 if sem_init(sem, 0, 0) != 0 { 371 throw("sem_init") 372 } 373 mp.waitsema = uintptr(unsafe.Pointer(sem)) 374 } 375 376 //go:nosplit 377 func semasleep(ns int64) int32 { 378 _m_ := getg().m 379 if ns >= 0 { 380 _m_.ts.tv_sec = ns / 1000000000 381 _m_.ts.tv_nsec = ns % 1000000000 382 383 _m_.libcall.fn = uintptr(unsafe.Pointer(&libc_sem_reltimedwait_np)) 384 _m_.libcall.n = 2 385 memclr(unsafe.Pointer(&_m_.scratch), uintptr(len(_m_.scratch.v))) 386 _m_.scratch.v[0] = _m_.waitsema 387 _m_.scratch.v[1] = uintptr(unsafe.Pointer(&_m_.ts)) 388 _m_.libcall.args = uintptr(unsafe.Pointer(&_m_.scratch)) 389 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&_m_.libcall)) 390 if *_m_.perrno != 0 { 391 if *_m_.perrno == _ETIMEDOUT || *_m_.perrno == _EAGAIN || *_m_.perrno == _EINTR { 392 return -1 393 } 394 throw("sem_reltimedwait_np") 395 } 396 return 0 397 } 398 for { 399 _m_.libcall.fn = uintptr(unsafe.Pointer(&libc_sem_wait)) 400 _m_.libcall.n = 1 401 memclr(unsafe.Pointer(&_m_.scratch), uintptr(len(_m_.scratch.v))) 402 _m_.scratch.v[0] = _m_.waitsema 403 _m_.libcall.args = uintptr(unsafe.Pointer(&_m_.scratch)) 404 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&_m_.libcall)) 405 if _m_.libcall.r1 == 0 { 406 break 407 } 408 if *_m_.perrno == _EINTR { 409 continue 410 } 411 throw("sem_wait") 412 } 413 return 0 414 } 415 416 //go:nosplit 417 func semawakeup(mp *m) { 418 if sem_post((*semt)(unsafe.Pointer(mp.waitsema))) != 0 { 419 throw("sem_post") 420 } 421 } 422 423 //go:nosplit 424 func closefd(fd int32) int32 { 425 return int32(sysvicall1(&libc_close, uintptr(fd))) 426 } 427 428 //go:nosplit 429 func exit(r int32) { 430 sysvicall1(&libc_exit, uintptr(r)) 431 } 432 433 //go:nosplit 434 func getcontext(context *ucontext) /* int32 */ { 435 sysvicall1(&libc_getcontext, uintptr(unsafe.Pointer(context))) 436 } 437 438 //go:nosplit 439 func madvise(addr unsafe.Pointer, n uintptr, flags int32) { 440 sysvicall3(&libc_madvise, uintptr(addr), uintptr(n), uintptr(flags)) 441 } 442 443 //go:nosplit 444 func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) unsafe.Pointer { 445 p, err := doMmap(uintptr(addr), n, uintptr(prot), uintptr(flags), uintptr(fd), uintptr(off)) 446 if p == ^uintptr(0) { 447 return unsafe.Pointer(err) 448 } 449 return unsafe.Pointer(p) 450 } 451 452 //go:nosplit 453 func doMmap(addr, n, prot, flags, fd, off uintptr) (uintptr, uintptr) { 454 var libcall libcall 455 libcall.fn = uintptr(unsafe.Pointer(&libc_mmap)) 456 libcall.n = 6 457 libcall.args = uintptr(noescape(unsafe.Pointer(&addr))) 458 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&libcall)) 459 return libcall.r1, libcall.err 460 } 461 462 //go:nosplit 463 func munmap(addr unsafe.Pointer, n uintptr) { 464 sysvicall2(&libc_munmap, uintptr(addr), uintptr(n)) 465 } 466 467 func nanotime1() 468 469 //go:nosplit 470 func nanotime() int64 { 471 return int64(sysvicall0((*libcFunc)(unsafe.Pointer(funcPC(nanotime1))))) 472 } 473 474 //go:nosplit 475 func open(path *byte, mode, perm int32) int32 { 476 return int32(sysvicall3(&libc_open, uintptr(unsafe.Pointer(path)), uintptr(mode), uintptr(perm))) 477 } 478 479 func pthread_attr_destroy(attr *pthreadattr) int32 { 480 return int32(sysvicall1(&libc_pthread_attr_destroy, uintptr(unsafe.Pointer(attr)))) 481 } 482 483 func pthread_attr_getstack(attr *pthreadattr, addr unsafe.Pointer, size *uint64) int32 { 484 return int32(sysvicall3(&libc_pthread_attr_getstack, uintptr(unsafe.Pointer(attr)), uintptr(addr), uintptr(unsafe.Pointer(size)))) 485 } 486 487 func pthread_attr_init(attr *pthreadattr) int32 { 488 return int32(sysvicall1(&libc_pthread_attr_init, uintptr(unsafe.Pointer(attr)))) 489 } 490 491 func pthread_attr_setdetachstate(attr *pthreadattr, state int32) int32 { 492 return int32(sysvicall2(&libc_pthread_attr_setdetachstate, uintptr(unsafe.Pointer(attr)), uintptr(state))) 493 } 494 495 func pthread_attr_setstack(attr *pthreadattr, addr uintptr, size uint64) int32 { 496 return int32(sysvicall3(&libc_pthread_attr_setstack, uintptr(unsafe.Pointer(attr)), uintptr(addr), uintptr(size))) 497 } 498 499 func pthread_create(thread *pthread, attr *pthreadattr, fn uintptr, arg unsafe.Pointer) int32 { 500 return int32(sysvicall4(&libc_pthread_create, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(fn), uintptr(arg))) 501 } 502 503 //go:nosplit 504 //go:nowritebarrierrec 505 func raise(sig int32) /* int32 */ { 506 sysvicall1(&libc_raise, uintptr(sig)) 507 } 508 509 func raiseproc(sig int32) /* int32 */ { 510 pid := sysvicall0(&libc_getpid) 511 sysvicall2(&libc_kill, pid, uintptr(sig)) 512 } 513 514 //go:nosplit 515 func read(fd int32, buf unsafe.Pointer, nbyte int32) int32 { 516 return int32(sysvicall3(&libc_read, uintptr(fd), uintptr(buf), uintptr(nbyte))) 517 } 518 519 //go:nosplit 520 func sem_init(sem *semt, pshared int32, value uint32) int32 { 521 return int32(sysvicall3(&libc_sem_init, uintptr(unsafe.Pointer(sem)), uintptr(pshared), uintptr(value))) 522 } 523 524 //go:nosplit 525 func sem_post(sem *semt) int32 { 526 return int32(sysvicall1(&libc_sem_post, uintptr(unsafe.Pointer(sem)))) 527 } 528 529 //go:nosplit 530 func sem_reltimedwait_np(sem *semt, timeout *timespec) int32 { 531 return int32(sysvicall2(&libc_sem_reltimedwait_np, uintptr(unsafe.Pointer(sem)), uintptr(unsafe.Pointer(timeout)))) 532 } 533 534 //go:nosplit 535 func sem_wait(sem *semt) int32 { 536 return int32(sysvicall1(&libc_sem_wait, uintptr(unsafe.Pointer(sem)))) 537 } 538 539 func setitimer(which int32, value *itimerval, ovalue *itimerval) /* int32 */ { 540 sysvicall3(&libc_setitimer, uintptr(which), uintptr(unsafe.Pointer(value)), uintptr(unsafe.Pointer(ovalue))) 541 } 542 543 //go:nosplit 544 //go:nowritebarrierrec 545 func sigaction(sig int32, act *sigactiont, oact *sigactiont) /* int32 */ { 546 sysvicall3(&libc_sigaction, uintptr(sig), uintptr(unsafe.Pointer(act)), uintptr(unsafe.Pointer(oact))) 547 } 548 549 //go:nosplit 550 //go:nowritebarrierrec 551 func sigaltstack(ss *sigaltstackt, oss *sigaltstackt) /* int32 */ { 552 sysvicall2(&libc_sigaltstack, uintptr(unsafe.Pointer(ss)), uintptr(unsafe.Pointer(oss))) 553 } 554 555 //go:nosplit 556 //go:nowritebarrierrec 557 func sigprocmask(how int32, set *sigset, oset *sigset) /* int32 */ { 558 sysvicall3(&libc_sigprocmask, uintptr(how), uintptr(unsafe.Pointer(set)), uintptr(unsafe.Pointer(oset))) 559 } 560 561 func sysconf(name int32) int64 { 562 return int64(sysvicall1(&libc_sysconf, uintptr(name))) 563 } 564 565 func usleep1(uint32) 566 567 //go:nosplit 568 func usleep(µs uint32) { 569 usleep1(µs) 570 } 571 572 //go:nosplit 573 func write(fd uintptr, buf unsafe.Pointer, nbyte int32) int32 { 574 return int32(sysvicall3(&libc_write, uintptr(fd), uintptr(buf), uintptr(nbyte))) 575 } 576 577 func osyield1() 578 579 //go:nosplit 580 func osyield() { 581 _g_ := getg() 582 583 // Check the validity of m because we might be called in cgo callback 584 // path early enough where there isn't a m available yet. 585 if _g_ != nil && _g_.m != nil { 586 sysvicall0(&libc_sched_yield) 587 return 588 } 589 osyield1() 590 }