libgo/runtime/go-signal.c

   1 /* go-signal.c -- signal handling for Go.
   2
   3    Copyright 2009 The Go Authors. All rights reserved.
   4    Use of this source code is governed by a BSD-style
   5    license that can be found in the LICENSE file.  */
   6
   7 #include <signal.h>
   8 #include <stdlib.h>
   9 #include <unistd.h>
  10 #include <sys/time.h>
  11 #include <ucontext.h>
  12
  13 #include "runtime.h"
  14
  15 #ifndef SA_RESTART
  16   #define SA_RESTART 0
  17 #endif
  18
  19 #ifdef USING_SPLIT_STACK
  20
  21 extern void __splitstack_getcontext(void *context[10]);
  22
  23 extern void __splitstack_setcontext(void *context[10]);
  24
  25 extern void *__splitstack_find_context(void *context[10], size_t *,
  26                                        void **, void **, void **);
  27
  28 #endif
  29
  30 // The rest of the signal handler, written in Go.
  31
  32 extern void sigtrampgo(uint32, siginfo_t *, void *)
  33         __asm__(GOSYM_PREFIX "runtime.sigtrampgo");
  34
  35 // The Go signal handler, written in C.  This should be running on the
  36 // alternate signal stack.  This is responsible for setting up the
  37 // split stack context so that stack guard checks will work as
  38 // expected.
  39
  40 void sigtramp(int, siginfo_t *, void *)
  41         __attribute__ ((no_split_stack));
  42
  43 void sigtramp(int, siginfo_t *, void *)
  44         __asm__ (GOSYM_PREFIX "runtime.sigtramp");
  45
  46 #ifndef USING_SPLIT_STACK
  47
  48 // When not using split stacks, there are no stack checks, and there
  49 // is nothing special for this function to do.
  50
  51 void
  52 sigtramp(int sig, siginfo_t *info, void *context)
  53 {
  54         sigtrampgo(sig, info, context);
  55 }
  56
  57 #else // USING_SPLIT_STACK
  58
  59 void
  60 sigtramp(int sig, siginfo_t *info, void *context)
  61 {
  62         G *gp;
  63         void *stack_context[10];
  64         void *stack;
  65         void *find_stack;
  66         size_t stack_size;
  67         void *next_segment;
  68         void *next_sp;
  69         void *initial_sp;
  70         uintptr sp;
  71         stack_t st;
  72         uintptr stsp;
  73
  74         gp = runtime_g();
  75
  76         if (gp == nil) {
  77                 // Let the Go code handle this case.
  78                 // It should only call nosplit functions in this case.
  79                 sigtrampgo(sig, info, context);
  80                 return;
  81         }
  82
  83         // If this signal is one for which we will panic, we are not
  84         // on the alternate signal stack.  It's OK to call split-stack
  85         // functions here.
  86         if (sig == SIGBUS || sig == SIGFPE || sig == SIGSEGV) {
  87                 sigtrampgo(sig, info, context);
  88                 return;
  89         }
  90
  91         // We are running on the alternate signal stack.
  92
  93         __splitstack_getcontext(&stack_context[0]);
  94
  95         find_stack =
  96           __splitstack_find_context((void*)(&gp->m->gsignal->stackcontext[0]),
  97                                     &stack_size, &next_segment,
  98                                     &next_sp, &initial_sp);
  99         stack = find_stack;
 100         if (stack == NULL) {
 101                 stack = gp->m->gsignalstack;
 102                 stack_size = gp->m->gsignalstacksize;
 103         }
 104
 105         // If some non-Go code called sigaltstack, adjust.
 106         sp = (uintptr)(&stack_size);
 107         if (sp < (uintptr)(stack) || sp >= (uintptr)(stack) + stack_size) {
 108                 sigaltstack(nil, &st);
 109                 if ((st.ss_flags & SS_DISABLE) != 0) {
 110                         runtime_printf("signal %d received on thread with no signal stack\n", (int32)(sig));
 111                         runtime_throw("non-Go code disabled sigaltstack");
 112                 }
 113
 114                 stsp = (uintptr)(st.ss_sp);
 115                 if (sp < stsp || sp >= stsp + st.ss_size) {
 116                         runtime_printf("signal %d received but handler not on signal stack\n", (int32)(sig));
 117                         runtime_throw("non-Go code set up signal handler without SA_ONSTACK flag");
 118                 }
 119
 120                 // Unfortunately __splitstack_find_context will return NULL
 121                 // when it is called on a context that has never been used.
 122                 // There isn't much we can do but assume all is well.
 123                 if (find_stack != NULL) {
 124                         // Here the gc runtime adjusts the gsignal
 125                         // stack guard to match the values returned by
 126                         // sigaltstack.  Unfortunately we have no way
 127                         // to do that.
 128                         runtime_printf("signal %d received on unknown signal stack\n", (int32)(sig));
 129                         runtime_throw("non-Go code changed signal stack");
 130                 }
 131         }
 132
 133         // Set the split stack context so that the stack guards are
 134         // checked correctly.
 135
 136         __splitstack_setcontext((void*)(&gp->m->gsignal->stackcontext[0]));
 137
 138         sigtrampgo(sig, info, context);
 139
 140         // We are going to return back to the signal trampoline and
 141         // then to whatever we were doing before we got the signal.
 142         // Restore the split stack context so that stack guards are
 143         // checked correctly.
 144
 145         __splitstack_setcontext(&stack_context[0]);
 146 }
 147
 148 #endif // USING_SPLIT_STACK
 149
 150 // C function to return the address of the sigtramp function.
 151 uintptr getSigtramp(void) __asm__ (GOSYM_PREFIX "runtime.getSigtramp");
 152
 153 uintptr
 154 getSigtramp()
 155 {
 156   return (uintptr)(void*)sigtramp;
 157 }
 158
 159 // C code to manage the sigaction sa_sigaction field, which is
 160 // typically a union and so hard for mksysinfo.sh to handle.
 161
 162 uintptr getSigactionHandler(struct sigaction*)
 163         __attribute__ ((no_split_stack));
 164
 165 uintptr getSigactionHandler(struct sigaction*)
 166         __asm__ (GOSYM_PREFIX "runtime.getSigactionHandler");
 167
 168 uintptr
 169 getSigactionHandler(struct sigaction* sa)
 170 {
 171         return (uintptr)(sa->sa_sigaction);
 172 }
 173
 174 void setSigactionHandler(struct sigaction*, uintptr)
 175         __attribute__ ((no_split_stack));
 176
 177 void setSigactionHandler(struct sigaction*, uintptr)
 178         __asm__ (GOSYM_PREFIX "runtime.setSigactionHandler");
 179
 180 void
 181 setSigactionHandler(struct sigaction* sa, uintptr handler)
 182 {
 183         sa->sa_sigaction = (void*)(handler);
 184 }
 185
 186 #ifdef __linux__
 187
 188 // Workaround for https://sourceware.org/bugzilla/show_bug.cgi?id=27417
 189 #ifndef sigev_notify_thread_id
 190   #define sigev_notify_thread_id _sigev_un._tid
 191 #endif
 192
 193 void setSigeventTID(struct sigevent*, int32_t)
 194         __asm__ (GOSYM_PREFIX "runtime.setSigeventTID");
 195
 196 void
 197 setSigeventTID(struct sigevent *sev, int32_t v)
 198 {
 199         sev->sigev_notify_thread_id = v;
 200 }
 201
 202 #endif // defined(__linux__)
 203
 204 // C code to fetch values from the siginfo_t and ucontext_t pointers
 205 // passed to a signal handler.
 206
 207 uintptr getSiginfoCode(siginfo_t *)
 208         __attribute__ ((no_split_stack));
 209
 210 uintptr getSiginfoCode(siginfo_t *)
 211         __asm__ (GOSYM_PREFIX "runtime.getSiginfoCode");
 212
 213 uintptr
 214 getSiginfoCode(siginfo_t *info)
 215 {
 216         return (uintptr)(info->si_code);
 217 }
 218
 219 struct getSiginfoRet {
 220         uintptr sigaddr;
 221         uintptr sigpc;
 222 };
 223
 224 struct getSiginfoRet getSiginfo(siginfo_t *, void *)
 225         __asm__(GOSYM_PREFIX "runtime.getSiginfo");
 226
 227 struct getSiginfoRet
 228 getSiginfo(siginfo_t *info, void *context __attribute__((unused)))
 229 {
 230         struct getSiginfoRet ret;
 231         Location loc[1];
 232         int32 n;
 233
 234         if (info == nil) {
 235                 ret.sigaddr = 0;
 236         } else {
 237                 ret.sigaddr = (uintptr)(info->si_addr);
 238         }
 239         ret.sigpc = 0;
 240
 241         // There doesn't seem to be a portable way to get the PC.
 242         // Use unportable code to pull it from context, and if that fails
 243         // try a stack backtrace across the signal handler.
 244
 245 #if defined(__x86_64__) && defined(__linux__)
 246         ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gregs[REG_RIP];
 247 #elif defined(__i386__) && defined(__linux__)
 248         ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gregs[REG_EIP];
 249 #elif defined(__alpha__) && defined(__linux__)
 250         ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.sc_pc;
 251 #elif defined(__PPC64__) && defined(__linux__)
 252         ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gp_regs[32];
 253 #elif defined(__PPC__) && defined(__linux__)
 254 # if defined(__GLIBC__)
 255         ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.uc_regs->gregs[32];
 256 # else
 257         ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gregs[32];
 258 # endif
 259 #elif defined(__PPC__) && defined(_AIX)
 260         ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.jmp_context.iar;
 261 #elif defined(__aarch64__) && defined(__linux__)
 262         ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.pc;
 263 #elif defined(__NetBSD__)
 264         ret.sigpc = _UC_MACHINE_PC(((ucontext_t*)(context)));
 265 #endif
 266
 267         if (ret.sigpc == 0) {
 268                 // Skip getSiginfo/sighandler/sigtrampgo/sigtramp/handler.
 269                 n = runtime_callers(5, &loc[0], 1, false);
 270                 if (n > 0) {
 271                         ret.sigpc = loc[0].pc;
 272                 }
 273         }
 274
 275         return ret;
 276 }
 277
 278 // Dump registers when crashing in a signal.
 279 // There is no portable way to write this,
 280 // so we just have some CPU/OS specific implementations.
 281
 282 void dumpregs(siginfo_t *, void *)
 283         __asm__(GOSYM_PREFIX "runtime.dumpregs");
 284
 285 void
 286 dumpregs(siginfo_t *info __attribute__((unused)), void *context __attribute__((unused)))
 287 {
 288 #if defined(__x86_64__) && defined(__linux__)
 289         {
 290                 mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
 291
 292                 runtime_printf("rax    %X\n", m->gregs[REG_RAX]);
 293                 runtime_printf("rbx    %X\n", m->gregs[REG_RBX]);
 294                 runtime_printf("rcx    %X\n", m->gregs[REG_RCX]);
 295                 runtime_printf("rdx    %X\n", m->gregs[REG_RDX]);
 296                 runtime_printf("rdi    %X\n", m->gregs[REG_RDI]);
 297                 runtime_printf("rsi    %X\n", m->gregs[REG_RSI]);
 298                 runtime_printf("rbp    %X\n", m->gregs[REG_RBP]);
 299                 runtime_printf("rsp    %X\n", m->gregs[REG_RSP]);
 300                 runtime_printf("r8     %X\n", m->gregs[REG_R8]);
 301                 runtime_printf("r9     %X\n", m->gregs[REG_R9]);
 302                 runtime_printf("r10    %X\n", m->gregs[REG_R10]);
 303                 runtime_printf("r11    %X\n", m->gregs[REG_R11]);
 304                 runtime_printf("r12    %X\n", m->gregs[REG_R12]);
 305                 runtime_printf("r13    %X\n", m->gregs[REG_R13]);
 306                 runtime_printf("r14    %X\n", m->gregs[REG_R14]);
 307                 runtime_printf("r15    %X\n", m->gregs[REG_R15]);
 308                 runtime_printf("rip    %X\n", m->gregs[REG_RIP]);
 309                 runtime_printf("rflags %X\n", m->gregs[REG_EFL]);
 310                 runtime_printf("cs     %X\n", m->gregs[REG_CSGSFS] & 0xffff);
 311                 runtime_printf("fs     %X\n", (m->gregs[REG_CSGSFS] >> 16) & 0xffff);
 312                 runtime_printf("gs     %X\n", (m->gregs[REG_CSGSFS] >> 32) & 0xffff);
 313           }
 314 #elif defined(__i386__) && defined(__linux__)
 315         {
 316                 mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
 317
 318                 runtime_printf("eax    %x\n", m->gregs[REG_EAX]);
 319                 runtime_printf("ebx    %x\n", m->gregs[REG_EBX]);
 320                 runtime_printf("ecx    %x\n", m->gregs[REG_ECX]);
 321                 runtime_printf("edx    %x\n", m->gregs[REG_EDX]);
 322                 runtime_printf("edi    %x\n", m->gregs[REG_EDI]);
 323                 runtime_printf("esi    %x\n", m->gregs[REG_ESI]);
 324                 runtime_printf("ebp    %x\n", m->gregs[REG_EBP]);
 325                 runtime_printf("esp    %x\n", m->gregs[REG_ESP]);
 326                 runtime_printf("eip    %x\n", m->gregs[REG_EIP]);
 327                 runtime_printf("eflags %x\n", m->gregs[REG_EFL]);
 328                 runtime_printf("cs     %x\n", m->gregs[REG_CS]);
 329                 runtime_printf("fs     %x\n", m->gregs[REG_FS]);
 330                 runtime_printf("gs     %x\n", m->gregs[REG_GS]);
 331           }
 332 #elif defined(__alpha__) && defined(__linux__)
 333         {
 334                 mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
 335
 336                 runtime_printf("v0  %X\n", m->sc_regs[0]);
 337                 runtime_printf("t0  %X\n", m->sc_regs[1]);
 338                 runtime_printf("t1  %X\n", m->sc_regs[2]);
 339                 runtime_printf("t2  %X\n", m->sc_regs[3]);
 340                 runtime_printf("t3  %X\n", m->sc_regs[4]);
 341                 runtime_printf("t4  %X\n", m->sc_regs[5]);
 342                 runtime_printf("t5  %X\n", m->sc_regs[6]);
 343                 runtime_printf("t6  %X\n", m->sc_regs[7]);
 344                 runtime_printf("t7  %X\n", m->sc_regs[8]);
 345                 runtime_printf("s0  %X\n", m->sc_regs[9]);
 346                 runtime_printf("s1  %X\n", m->sc_regs[10]);
 347                 runtime_printf("s2  %X\n", m->sc_regs[11]);
 348                 runtime_printf("s3  %X\n", m->sc_regs[12]);
 349                 runtime_printf("s4  %X\n", m->sc_regs[13]);
 350                 runtime_printf("s5  %X\n", m->sc_regs[14]);
 351                 runtime_printf("fp  %X\n", m->sc_regs[15]);
 352                 runtime_printf("a0  %X\n", m->sc_regs[16]);
 353                 runtime_printf("a1  %X\n", m->sc_regs[17]);
 354                 runtime_printf("a2  %X\n", m->sc_regs[18]);
 355                 runtime_printf("a3  %X\n", m->sc_regs[19]);
 356                 runtime_printf("a4  %X\n", m->sc_regs[20]);
 357                 runtime_printf("a5  %X\n", m->sc_regs[21]);
 358                 runtime_printf("t8  %X\n", m->sc_regs[22]);
 359                 runtime_printf("t9  %X\n", m->sc_regs[23]);
 360                 runtime_printf("t10 %X\n", m->sc_regs[24]);
 361                 runtime_printf("t11 %X\n", m->sc_regs[25]);
 362                 runtime_printf("ra  %X\n", m->sc_regs[26]);
 363                 runtime_printf("t12 %X\n", m->sc_regs[27]);
 364                 runtime_printf("at  %X\n", m->sc_regs[28]);
 365                 runtime_printf("gp  %X\n", m->sc_regs[29]);
 366                 runtime_printf("sp  %X\n", m->sc_regs[30]);
 367                 runtime_printf("pc  %X\n", m->sc_pc);
 368           }
 369 #elif defined(__PPC__) && defined(__linux__)
 370           {
 371                 int i;
 372
 373 # if defined(__PPC64__)
 374                 mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
 375
 376                 for (i = 0; i < 32; i++)
 377                         runtime_printf("r%d %X\n", i, m->gp_regs[i]);
 378                 runtime_printf("pc  %X\n", m->gp_regs[32]);
 379                 runtime_printf("msr %X\n", m->gp_regs[33]);
 380                 runtime_printf("cr  %X\n", m->gp_regs[38]);
 381                 runtime_printf("lr  %X\n", m->gp_regs[36]);
 382                 runtime_printf("ctr %X\n", m->gp_regs[35]);
 383                 runtime_printf("xer %X\n", m->gp_regs[37]);
 384 # else
 385 #  if defined(__GLIBC__)
 386                 mcontext_t *m = ((ucontext_t*)(context))->uc_mcontext.uc_regs;
 387 #  else
 388                 mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
 389 #  endif
 390
 391                 for (i = 0; i < 32; i++)
 392                         runtime_printf("r%d %x\n", i, m->gregs[i]);
 393                 runtime_printf("pc  %x\n", m->gregs[32]);
 394                 runtime_printf("msr %x\n", m->gregs[33]);
 395                 runtime_printf("cr  %x\n", m->gregs[38]);
 396                 runtime_printf("lr  %x\n", m->gregs[36]);
 397                 runtime_printf("ctr %x\n", m->gregs[35]);
 398                 runtime_printf("xer %x\n", m->gregs[37]);
 399 # endif
 400           }
 401 #elif defined(__PPC__) && defined(_AIX)
 402           {
 403                 mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
 404                 int i;
 405
 406                 for (i = 0; i < 32; i++)
 407                         runtime_printf("r%d %p\n", i, m->jmp_context.gpr[i]);
 408                 runtime_printf("pc  %p\n", m->jmp_context.iar);
 409                 runtime_printf("msr %p\n", m->jmp_context.msr);
 410                 runtime_printf("cr  %x\n", m->jmp_context.cr);
 411                 runtime_printf("lr  %p\n", m->jmp_context.lr);
 412                 runtime_printf("ctr %p\n", m->jmp_context.ctr);
 413                 runtime_printf("xer %x\n", m->jmp_context.xer);
 414           }
 415 #elif defined(__aarch64__) && defined(__linux__)
 416           {
 417                 mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext;
 418                 int i;
 419
 420                 for (i = 0; i < 31; i++)
 421                         runtime_printf("x%d    %X\n", i, m->regs[i]);
 422                 runtime_printf("sp     %X\n", m->sp);
 423                 runtime_printf("pc     %X\n", m->pc);
 424                 runtime_printf("pstate %X\n", m->pstate);
 425           }
 426 #endif
 427 }