go_netbsd.go RawHistoryFolder
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//go:build !cgo && (amd64 || arm64)
6
7package fakecgo
8
9import "unsafe"
10
11//go:nosplit
12func _cgo_sys_thread_start(ts *ThreadStart) {
13 var attr pthread_attr_t
14 var ign, oset sigset_t
15 var p pthread_t
16 var size size_t
17 var err int
18
19 // fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug
20 sigfillset(&ign)
21 pthread_sigmask(SIG_SETMASK, &ign, &oset)
22
23 pthread_attr_init(&attr)
24 pthread_attr_getstacksize(&attr, &size)
25 // Leave stacklo=0 and set stackhi=size; mstart will do the rest.
26 ts.g.stackhi = uintptr(size)
27
28 err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts)
29
30 pthread_sigmask(SIG_SETMASK, &oset, nil)
31
32 if err != 0 {
33 print("fakecgo: pthread_create failed: ")
34 println(err)
35 abort()
36 }
37}
38
39// threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function
40//
41//go:linkname x_threadentry_trampoline threadentry_trampoline
42var x_threadentry_trampoline byte
43var threadentry_trampolineABI0 = &x_threadentry_trampoline
44
45//go:nosplit
46func threadentry(v unsafe.Pointer) unsafe.Pointer {
47 var ss stack_t
48 ts := *(*ThreadStart)(v)
49 free(v)
50
51 // On NetBSD, a new thread inherits the signal stack of the
52 // creating thread. That confuses minit, so we remove that
53 // signal stack here before calling the regular mstart. It's
54 // a bit baroque to remove a signal stack here only to add one
55 // in minit, but it's a simple change that keeps NetBSD
56 // working like other OS's. At this point all signals are
57 // blocked, so there is no race.
58 ss.ss_flags = SS_DISABLE
59 sigaltstack(&ss, nil)
60
61 setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g)))
62
63 // faking funcs in go is a bit a... involved - but the following works :)
64 fn := uintptr(unsafe.Pointer(&ts.fn))
65 (*(*func())(unsafe.Pointer(&fn)))()
66
67 return nil
68}
69
70// here we will store a pointer to the provided setg func
71var setg_func uintptr
72
73//go:nosplit
74func x_cgo_init(g *G, setg uintptr) {
75 var size size_t
76 var attr pthread_attr_t
77
78 setg_func = setg
79 pthread_attr_init(&attr)
80 pthread_attr_getstacksize(&attr, &size)
81 // runtime/cgo uses __builtin_frame_address(0) instead of `uintptr(unsafe.Pointer(&size))`
82 // but this should be OK since we are taking the address of the first variable in this function.
83 g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096
84 pthread_attr_destroy(&attr)
85}