OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
fbaadba246
gcc/libgo/runtime/go-signal.c
Benny Siegert 8e841bd419 gccgo: fix runtime compilation on NetBSD 
si_code in siginfo_t is a macro on NetBSD, not a member of the
struct itself, so add a C trampoline for receiving its value.

Also replace references to mos.waitsemacount with the replacement and
add some helpers from os_netbsd.go in the GC repository.

Update golang/go#38538.

Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/228918
2020-04-20 21:20:53 -07:00

377 lines
12 KiB
C
Raw Blame History

/* go-signal.c -- signal handling for Go.
Copyright 2009 The Go Authors. All rights reserved.
Use of this source code is governed by a BSD-style
license that can be found in the LICENSE file. */
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <ucontext.h>
#include "runtime.h"
#ifndef SA_RESTART
#define SA_RESTART 0
#endif
#ifdef USING_SPLIT_STACK
extern void __splitstack_getcontext(void *context[10]);
extern void __splitstack_setcontext(void *context[10]);
extern void *__splitstack_find_context(void *context[10], size_t *,
void **, void **, void **);
#endif
// The rest of the signal handler, written in Go.
extern void sigtrampgo(uint32, siginfo_t *, void *)
__asm__(GOSYM_PREFIX "runtime.sigtrampgo");
// The Go signal handler, written in C. This should be running on the
// alternate signal stack. This is responsible for setting up the
// split stack context so that stack guard checks will work as
// expected.
void sigtramp(int, siginfo_t *, void *)
__attribute__ ((no_split_stack));
void sigtramp(int, siginfo_t *, void *)
__asm__ (GOSYM_PREFIX "runtime.sigtramp");
#ifndef USING_SPLIT_STACK
// When not using split stacks, there are no stack checks, and there
// is nothing special for this function to do.
void
sigtramp(int sig, siginfo_t *info, void *context)
{
sigtrampgo(sig, info, context);
}
#else // USING_SPLIT_STACK
void
sigtramp(int sig, siginfo_t *info, void *context)
{
G *gp;
void *stack_context[10];
void *stack;
size_t stack_size;
void *next_segment;
void *next_sp;
void *initial_sp;
uintptr sp;
stack_t st;
uintptr stsp;
gp = runtime_g();
if (gp == nil) {
// Let the Go code handle this case.
// It should only call nosplit functions in this case.
sigtrampgo(sig, info, context);
return;
}
// If this signal is one for which we will panic, we are not
// on the alternate signal stack. It's OK to call split-stack
// functions here.
if (sig == SIGBUS || sig == SIGFPE || sig == SIGSEGV) {
sigtrampgo(sig, info, context);
return;
}
// We are running on the alternate signal stack.
__splitstack_getcontext(&stack_context[0]);
stack = __splitstack_find_context((void*)(&gp->m->gsignal->stackcontext[0]),
&stack_size, &next_segment,
&next_sp, &initial_sp);
// If some non-Go code called sigaltstack, adjust.
sp = (uintptr)(&stack_size);
if (sp < (uintptr)(stack) || sp >= (uintptr)(stack) + stack_size) {
sigaltstack(nil, &st);
if ((st.ss_flags & SS_DISABLE) != 0) {
runtime_printf("signal %d received on thread with no signal stack\n", (int32)(sig));
runtime_throw("non-Go code disabled sigaltstack");
}
stsp = (uintptr)(st.ss_sp);
if (sp < stsp || sp >= stsp + st.ss_size) {
runtime_printf("signal %d received but handler not on signal stack\n", (int32)(sig));
runtime_throw("non-Go code set up signal handler without SA_ONSTACK flag");
}
// Unfortunately __splitstack_find_context will return NULL
// when it is called on a context that has never been used.
// There isn't much we can do but assume all is well.
if (stack != NULL) {
// Here the gc runtime adjusts the gsignal
// stack guard to match the values returned by
// sigaltstack. Unfortunately we have no way
// to do that.
runtime_printf("signal %d received on unknown signal stack\n", (int32)(sig));
runtime_throw("non-Go code changed signal stack");
}
}
// Set the split stack context so that the stack guards are
// checked correctly.
__splitstack_setcontext((void*)(&gp->m->gsignal->stackcontext[0]));
sigtrampgo(sig, info, context);
// We are going to return back to the signal trampoline and
// then to whatever we were doing before we got the signal.
// Restore the split stack context so that stack guards are
// checked correctly.
__splitstack_setcontext(&stack_context[0]);
}
#endif // USING_SPLIT_STACK
// C function to return the address of the sigtramp function.
uintptr getSigtramp(void) __asm__ (GOSYM_PREFIX "runtime.getSigtramp");
uintptr
getSigtramp()
{
return (uintptr)(void*)sigtramp;
}
// C code to manage the sigaction sa_sigaction field, which is
// typically a union and so hard for mksysinfo.sh to handle.
uintptr getSigactionHandler(struct sigaction*)
__attribute__ ((no_split_stack));
uintptr getSigactionHandler(struct sigaction*)
__asm__ (GOSYM_PREFIX "runtime.getSigactionHandler");
uintptr
getSigactionHandler(struct sigaction* sa)
{
return (uintptr)(sa->sa_sigaction);
}
void setSigactionHandler(struct sigaction*, uintptr)
__attribute__ ((no_split_stack));
void setSigactionHandler(struct sigaction*, uintptr)
__asm__ (GOSYM_PREFIX "runtime.setSigactionHandler");
void
setSigactionHandler(struct sigaction* sa, uintptr handler)
{
sa->sa_sigaction = (void*)(handler);
}
// C code to fetch values from the siginfo_t and ucontext_t pointers
// passed to a signal handler.
uintptr getSiginfoCode(siginfo_t *)
__attribute__ ((no_split_stack));
uintptr getSiginfoCode(siginfo_t *)
__asm__ (GOSYM_PREFIX "runtime.getSiginfoCode");
uintptr
getSiginfoCode(siginfo_t *info)
{
return (uintptr)(info->si_code);
}
struct getSiginfoRet {
uintptr sigaddr;
uintptr sigpc;
};
struct getSiginfoRet getSiginfo(siginfo_t *, void *)
__asm__(GOSYM_PREFIX "runtime.getSiginfo");
struct getSiginfoRet
getSiginfo(siginfo_t *info, void *context __attribute__((unused)))
{
struct getSiginfoRet ret;
Location loc[1];
int32 n;
if (info == nil) {
ret.sigaddr = 0;
} else {
ret.sigaddr = (uintptr)(info->si_addr);
}
ret.sigpc = 0;
// There doesn't seem to be a portable way to get the PC.
// Use unportable code to pull it from context, and if that fails
// try a stack backtrace across the signal handler.
#if defined(__x86_64__) && defined(__linux__)
ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gregs[REG_RIP];
#elif defined(__i386__) && defined(__linux__)
ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gregs[REG_EIP];
#elif defined(__alpha__) && defined(__linux__)
ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.sc_pc;
#elif defined(__PPC__) && defined(__linux__)
ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.regs->nip;
#elif defined(__PPC__) && defined(_AIX)
ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.jmp_context.iar;
#elif defined(__aarch64__) && defined(__linux__)
ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.pc;
#endif
if (ret.sigpc == 0) {
// Skip getSiginfo/sighandler/sigtrampgo/sigtramp/handler.
n = runtime_callers(5, &loc[0], 1, false);
if (n > 0) {
ret.sigpc = loc[0].pc;
}
}
return ret;
}
// Dump registers when crashing in a signal.
// There is no portable way to write this,
// so we just have some CPU/OS specific implementations.
void dumpregs(siginfo_t *, void *)
__asm__(GOSYM_PREFIX "runtime.dumpregs");
void
dumpregs(siginfo_t *info __attribute__((unused)), void *context __attribute__((unused)))
{
#if defined(__x86_64__) && defined(__linux__)
{
mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
runtime_printf("rax %X\n", m->gregs[REG_RAX]);
runtime_printf("rbx %X\n", m->gregs[REG_RBX]);
runtime_printf("rcx %X\n", m->gregs[REG_RCX]);
runtime_printf("rdx %X\n", m->gregs[REG_RDX]);
runtime_printf("rdi %X\n", m->gregs[REG_RDI]);
runtime_printf("rsi %X\n", m->gregs[REG_RSI]);
runtime_printf("rbp %X\n", m->gregs[REG_RBP]);
runtime_printf("rsp %X\n", m->gregs[REG_RSP]);
runtime_printf("r8 %X\n", m->gregs[REG_R8]);
runtime_printf("r9 %X\n", m->gregs[REG_R9]);
runtime_printf("r10 %X\n", m->gregs[REG_R10]);
runtime_printf("r11 %X\n", m->gregs[REG_R11]);
runtime_printf("r12 %X\n", m->gregs[REG_R12]);
runtime_printf("r13 %X\n", m->gregs[REG_R13]);
runtime_printf("r14 %X\n", m->gregs[REG_R14]);
runtime_printf("r15 %X\n", m->gregs[REG_R15]);
runtime_printf("rip %X\n", m->gregs[REG_RIP]);
runtime_printf("rflags %X\n", m->gregs[REG_EFL]);
runtime_printf("cs %X\n", m->gregs[REG_CSGSFS] & 0xffff);
runtime_printf("fs %X\n", (m->gregs[REG_CSGSFS] >> 16) & 0xffff);
runtime_printf("gs %X\n", (m->gregs[REG_CSGSFS] >> 32) & 0xffff);
}
#elif defined(__i386__) && defined(__linux__)
{
mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
runtime_printf("eax %x\n", m->gregs[REG_EAX]);
runtime_printf("ebx %x\n", m->gregs[REG_EBX]);
runtime_printf("ecx %x\n", m->gregs[REG_ECX]);
runtime_printf("edx %x\n", m->gregs[REG_EDX]);
runtime_printf("edi %x\n", m->gregs[REG_EDI]);
runtime_printf("esi %x\n", m->gregs[REG_ESI]);
runtime_printf("ebp %x\n", m->gregs[REG_EBP]);
runtime_printf("esp %x\n", m->gregs[REG_ESP]);
runtime_printf("eip %x\n", m->gregs[REG_EIP]);
runtime_printf("eflags %x\n", m->gregs[REG_EFL]);
runtime_printf("cs %x\n", m->gregs[REG_CS]);
runtime_printf("fs %x\n", m->gregs[REG_FS]);
runtime_printf("gs %x\n", m->gregs[REG_GS]);
}
#elif defined(__alpha__) && defined(__linux__)
{
mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
runtime_printf("v0 %X\n", m->sc_regs[0]);
runtime_printf("t0 %X\n", m->sc_regs[1]);
runtime_printf("t1 %X\n", m->sc_regs[2]);
runtime_printf("t2 %X\n", m->sc_regs[3]);
runtime_printf("t3 %X\n", m->sc_regs[4]);
runtime_printf("t4 %X\n", m->sc_regs[5]);
runtime_printf("t5 %X\n", m->sc_regs[6]);
runtime_printf("t6 %X\n", m->sc_regs[7]);
runtime_printf("t7 %X\n", m->sc_regs[8]);
runtime_printf("s0 %X\n", m->sc_regs[9]);
runtime_printf("s1 %X\n", m->sc_regs[10]);
runtime_printf("s2 %X\n", m->sc_regs[11]);
runtime_printf("s3 %X\n", m->sc_regs[12]);
runtime_printf("s4 %X\n", m->sc_regs[13]);
runtime_printf("s5 %X\n", m->sc_regs[14]);
runtime_printf("fp %X\n", m->sc_regs[15]);
runtime_printf("a0 %X\n", m->sc_regs[16]);
runtime_printf("a1 %X\n", m->sc_regs[17]);
runtime_printf("a2 %X\n", m->sc_regs[18]);
runtime_printf("a3 %X\n", m->sc_regs[19]);
runtime_printf("a4 %X\n", m->sc_regs[20]);
runtime_printf("a5 %X\n", m->sc_regs[21]);
runtime_printf("t8 %X\n", m->sc_regs[22]);
runtime_printf("t9 %X\n", m->sc_regs[23]);
runtime_printf("t10 %X\n", m->sc_regs[24]);
runtime_printf("t11 %X\n", m->sc_regs[25]);
runtime_printf("ra %X\n", m->sc_regs[26]);
runtime_printf("t12 %X\n", m->sc_regs[27]);
runtime_printf("at %X\n", m->sc_regs[28]);
runtime_printf("gp %X\n", m->sc_regs[29]);
runtime_printf("sp %X\n", m->sc_regs[30]);
runtime_printf("pc %X\n", m->sc_pc);
}
#elif defined(__PPC__) && defined(__LITTLE_ENDIAN__) && defined(__linux__)
{
mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
int i;
for (i = 0; i < 32; i++)
runtime_printf("r%d %X\n", i, m->regs->gpr[i]);
runtime_printf("pc %X\n", m->regs->nip);
runtime_printf("msr %X\n", m->regs->msr);
runtime_printf("cr %X\n", m->regs->ccr);
runtime_printf("lr %X\n", m->regs->link);
runtime_printf("ctr %X\n", m->regs->ctr);
runtime_printf("xer %X\n", m->regs->xer);
}
#elif defined(__PPC__) && defined(_AIX)
{
mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
int i;
for (i = 0; i < 32; i++)
runtime_printf("r%d %p\n", i, m->jmp_context.gpr[i]);
runtime_printf("pc %p\n", m->jmp_context.iar);
runtime_printf("msr %p\n", m->jmp_context.msr);
runtime_printf("cr %x\n", m->jmp_context.cr);
runtime_printf("lr %p\n", m->jmp_context.lr);
runtime_printf("ctr %p\n", m->jmp_context.ctr);
runtime_printf("xer %x\n", m->jmp_context.xer);
}
#elif defined(__aarch64__) && defined(__linux__)
{
mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
int i;
for (i = 0; i < 31; i++)
runtime_printf("x%d %X\n", i, m->regs[i]);
runtime_printf("sp %X\n", m->sp);
runtime_printf("pc %X\n", m->pc);
runtime_printf("pstate %X\n", m->pstate);
}
#endif
}
Reference in New Issue View Git Blame Copy Permalink