lib/sigsegv.c

   1 /* Page fault handling library.
   2    Copyright (C) 1993-2021 Free Software Foundation, Inc.
   3    Copyright (C) 2018  Nylon Chen <nylon7@andestech.com>
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  17
  18 /* Written by Bruno Haible and Nylon Chen.  */
  19
  20 #include <config.h>
  21
  22 /* Specification.  */
  23 #include "sigsegv.h"
  24
  25 #include <errno.h>
  26 #include <stdio.h> /* declares perror */
  27 #include <stdint.h> /* defines uintptr_t */
  28 #include <stdlib.h>
  29 #include <signal.h>
  30 #if HAVE_GETRLIMIT
  31 # include <sys/resource.h> /* declares struct rlimit */
  32 #endif
  33
  34 #ifdef __OpenBSD__
  35 # include <sys/param.h> /* defines macro OpenBSD */
  36 #endif
  37
  38
  39 /* Version number.  */
  40 int libsigsegv_version = LIBSIGSEGV_VERSION;
  41
  42
  43 /* ======================= Fault handler information ======================= */
  44
  45 /* Define:
  46
  47      SIGSEGV_FAULT_HANDLER_ARGLIST
  48           is the argument list for the actual fault handler.
  49
  50    and if available (optional):
  51
  52      SIGSEGV_FAULT_ADDRESS
  53           is a macro for fetching the fault address.
  54
  55      SIGSEGV_FAULT_CONTEXT
  56           is a macro giving a pointer to the entire fault context (i.e.
  57           the register set etc.).
  58
  59      SIGSEGV_FAULT_STACKPOINTER
  60           is a macro for fetching the stackpointer at the moment the fault
  61           occurred.
  62  */
  63
  64 #if defined __linux__ || defined __ANDROID__ /* Linux */
  65
  66 # define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
  67 # define SIGSEGV_FAULT_ADDRESS  sip->si_addr
  68 # define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
  69 # define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
  70
  71 # if defined __alpha__
  72
  73 /* See glibc/sysdeps/unix/sysv/linux/alpha/sys/ucontext.h
  74    and the definition of GET_STACK in
  75    glibc/sysdeps/unix/sysv/linux/alpha/sigcontextinfo.h.
  76    Note that the 'mcontext_t' defined in
  77    glibc/sysdeps/unix/sysv/linux/alpha/sys/ucontext.h
  78    and the 'struct sigcontext' defined in <asm/sigcontext.h>
  79    are actually the same.  */
  80
  81 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.sc_regs[30]
  82
  83 # elif defined __arm64__ /* 64-bit */
  84
  85 /* See glibc/sysdeps/unix/sysv/linux/aarch64/sys/ucontext.h.
  86    Note that the 'mcontext_t' defined in
  87    glibc/sysdeps/unix/sysv/linux/aarch64/sys/ucontext.h
  88    and the 'struct sigcontext' defined in <asm/sigcontext.h>
  89    are actually the same.  */
  90
  91 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.sp
  92
  93 # elif defined __arm__ || defined __armhf__ /* 32-bit */
  94
  95 /* See glibc/sysdeps/unix/sysv/linux/arm/sys/ucontext.h
  96    and the definition of GET_STACK in
  97    glibc/sysdeps/unix/sysv/linux/arm/sigcontextinfo.h.
  98    Note that the 'mcontext_t' defined in
  99    glibc/sysdeps/unix/sysv/linux/arm/sys/ucontext.h
 100    and the 'struct sigcontext' defined in <asm/sigcontext.h>
 101    are actually the same.  */
 102
 103 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.arm_sp
 104
 105 # elif defined __cris__
 106
 107 /* See glibc-ports/sysdeps/unix/sysv/linux/cris/sys/ucontext.h.
 108    Note that the 'mcontext_t' defined in
 109    glibc-ports/sysdeps/unix/sysv/linux/cris/sys/ucontext.h
 110    and the 'struct sigcontext' defined in <asm/sigcontext.h>
 111    are actually the same.  */
 112
 113 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.usp
 114
 115 # elif defined __hppa__
 116
 117 /* See glibc/sysdeps/unix/sysv/linux/hppa/sys/ucontext.h.
 118    Note that the 'mcontext_t' defined in
 119    glibc/sysdeps/unix/sysv/linux/hppa/sys/ucontext.h
 120    and the 'struct sigcontext' defined in <asm/sigcontext.h>
 121    are actually the same.  */
 122
 123 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.sc_gr[30]
 124
 125 # elif defined __x86_64__ /* 64 bit registers */
 126
 127 /* See glibc/sysdeps/unix/sysv/linux/x86/sys/ucontext.h
 128    and the definition of GET_STACK in
 129    glibc/sysdeps/unix/sysv/linux/x86_64/sigcontextinfo.h.
 130    Note that the 'mcontext_t' defined in
 131    glibc/sysdeps/unix/sysv/linux/x86/sys/ucontext.h
 132    and the 'struct sigcontext' defined in
 133    glibc/sysdeps/unix/sysv/linux/x86/bits/sigcontext.h
 134    (see also <asm/sigcontext.h>)
 135    are effectively the same.  */
 136
 137 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[REG_RSP]
 138
 139 # elif defined __i386__ /* 32 bit registers */
 140
 141 /* See glibc/sysdeps/unix/sysv/linux/x86/sys/ucontext.h
 142    and the definition of GET_STACK in
 143    glibc/sysdeps/unix/sysv/linux/i386/sigcontextinfo.h.
 144    Note that the 'mcontext_t' defined in
 145    glibc/sysdeps/unix/sysv/linux/x86/sys/ucontext.h
 146    and the 'struct sigcontext_ia32' defined in <asm/sigcontext32.h>
 147    are effectively the same.  */
 148
 149 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[REG_ESP]
 150                      /* same value as ((ucontext_t *) ucp)->uc_mcontext.gregs[REG_UESP] */
 151
 152 # elif defined __ia64__
 153
 154 /* See glibc/sysdeps/unix/sysv/linux/ia64/sys/ucontext.h.
 155    Note that the 'mcontext_t' defined in
 156    glibc/sysdeps/unix/sysv/linux/ia64/sys/ucontext.h
 157    and the 'struct sigcontext' defined in
 158    glibc/sysdeps/unix/sysv/linux/ia64/bits/sigcontext.h
 159    (see also <asm/sigcontext.h>)
 160    are actually the same.  */
 161
 162 /* IA-64 has two stack pointers, one that grows down, called $r12, and one
 163    that grows up, called $bsp/$bspstore.  */
 164 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.sc_gr[12]
 165
 166 /* It would be better to access $bspstore instead of $bsp but I don't know
 167    where to find it in 'struct sigcontext'.  Anyway, it doesn't matter
 168    because $bsp and $bspstore never differ by more than ca. 1 KB.  */
 169 #  define SIGSEGV_FAULT_BSP_POINTER  ((ucontext_t *) ucp)->uc_mcontext.sc_ar_bsp
 170
 171 # elif defined __m68k__
 172
 173 /* See glibc/sysdeps/unix/sysv/linux/m68k/sys/ucontext.h
 174    and the definition of GET_STACK in
 175    glibc/sysdeps/unix/sysv/linux/m68k/sigcontextinfo.h.
 176    Note that the 'mcontext_t' defined in
 177    glibc/sysdeps/unix/sysv/linux/m68k/sys/ucontext.h
 178    and the 'struct sigcontext' defined in <asm/sigcontext.h>
 179    are quite different types.  */
 180
 181 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[R_SP]
 182
 183 # elif defined __mips__ || defined __mipsn32__ || defined __mips64__
 184
 185 /* See glibc/sysdeps/unix/sysv/linux/mips/sys/ucontext.h
 186    and the definition of GET_STACK in
 187    glibc/sysdeps/unix/sysv/linux/mips/sigcontextinfo.h.
 188    Note that the 'mcontext_t' defined in
 189    glibc/sysdeps/unix/sysv/linux/mips/sys/ucontext.h
 190    and the 'struct sigcontext' defined in
 191    glibc/sysdeps/unix/sysv/linux/mips/bits/sigcontext.h
 192    (see also <asm/sigcontext.h>)
 193    are effectively the same.  */
 194
 195 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[29]
 196
 197 # elif defined __nds32__
 198
 199 /* See glibc/sysdeps/unix/sysv/linux/nds32/sys/ucontext.h
 200    and the definition of GET_STACK in
 201    glibc/sysdeps/unix/sysv/linux/nds32/sigcontextinfo.h.
 202    Both are found in <https://patches-gcc.linaro.org/cover/4409/> part 08/11
 203    <https://sourceware.org/ml/libc-alpha/2018-05/msg00125.html>.  */
 204
 205 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.nds32_sp
 206
 207 # elif defined __powerpc__ || defined __powerpc64__ || defined __powerpc64_elfv2__
 208
 209 /* See glibc/sysdeps/unix/sysv/linux/powerpc/sys/ucontext.h
 210    and the definition of GET_STACK in
 211    glibc/sysdeps/unix/sysv/linux/powerpc/sigcontextinfo.h.
 212    Note that the 'mcontext_t' defined in
 213    glibc/sysdeps/unix/sysv/linux/powerpc/sys/ucontext.h,
 214    the 'struct sigcontext' defined in <asm/sigcontext.h>,
 215    and the 'struct pt_regs' defined in <asm/ptrace.h>
 216    are quite different types.  */
 217
 218 #  if defined __powerpc64__ || defined __powerpc64_elfv2__ /* 64-bit */
 219 #   define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gp_regs[1]
 220 #  else /* 32-bit */
 221 /* both should be equivalent */
 222 #   if 0
 223 #    define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.regs->gpr[1]
 224 #   else
 225 #    define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.uc_regs->gregs[1]
 226 #   endif
 227 #  endif
 228
 229 # elif defined __riscv32__ || __riscv64__
 230
 231 /* See glibc/sysdeps/unix/sysv/linux/riscv/sys/ucontext.h
 232    and the definition of GET_STACK in
 233    glibc/sysdeps/unix/sysv/linux/riscv/sigcontextinfo.h.
 234    Note that the 'mcontext_t' defined in
 235    glibc/sysdeps/unix/sysv/linux/riscv/sys/ucontext.h
 236    and the 'struct sigcontext' defined in
 237    glibc/sysdeps/unix/sysv/linux/riscv/bits/sigcontext.h
 238    start with the same block of 32 general-purpose registers.  */
 239
 240 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.__gregs[REG_SP]
 241
 242 # elif defined __s390__ || defined __s390x__
 243
 244 /* See glibc/sysdeps/unix/sysv/linux/s390/sys/ucontext.h
 245    and the definition of GET_STACK in
 246    glibc/sysdeps/unix/sysv/linux/s390/sigcontextinfo.h.
 247    Note that the 'mcontext_t' defined in
 248    glibc/sysdeps/unix/sysv/linux/s390/sys/ucontext.h
 249    and the '_sigregs' type, indirect part of 'struct sigcontext', defined
 250    in <asm/sigcontext.h>, are effectively the same.  */
 251
 252 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[15]
 253
 254 # elif defined __sh__
 255
 256 /* See glibc/sysdeps/unix/sysv/linux/sh/sys/ucontext.h
 257    and the definition of GET_STACK in
 258    glibc/sysdeps/unix/sysv/linux/sh/sigcontextinfo.h.
 259    Note that the 'mcontext_t' defined in
 260    glibc/sysdeps/unix/sysv/linux/sh/sys/ucontext.h
 261    and the 'struct sigcontext' defined in <asm/sigcontext.h>
 262    are effectively the same.  */
 263
 264 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[15]
 265
 266 # elif defined __sparc__ || defined __sparc64__
 267
 268 /* See glibc/sysdeps/unix/sysv/linux/sparc/sys/ucontext.h
 269    and the definition of GET_STACK in
 270    glibc/sysdeps/unix/sysv/linux/sparc/{sparc32,sparc64}/sigcontextinfo.h.
 271    Note that the 'mcontext_t' defined in
 272    glibc/sysdeps/unix/sysv/linux/sparc/sys/ucontext.h
 273    and the 'struct sigcontext' defined in
 274    glibc/sysdeps/unix/sysv/linux/sparc/bits/sigcontext.h
 275    (see also <asm/sigcontext.h>)
 276    are quite different types.  */
 277
 278 #  if defined __sparc64__/* 64-bit */
 279 /* From linux-4.8.1/arch/sparc/kernel/signal_64.c, function setup_rt_frame, we
 280    see that ucp is not an 'ucontext_t *' but rather a 'struct sigcontext *'
 281    that happens to have the same value as sip (which is possible because a
 282    'struct sigcontext' starts with 128 bytes room for the siginfo_t).  */
 283 #   define SIGSEGV_FAULT_STACKPOINTER  (((struct sigcontext *) ucp)->sigc_regs.u_regs[14] + 2047)
 284 #  else /* 32-bit */
 285 /* From linux-4.8.1/arch/sparc/kernel/signal_32.c, function setup_rt_frame,
 286    and linux-4.8.1/arch/sparc/kernel/signal32.c, function setup_rt_frame32, we
 287    see that ucp is a 'struct pt_regs *' or 'struct pt_regs32 *', respectively.
 288    In userland, this is a 'struct sigcontext *'.  */
 289 #   define SIGSEGV_FAULT_STACKPOINTER  ((struct sigcontext *) ucp)->si_regs.u_regs[14]
 290 #  endif
 291
 292 /* The sip->si_addr field is correct for a normal fault, but unusable in case
 293    of a stack overflow. What I observe (when running
 294    tests/test-sigsegv-catch-stackoverflow1, with a printf right at the beginning
 295    of sigsegv_handler) is that sip->si_addr is near 0:
 296      - in 64-bit mode: sip->si_addr = 0x000000000000030F, and gdb shows me that
 297        the fault occurs in an instruction 'stx %o3,[%fp+0x30f]' and %fp is 0.
 298        In fact, all registers %l0..%l7 and %i0..%i7 are 0.
 299      - in 32-bit mode: sip->si_addr = 0xFFFFFA64, and gdb shows me that
 300        the fault occurs in an instruction 'st %g2,[%fp-1436]' and %fp is 0.
 301        In fact, all registers %l0..%l7 and %i0..%i7 are 0.
 302    Apparently when the stack overflow occurred, some trap has tried to move the
 303    contents of the registers %l0..%l7 and %i0..%i7 (a "window" in SPARC
 304    terminology) to the stack, did not succeed in doing this, replaced all these
 305    register values with 0, and resumed execution at the fault location. This
 306    time, due to %fp = 0, a different fault was triggered. Now it is impossible
 307    to determine the real (previous) fault address because, even if know the
 308    faulting instruction, the previous register values have been lost.  */
 309 #  define BOGUS_FAULT_ADDRESS_UPON_STACK_OVERFLOW
 310
 311 # else
 312
 313 /* When adding support for other CPUs here:  */
 314
 315 /* For SIGSEGV_FAULT_HANDLER_ARGLIST, see the definition of SIGCONTEXT in
 316    glibc/sysdeps/unix/sysv/linux/<cpu>/sigcontextinfo.h.  */
 317
 318 /* For SIGSEGV_FAULT_STACKPOINTER, see the definition of GET_STACK in
 319    glibc/sysdeps/unix/sysv/linux/<cpu>/sigcontextinfo.h.  */
 320
 321 # endif
 322
 323 #endif
 324
 325 #if defined __GNU__ /* Hurd */
 326
 327 # define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, int code, struct sigcontext *scp
 328 # define SIGSEGV_FAULT_ADDRESS  (unsigned long) code
 329 # define SIGSEGV_FAULT_CONTEXT  scp
 330
 331 # if defined __i386__
 332
 333 /* scp points to a 'struct sigcontext' (defined in
 334    glibc/sysdeps/mach/hurd/i386/bits/sigcontext.h).
 335    The registers of this struct get pushed on the stack through
 336    gnumach/i386/i386/locore.S:trapall.  */
 337 /* Both sc_esp and sc_uesp appear to have the same value.
 338    It appears more reliable to use sc_uesp because it is labelled as
 339    "old esp, if trapped from user".  */
 340 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_uesp
 341
 342 # endif
 343
 344 #endif
 345
 346 #if defined __FreeBSD_kernel__ || defined __FreeBSD__ || defined __DragonFly__ /* GNU/kFreeBSD, FreeBSD */
 347
 348 # if defined __arm__ || defined __armhf__ || defined __arm64__
 349
 350 #  define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
 351 #  define SIGSEGV_FAULT_ADDRESS  sip->si_addr
 352 #  define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
 353
 354 #  if defined __arm64__ /* 64-bit */
 355
 356 /* See sys/arm64/include/ucontext.h.  */
 357
 358 #   define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.mc_gpregs.gp_sp
 359
 360 #  elif defined __arm__ || defined __armhf__ /* 32-bit */
 361
 362 /* See sys/arm/include/ucontext.h.  */
 363
 364 #   define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.__gregs[_REG_SP]
 365
 366 #  endif
 367
 368 # else
 369
 370 /* On FreeBSD 12, both of these approaches work.  On FreeBSD derivatives, the
 371    first one has more chances to work.  */
 372 #  if 1
 373 /* Use signal handlers without SA_SIGINFO.  */
 374
 375 #   define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, int code, struct sigcontext *scp, void *addr
 376 #   define SIGSEGV_FAULT_ADDRESS  addr
 377 #   define SIGSEGV_FAULT_CONTEXT  scp
 378
 379 /* See sys/x86/include/signal.h.  */
 380
 381 #   if defined __x86_64__
 382 /* 64 bit registers */
 383
 384 #    define SIGSEGV_FAULT_STACKPOINTER  scp->sc_rsp
 385
 386 #   elif defined __i386__
 387 /* 32 bit registers */
 388
 389 #    define SIGSEGV_FAULT_STACKPOINTER  scp->sc_esp
 390
 391 #   endif
 392
 393 #  else
 394 /* Use signal handlers with SA_SIGINFO.  */
 395
 396 #   define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *scp
 397 #   define SIGSEGV_FAULT_ADDRESS  sip->si_addr
 398 #   define SIGSEGV_FAULT_CONTEXT  ((struct sigcontext *) scp)
 399 #   define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
 400
 401 /* See sys/x86/include/signal.h.  */
 402
 403 #   if defined __x86_64__
 404 /* 64 bit registers */
 405
 406 #    define SIGSEGV_FAULT_STACKPOINTER  ((struct sigcontext *) scp)->sc_rsp
 407
 408 #   elif defined __i386__
 409 /* 32 bit registers */
 410
 411 #    define SIGSEGV_FAULT_STACKPOINTER  ((struct sigcontext *) scp)->sc_esp
 412
 413 #   endif
 414
 415 #  endif
 416
 417 # endif
 418
 419 #endif
 420
 421 #if defined __NetBSD__ /* NetBSD */
 422
 423 # define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
 424 # define SIGSEGV_FAULT_ADDRESS  sip->si_addr
 425 # define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
 426 # define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
 427
 428 /* _UC_MACHINE_SP is a platform independent macro.
 429    Defined in <machine/mcontext.h>, see
 430      http://cvsweb.netbsd.org/bsdweb.cgi/src/sys/arch/$arch/include/mcontext.h
 431    Supported on alpha, amd64, i386, ia64, m68k, mips, powerpc, sparc since
 432    NetBSD 2.0.
 433    On i386, _UC_MACHINE_SP is the same as ->uc_mcontext.__gregs[_REG_UESP],
 434    and apparently the same value as       ->uc_mcontext.__gregs[_REG_ESP]. */
 435 # ifdef _UC_MACHINE_SP
 436 #  define SIGSEGV_FAULT_STACKPOINTER  _UC_MACHINE_SP ((ucontext_t *) ucp)
 437 # endif
 438
 439 #endif
 440
 441 #if defined __OpenBSD__ /* OpenBSD */
 442
 443 # define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, struct sigcontext *scp
 444 # define SIGSEGV_FAULT_ADDRESS  sip->si_addr
 445 # define SIGSEGV_FAULT_CONTEXT  scp
 446 # define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
 447
 448 # if defined __alpha__
 449
 450 /* See the definition of 'struct sigcontext' in
 451    openbsd-src/sys/arch/alpha/include/signal.h.  */
 452
 453 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs[30]
 454
 455 # elif defined __arm__ || defined __armhf__
 456
 457 /* See the definition of 'struct sigcontext' in
 458    openbsd-src/sys/arch/arm/include/signal.h.  */
 459
 460 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_usr_sp
 461
 462 # elif defined __hppa__ || defined __hppa64__
 463
 464 /* See the definition of 'struct sigcontext' in
 465    openbsd-src/sys/arch/hppa/include/signal.h
 466    and
 467    openbsd-src/sys/arch/hppa64/include/signal.h.  */
 468
 469 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs[30]
 470
 471 # elif defined __x86_64__
 472 /* 64 bit registers */
 473
 474 /* See the definition of 'struct sigcontext' in
 475    openbsd-src/sys/arch/amd64/include/signal.h.  */
 476
 477 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_rsp
 478
 479 # elif defined __i386__
 480 /* 32 bit registers */
 481
 482 /* See the definition of 'struct sigcontext' in
 483    openbsd-src/sys/arch/i386/include/signal.h.  */
 484
 485 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_esp
 486
 487 # elif defined __m68k__
 488
 489 /* See the definition of 'struct sigcontext' in
 490    openbsd-src/sys/arch/m68k/include/signal.h.  */
 491
 492 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_sp
 493
 494 # elif defined __m88k__
 495
 496 /* See the definition of 'struct sigcontext' in
 497    openbsd-src/sys/arch/m88k/include/signal.h
 498    and the definition of 'struct reg' in
 499    openbsd-src/sys/arch/m88k/include/reg.h.  */
 500
 501 #  if OpenBSD >= 201211 /* OpenBSD version >= 5.2 */
 502 #   define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs[31]
 503 #  else
 504 #   define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs.r[31]
 505 #  endif
 506
 507 # elif defined __mips__ || defined __mipsn32__ || defined __mips64__
 508
 509 /* See the definition of 'struct sigcontext' in
 510    openbsd-src/sys/arch/mips64/include/signal.h.  */
 511
 512 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs[29]
 513
 514 # elif defined __powerpc__ || defined __powerpc64__
 515
 516 /* See the definition of 'struct sigcontext' and 'struct trapframe' in
 517    openbsd-src/sys/arch/powerpc/include/signal.h.  */
 518
 519 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_frame.fixreg[1]
 520
 521 # elif defined __sh__
 522
 523 /* See the definition of 'struct sigcontext' in
 524    openbsd-src/sys/arch/sh/include/signal.h
 525    and the definition of 'struct reg' in
 526    openbsd-src/sys/arch/sh/include/reg.h.  */
 527
 528 #  if OpenBSD >= 201211 /* OpenBSD version >= 5.2 */
 529 #   define SIGSEGV_FAULT_STACKPOINTER  scp->sc_reg[20-15]
 530 #  else
 531 #   define SIGSEGV_FAULT_STACKPOINTER  scp->sc_reg.r_r15
 532 #  endif
 533
 534 # elif defined __sparc__ || defined __sparc64__
 535
 536 /* See the definition of 'struct sigcontext' in
 537    openbsd-src/sys/arch/sparc/include/signal.h
 538    and
 539    openbsd-src/sys/arch/sparc64/include/signal.h.  */
 540
 541 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_sp
 542
 543 # elif defined __vax__
 544
 545 /* See the definition of 'struct sigcontext' in
 546    openbsd-src/sys/arch/vax/include/signal.h.  */
 547
 548 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_sp
 549
 550 # endif
 551
 552 #endif
 553
 554 #if (defined __APPLE__ && defined __MACH__) /* macOS */
 555
 556 # define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
 557 # define SIGSEGV_FAULT_ADDRESS  sip->si_addr
 558 # define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
 559 # define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
 560
 561 # if defined __x86_64__
 562
 563 /* See the definitions of
 564      - 'ucontext_t' and 'struct __darwin_ucontext' in <sys/_types/_ucontext.h>,
 565      - 'struct __darwin_mcontext64' in <i386/_mcontext.h>, and
 566      - 'struct __darwin_x86_thread_state64' in <mach/i386/_structs.h>.  */
 567 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext->__ss.__rsp
 568
 569 # elif defined __i386__
 570
 571 /* See the definitions of
 572      - 'ucontext_t' and 'struct __darwin_ucontext' in <sys/_types/_ucontext.h>,
 573      - 'struct __darwin_mcontext32' in <i386/_mcontext.h>, and
 574      - 'struct __darwin_i386_thread_state' in <mach/i386/_structs.h>.  */
 575 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext->__ss.__esp
 576
 577 # elif defined __arm64__
 578
 579 /* See the definitions of
 580      - 'ucontext_t' and 'struct __darwin_ucontext' in <sys/_types/_ucontext.h>,
 581      - 'struct __darwin_mcontext64' in <arm/_mcontext.h>, and
 582      - 'struct __darwin_arm_thread_state64' in <mach/arm/_structs.h>.  */
 583 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext->__ss.__sp
 584
 585 # elif defined __powerpc__
 586
 587 /* See the definitions of
 588      - 'ucontext_t' and 'struct __darwin_ucontext' in <sys/_structs.h>,
 589      - 'struct __darwin_mcontext' in <ppc/_structs.h>, and
 590      - 'struct __darwin_ppc_thread_state' in <mach/ppc/_structs.h>.  */
 591 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext->__ss.__r1
 592
 593 # endif
 594
 595 #endif
 596
 597 #if defined _AIX /* AIX */
 598
 599 # define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
 600 # define SIGSEGV_FAULT_ADDRESS  sip->si_addr
 601 # define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
 602 # define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
 603
 604 # if defined __powerpc__ || defined __powerpc64__
 605 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.jmp_context.gpr[1]
 606 # endif
 607
 608 #endif
 609
 610 #if defined __sgi /* IRIX */
 611
 612 # define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, int code, struct sigcontext *scp
 613 # define SIGSEGV_FAULT_ADDRESS  (unsigned long) scp->sc_badvaddr
 614 # define SIGSEGV_FAULT_CONTEXT  scp
 615
 616 # if defined __mips__ || defined __mipsn32__ || defined __mips64__
 617 #  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs[29]
 618 # endif
 619
 620 #endif
 621
 622 #if defined __sun /* Solaris */
 623
 624 # define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
 625 # define SIGSEGV_FAULT_ADDRESS  sip->si_addr
 626 # define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
 627 # define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
 628
 629 # if defined __x86_64__
 630 /* 64 bit registers */
 631
 632 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[REG_RSP]
 633
 634 # elif defined __i386__
 635 /* 32 bit registers */
 636
 637 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[ESP]
 638
 639 # elif defined __sparc__ || defined __sparc64__
 640
 641 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[REG_O6]
 642
 643 #  if SOLARIS11
 644
 645 /* On Solaris 11.3/SPARC, both in 32-bit and 64-bit mode, when catching
 646    stack overflow, the fault address is correct the first time, but is zero
 647    or near zero the second time.
 648    'truss tests/test-sigsegv-catch-stackoverflow1' shows it:
 649
 650    In 32-bit mode:
 651
 652     Incurred fault #6, FLTBOUNDS  %pc = 0x000116E8
 653       siginfo: SIGSEGV SEGV_MAPERR addr=0xFFB00000
 654     Received signal #11, SIGSEGV [caught]
 655       siginfo: SIGSEGV SEGV_MAPERR addr=0xFFB00000
 656    then
 657     Incurred fault #6, FLTBOUNDS  %pc = 0x000116E8
 658       siginfo: SIGSEGV SEGV_MAPERR addr=0x00000008
 659     Received signal #11, SIGSEGV [caught]
 660       siginfo: SIGSEGV SEGV_MAPERR addr=0x00000008
 661
 662    In 64-bit mode:
 663
 664     Incurred fault #6, FLTBOUNDS  %pc = 0x100001C58
 665       siginfo: SIGSEGV SEGV_MAPERR addr=0xFFFFFFFF7FF00000
 666     Received signal #11, SIGSEGV [caught]
 667       siginfo: SIGSEGV SEGV_MAPERR addr=0xFFFFFFFF7FF00000
 668    then
 669     Incurred fault #6, FLTBOUNDS  %pc = 0x100001C58
 670       siginfo: SIGSEGV SEGV_MAPERR addr=0x00000000
 671     Received signal #11, SIGSEGV [caught]
 672       siginfo: SIGSEGV SEGV_MAPERR addr=0x00000000
 673  */
 674 #   define BOGUS_FAULT_ADDRESS_UPON_STACK_OVERFLOW
 675
 676 #  endif
 677
 678 # endif
 679
 680 #endif
 681
 682 #if defined __CYGWIN__ /* Cygwin */
 683
 684 # define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
 685 # define SIGSEGV_FAULT_ADDRESS  sip->si_addr
 686 # define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
 687 # define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
 688
 689 /* See the definition of 'ucontext_t' in <sys/ucontext.h> and
 690    of 'struct __mcontext' in <cygwin/signal.h>.  */
 691 # if defined __x86_64__
 692 /* 64 bit registers */
 693 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.rsp
 694 # elif defined __i386__
 695 /* 32 bit registers */
 696 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.esp
 697 # endif
 698
 699 #endif
 700
 701 #if defined __HAIKU__ /* Haiku */
 702
 703 # define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
 704 # define SIGSEGV_FAULT_ADDRESS  sip->si_addr
 705 # define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
 706 # define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
 707
 708 # if defined __x86_64__
 709 /* 64 bit registers */
 710
 711 /* See the definition of 'ucontext_t' in <signal.h> and
 712    of 'struct vregs' in <arch/x86_64/signal.h>.  */
 713
 714 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.rsp
 715
 716 # elif defined __i386__
 717 /* 32 bit registers */
 718
 719 /* See the definition of 'ucontext_t' in <signal.h> and
 720    of 'struct vregs' in <arch/x86/signal.h>.  */
 721
 722 #  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.esp
 723
 724 # endif
 725
 726 #endif
 727
 728 /* ========================================================================== */
 729
 730 /* List of signals that are sent when an invalid virtual memory address
 731    is accessed, or when the stack overflows.  */
 732 #if defined __GNU__ \
 733     || defined __FreeBSD_kernel__ || defined __FreeBSD__ || defined __DragonFly__ \
 734     || defined __NetBSD__ || defined __OpenBSD__ \
 735     || (defined __APPLE__ && defined __MACH__)
 736 # define SIGSEGV_FOR_ALL_SIGNALS(var,body) \
 737     { int var; var = SIGSEGV; { body } var = SIGBUS; { body } }
 738 #else
 739 # define SIGSEGV_FOR_ALL_SIGNALS(var,body) \
 740     { int var; var = SIGSEGV; { body } }
 741 #endif
 742
 743 /* ========================================================================== */
 744
 745 /* Determine the virtual memory area of a given address.  */
 746 #include "stackvma.h"
 747
 748 /* ========================================================================== */
 749
 750 /* On the average Unix platform, we define
 751
 752    HAVE_SIGSEGV_RECOVERY
 753        if there is a fault-*.h include file which defines
 754        SIGSEGV_FAULT_HANDLER_ARGLIST and SIGSEGV_FAULT_ADDRESS.
 755
 756    HAVE_STACK_OVERFLOW_RECOVERY
 757        if HAVE_SIGALTSTACK is set and
 758        at least two of the following are true:
 759        A) There is a fault-*.h include file which defines
 760           SIGSEGV_FAULT_HANDLER_ARGLIST and SIGSEGV_FAULT_ADDRESS.
 761        B) There is a fault-*.h include file which defines
 762           SIGSEGV_FAULT_HANDLER_ARGLIST and SIGSEGV_FAULT_STACKPOINTER.
 763        C) There is a stackvma-*.c, other than stackvma-none.c, which
 764           defines sigsegv_get_vma.
 765
 766    Why? Obviously, to catch stack overflow, we need an alternate signal
 767    stack; this requires kernel support. But we also need to distinguish
 768    (with a reasonable confidence) a stack overflow from a regular SIGSEGV.
 769    If we have A) and B), we use the
 770      Heuristic AB: If the fault address is near the stack pointer, it's a
 771      stack overflow.
 772    If we have A) and C), we use the
 773      Heuristic AC: If the fault address is near and beyond the bottom of
 774      the stack's virtual memory area, it's a stack overflow.
 775    If we have B) and C), we use the
 776      Heuristic BC: If the stack pointer is near the bottom of the stack's
 777      virtual memory area, it's a stack overflow.
 778      This heuristic comes in two flavours: On OSes which let the stack's
 779      VMA grow continuously, we determine the bottom by use of getrlimit().
 780      On OSes which preallocate the stack's VMA with its maximum size
 781      (like BeOS), we use the stack's VMA directly.
 782  */
 783
 784 #if HAVE_SIGSEGV_RECOVERY \
 785      && !(defined SIGSEGV_FAULT_HANDLER_ARGLIST && defined SIGSEGV_FAULT_ADDRESS)
 786 # error "You need to define SIGSEGV_FAULT_HANDLER_ARGLIST and SIGSEGV_FAULT_ADDRESS before you can define HAVE_SIGSEGV_RECOVERY."
 787 #endif
 788 #if !HAVE_SIGSEGV_RECOVERY \
 789     && (defined SIGSEGV_FAULT_HANDLER_ARGLIST && defined SIGSEGV_FAULT_ADDRESS) \
 790     && !(defined __FreeBSD__ && (defined __sparc__ || defined __sparc64__))
 791 # if __GNUC__ || (__clang_major__ >= 4)
 792 #  warning "You can define HAVE_SIGSEGV_RECOVERY on this platform."
 793 # else
 794 #  error "You can define HAVE_SIGSEGV_RECOVERY on this platform."
 795 # endif
 796 #endif
 797
 798 #if HAVE_STACK_OVERFLOW_RECOVERY \
 799     && !(defined SIGSEGV_FAULT_ADDRESS + defined SIGSEGV_FAULT_STACKPOINTER + HAVE_STACKVMA >= 2)
 800 # error "You need to define two of SIGSEGV_FAULT_ADDRESS, SIGSEGV_FAULT_STACKPOINTER, HAVE_STACKVMA, before you can define HAVE_STACK_OVERFLOW_RECOVERY."
 801 #endif
 802 #if !HAVE_STACK_OVERFLOW_RECOVERY \
 803     && (defined SIGSEGV_FAULT_ADDRESS + defined SIGSEGV_FAULT_STACKPOINTER + HAVE_STACKVMA >= 2) \
 804     && !(defined __FreeBSD__ && (defined __sparc__ || defined __sparc64__)) \
 805     && !(defined __NetBSD__ && (defined __sparc__ || defined __sparc64__))
 806 # if __GNUC__ || (__clang_major__ >= 4)
 807 #  warning "You can define HAVE_STACK_OVERFLOW_RECOVERY on this platform."
 808 # else
 809 #  error "You can define HAVE_STACK_OVERFLOW_RECOVERY on this platform."
 810 # endif
 811 #endif
 812
 813 /* ========================================================================== */
 814
 815 #if HAVE_STACK_OVERFLOW_RECOVERY
 816
 817 /* ======= Leaving a signal handler executing on the alternate stack ======= */
 818
 819 /* Platform dependent:
 820    Leaving a signal handler executing on the alternate stack.  */
 821 static void sigsegv_reset_onstack_flag (void);
 822
 823 /* -------------------------- leave-sigaltstack.c -------------------------- */
 824
 825 # if defined __GNU__ \
 826      || defined __FreeBSD_kernel__ || defined __FreeBSD__ || defined __DragonFly__ \
 827      || defined __NetBSD__ || defined __OpenBSD__
 828
 829 static void
 830 sigsegv_reset_onstack_flag (void)
 831 {
 832   stack_t ss;
 833
 834   if (sigaltstack (NULL, &ss) >= 0)
 835     {
 836       ss.ss_flags &= ~SS_ONSTACK;
 837       sigaltstack (&ss, NULL);
 838     }
 839 }
 840
 841 /* --------------------------- leave-setcontext.c --------------------------- */
 842
 843 # elif defined __sgi || defined __sun /* IRIX, Solaris */
 844
 845 #  include <ucontext.h>
 846
 847 static void
 848 sigsegv_reset_onstack_flag (void)
 849 {
 850   ucontext_t uc;
 851
 852   if (getcontext (&uc) >= 0)
 853     /* getcontext returns twice.  We are interested in the returned context
 854        only the first time, i.e. when the SS_ONSTACK bit is set.  */
 855     if (uc.uc_stack.ss_flags & SS_ONSTACK)
 856       {
 857         uc.uc_stack.ss_flags &= ~SS_ONSTACK;
 858         /* Note that setcontext() does not refill uc.  Therefore if
 859            setcontext() keeps SS_ONSTACK set in the kernel, either
 860            setcontext() will return -1 or getcontext() will return a
 861            second time, with the SS_ONSTACK bit being cleared.  */
 862         setcontext (&uc);
 863       }
 864 }
 865
 866 /* ------------------------------ leave-nop.c ------------------------------ */
 867
 868 # else
 869
 870 static void
 871 sigsegv_reset_onstack_flag (void)
 872 {
 873   /* Nothing to do. sigaltstack() simply looks at the stack pointer,
 874      therefore SS_ONSTACK is not sticky.  */
 875 }
 876
 877 # endif
 878
 879 /* ========================================================================== */
 880
 881 # if HAVE_STACKVMA
 882
 883 /* Address of the last byte belonging to the stack vma.  */
 884 static uintptr_t stack_top = 0;
 885
 886 /* Needs to be called once only.  */
 887 static void
 888 remember_stack_top (void *some_variable_on_stack)
 889 {
 890   struct vma_struct vma;
 891
 892   if (sigsegv_get_vma ((uintptr_t) some_variable_on_stack, &vma) >= 0)
 893     stack_top = vma.end - 1;
 894 }
 895
 896 # endif /* HAVE_STACKVMA */
 897
 898 static stackoverflow_handler_t stk_user_handler = (stackoverflow_handler_t)NULL;
 899 static uintptr_t stk_extra_stack;
 900 static size_t stk_extra_stack_size;
 901
 902 #endif /* HAVE_STACK_OVERFLOW_RECOVERY */
 903
 904 #if HAVE_SIGSEGV_RECOVERY
 905
 906 /* User's SIGSEGV handler.  */
 907 static sigsegv_handler_t user_handler = (sigsegv_handler_t)NULL;
 908
 909 #endif /* HAVE_SIGSEGV_RECOVERY */
 910
 911
 912 /* Our SIGSEGV handler, with OS dependent argument list.  */
 913
 914 #if HAVE_SIGSEGV_RECOVERY
 915
 916 static void
 917 sigsegv_handler (SIGSEGV_FAULT_HANDLER_ARGLIST)
 918 {
 919   void *address = (void *) (SIGSEGV_FAULT_ADDRESS);
 920
 921 # if HAVE_STACK_OVERFLOW_RECOVERY
 922 #  if !(HAVE_STACKVMA || defined SIGSEGV_FAULT_STACKPOINTER)
 923 #error "Insufficient heuristics for detecting a stack overflow.  Either define CFG_STACKVMA and HAVE_STACKVMA correctly, or define SIGSEGV_FAULT_STACKPOINTER correctly, or undefine HAVE_STACK_OVERFLOW_RECOVERY!"
 924 #  endif
 925
 926   /* Call user's handler.  */
 927   if (user_handler && (*user_handler) (address, 0))
 928     {
 929       /* Handler successful.  */
 930     }
 931   else
 932     {
 933       /* Handler declined responsibility.  */
 934
 935       /* Did the user install a stack overflow handler?  */
 936       if (stk_user_handler)
 937         {
 938           /* See whether it was a stack overflow. If so, longjump away.  */
 939 #  ifdef SIGSEGV_FAULT_STACKPOINTER
 940           uintptr_t old_sp = (uintptr_t) (SIGSEGV_FAULT_STACKPOINTER);
 941 #   ifdef __ia64
 942           uintptr_t old_bsp = (uintptr_t) (SIGSEGV_FAULT_BSP_POINTER);
 943 #   endif
 944 #  endif
 945
 946 #  if HAVE_STACKVMA
 947           /* Were we able to determine the stack top?  */
 948           if (stack_top)
 949             {
 950               /* Determine stack bounds.  */
 951               int saved_errno;
 952               struct vma_struct vma;
 953               int ret;
 954
 955               saved_errno = errno;
 956               ret = sigsegv_get_vma (stack_top, &vma);
 957               errno = saved_errno;
 958               if (ret >= 0)
 959                 {
 960 #   ifndef BOGUS_FAULT_ADDRESS_UPON_STACK_OVERFLOW
 961                   /* Heuristic AC: If the fault_address is nearer to the stack
 962                      segment's [start,end] than to the previous segment, we
 963                      consider it a stack overflow.
 964                      In the case of IA-64, we know that the previous segment
 965                      is the up-growing bsp segment, and either of the two
 966                      stacks can overflow.  */
 967                   uintptr_t addr = (uintptr_t) address;
 968
 969 #    ifdef __ia64
 970                   if (addr >= vma.prev_end && addr <= vma.end - 1)
 971 #    else
 972 #     if STACK_DIRECTION < 0
 973                   if (addr >= vma.start
 974                       ? (addr <= vma.end - 1)
 975                       : vma.is_near_this (addr, &vma))
 976 #     else
 977                   if (addr <= vma.end - 1
 978                       ? (addr >= vma.start)
 979                       : vma.is_near_this (addr, &vma))
 980 #     endif
 981 #    endif
 982                     {
 983 #   else /* BOGUS_FAULT_ADDRESS_UPON_STACK_OVERFLOW */
 984 #    if HAVE_GETRLIMIT && defined RLIMIT_STACK
 985                   /* Heuristic BC: If the stack size has reached its maximal size,
 986                      and old_sp is near the low end, we consider it a stack
 987                      overflow.  */
 988                   struct rlimit rl;
 989
 990                   saved_errno = errno;
 991                   ret = getrlimit (RLIMIT_STACK, &rl);
 992                   errno = saved_errno;
 993                   if (ret >= 0)
 994                     {
 995                       uintptr_t current_stack_size = vma.end - vma.start;
 996                       uintptr_t max_stack_size = rl.rlim_cur;
 997                       if (current_stack_size <= max_stack_size + 4096
 998                           && max_stack_size <= current_stack_size + 4096
 999 #    else
1000                     {
1001                       if (1
1002 #    endif
1003 #    ifdef SIGSEGV_FAULT_STACKPOINTER
1004                           /* Heuristic BC: If we know old_sp, and it is neither
1005                              near the low end, nor in the alternate stack, then
1006                              it's probably not a stack overflow.  */
1007                           && ((old_sp >= stk_extra_stack
1008                                && old_sp <= stk_extra_stack + stk_extra_stack_size)
1009 #     if STACK_DIRECTION < 0
1010                               || (old_sp <= vma.start + 4096
1011                                   && vma.start <= old_sp + 4096))
1012 #     else
1013                               || (old_sp <= vma.end + 4096
1014                                   && vma.end <= old_sp + 4096))
1015 #     endif
1016 #    endif
1017                          )
1018 #   endif /* BOGUS_FAULT_ADDRESS_UPON_STACK_OVERFLOW */
1019 #  else /* !HAVE_STACKVMA */
1020           /* Heuristic AB: If the fault address is near the stack pointer,
1021              it's a stack overflow.  */
1022           uintptr_t addr = (uintptr_t) address;
1023
1024           if ((addr <= old_sp + 4096 && old_sp <= addr + 4096)
1025 #   ifdef __ia64
1026               || (addr <= old_bsp + 4096 && old_bsp <= addr + 4096)
1027 #   endif
1028              )
1029             {
1030                 {
1031                     {
1032 #  endif /* !HAVE_STACKVMA */
1033                         {
1034 #  ifdef SIGSEGV_FAULT_STACKPOINTER
1035                           int emergency =
1036                             (old_sp >= stk_extra_stack
1037                              && old_sp <= stk_extra_stack + stk_extra_stack_size);
1038                           stackoverflow_context_t context = (SIGSEGV_FAULT_CONTEXT);
1039 #  else
1040                           int emergency = 0;
1041                           stackoverflow_context_t context = (void *) 0;
1042 #  endif
1043                           /* Call user's handler.  */
1044                           (*stk_user_handler) (emergency, context);
1045                         }
1046                     }
1047                 }
1048             }
1049         }
1050 # endif /* HAVE_STACK_OVERFLOW_RECOVERY */
1051
1052       if (user_handler && (*user_handler) (address, 1))
1053         {
1054           /* Handler successful.  */
1055         }
1056       else
1057         {
1058           /* Handler declined responsibility for real.  */
1059
1060           /* Remove ourselves and dump core.  */
1061           SIGSEGV_FOR_ALL_SIGNALS (signo, signal (signo, SIG_DFL);)
1062         }
1063
1064 # if HAVE_STACK_OVERFLOW_RECOVERY
1065     }
1066 # endif /* HAVE_STACK_OVERFLOW_RECOVERY */
1067 }
1068
1069 #elif HAVE_STACK_OVERFLOW_RECOVERY
1070
1071 static void
1072 # ifdef SIGSEGV_FAULT_STACKPOINTER
1073 sigsegv_handler (SIGSEGV_FAULT_HANDLER_ARGLIST)
1074 # else
1075 sigsegv_handler (int sig)
1076 # endif
1077 {
1078 # if !((HAVE_GETRLIMIT && defined RLIMIT_STACK) || defined SIGSEGV_FAULT_STACKPOINTER)
1079 #  error "Insufficient heuristics for detecting a stack overflow.  Either define SIGSEGV_FAULT_STACKPOINTER correctly, or undefine HAVE_STACK_OVERFLOW_RECOVERY!"
1080 # endif
1081
1082   /* Did the user install a handler?  */
1083   if (stk_user_handler)
1084     {
1085       /* See whether it was a stack overflow.  If so, longjump away.  */
1086 # ifdef SIGSEGV_FAULT_STACKPOINTER
1087       uintptr_t old_sp = (uintptr_t) (SIGSEGV_FAULT_STACKPOINTER);
1088 # endif
1089
1090       /* Were we able to determine the stack top?  */
1091       if (stack_top)
1092         {
1093           /* Determine stack bounds.  */
1094           int saved_errno;
1095           struct vma_struct vma;
1096           int ret;
1097
1098           saved_errno = errno;
1099           ret = sigsegv_get_vma (stack_top, &vma);
1100           errno = saved_errno;
1101           if (ret >= 0)
1102             {
1103 # if HAVE_GETRLIMIT && defined RLIMIT_STACK
1104               /* Heuristic BC: If the stack size has reached its maximal size,
1105                  and old_sp is near the low end, we consider it a stack
1106                  overflow.  */
1107               struct rlimit rl;
1108
1109               saved_errno = errno;
1110               ret = getrlimit (RLIMIT_STACK, &rl);
1111               errno = saved_errno;
1112               if (ret >= 0)
1113                 {
1114                   uintptr_t current_stack_size = vma.end - vma.start;
1115                   uintptr_t max_stack_size = rl.rlim_cur;
1116                   if (current_stack_size <= max_stack_size + 4096
1117                       && max_stack_size <= current_stack_size + 4096
1118 # else
1119                 {
1120                   if (1
1121 # endif
1122 # ifdef SIGSEGV_FAULT_STACKPOINTER
1123                       /* Heuristic BC: If we know old_sp, and it is neither
1124                          near the low end, nor in the alternate stack, then
1125                          it's probably not a stack overflow.  */
1126                       && ((old_sp >= stk_extra_stack
1127                            && old_sp <= stk_extra_stack + stk_extra_stack_size)
1128 #  if STACK_DIRECTION < 0
1129                           || (old_sp <= vma.start + 4096
1130                               && vma.start <= old_sp + 4096))
1131 #  else
1132                           || (old_sp <= vma.end + 4096
1133                               && vma.end <= old_sp + 4096))
1134 #  endif
1135 # endif
1136                      )
1137                     {
1138 # ifdef SIGSEGV_FAULT_STACKPOINTER
1139                       int emergency =
1140                         (old_sp >= stk_extra_stack
1141                          && old_sp <= stk_extra_stack + stk_extra_stack_size);
1142                       stackoverflow_context_t context = (SIGSEGV_FAULT_CONTEXT);
1143 # else
1144                       int emergency = 0;
1145                       stackoverflow_context_t context = (void *) 0;
1146 # endif
1147                       /* Call user's handler.  */
1148                       (*stk_user_handler)(emergency,context);
1149                     }
1150                 }
1151             }
1152         }
1153     }
1154
1155   /* Remove ourselves and dump core.  */
1156   SIGSEGV_FOR_ALL_SIGNALS (signo, signal (signo, SIG_DFL);)
1157 }
1158
1159 #endif
1160
1161
1162 #if HAVE_SIGSEGV_RECOVERY || HAVE_STACK_OVERFLOW_RECOVERY
1163
1164 static void
1165 install_for (int sig)
1166 {
1167   struct sigaction action;
1168
1169 # ifdef SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
1170   action.sa_sigaction = &sigsegv_handler;
1171 # else
1172   action.sa_handler = (void (*) (int)) &sigsegv_handler;
1173 # endif
1174   /* Block most signals while SIGSEGV is being handled.  */
1175   /* Signals SIGKILL, SIGSTOP cannot be blocked.  */
1176   /* Signals SIGCONT, SIGTSTP, SIGTTIN, SIGTTOU are not blocked because
1177      dealing with these signals seems dangerous.  */
1178   /* Signals SIGILL, SIGABRT, SIGFPE, SIGSEGV, SIGTRAP, SIGIOT, SIGEMT, SIGBUS,
1179      SIGSYS, SIGSTKFLT are not blocked because these are synchronous signals,
1180      which may require immediate intervention, otherwise the process may
1181      starve.  */
1182   sigemptyset (&action.sa_mask);
1183 # ifdef SIGHUP
1184   sigaddset (&action.sa_mask,SIGHUP);
1185 # endif
1186 # ifdef SIGINT
1187   sigaddset (&action.sa_mask,SIGINT);
1188 # endif
1189 # ifdef SIGQUIT
1190   sigaddset (&action.sa_mask,SIGQUIT);
1191 # endif
1192 # ifdef SIGPIPE
1193   sigaddset (&action.sa_mask,SIGPIPE);
1194 # endif
1195 # ifdef SIGALRM
1196   sigaddset (&action.sa_mask,SIGALRM);
1197 # endif
1198 # ifdef SIGTERM
1199   sigaddset (&action.sa_mask,SIGTERM);
1200 # endif
1201 # ifdef SIGUSR1
1202   sigaddset (&action.sa_mask,SIGUSR1);
1203 # endif
1204 # ifdef SIGUSR2
1205   sigaddset (&action.sa_mask,SIGUSR2);
1206 # endif
1207 # ifdef SIGCHLD
1208   sigaddset (&action.sa_mask,SIGCHLD);
1209 # endif
1210 # ifdef SIGCLD
1211   sigaddset (&action.sa_mask,SIGCLD);
1212 # endif
1213 # ifdef SIGURG
1214   sigaddset (&action.sa_mask,SIGURG);
1215 # endif
1216 # ifdef SIGIO
1217   sigaddset (&action.sa_mask,SIGIO);
1218 # endif
1219 # ifdef SIGPOLL
1220   sigaddset (&action.sa_mask,SIGPOLL);
1221 # endif
1222 # ifdef SIGXCPU
1223   sigaddset (&action.sa_mask,SIGXCPU);
1224 # endif
1225 # ifdef SIGXFSZ
1226   sigaddset (&action.sa_mask,SIGXFSZ);
1227 # endif
1228 # ifdef SIGVTALRM
1229   sigaddset (&action.sa_mask,SIGVTALRM);
1230 # endif
1231 # ifdef SIGPROF
1232   sigaddset (&action.sa_mask,SIGPROF);
1233 # endif
1234 # ifdef SIGPWR
1235   sigaddset (&action.sa_mask,SIGPWR);
1236 # endif
1237 # ifdef SIGLOST
1238   sigaddset (&action.sa_mask,SIGLOST);
1239 # endif
1240 # ifdef SIGWINCH
1241   sigaddset (&action.sa_mask,SIGWINCH);
1242 # endif
1243   /* Note that sigaction() implicitly adds sig itself to action.sa_mask.  */
1244   /* Ask the OS to provide a structure siginfo_t to the handler.  */
1245 # ifdef SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
1246   action.sa_flags = SA_SIGINFO;
1247 # else
1248   action.sa_flags = 0;
1249 # endif
1250 # if HAVE_STACK_OVERFLOW_RECOVERY && HAVE_SIGALTSTACK /* not BeOS */
1251   /* Work around Linux 2.2.5 bug: If SA_ONSTACK is specified but sigaltstack()
1252      has not been called, the kernel will busy loop, eating CPU time.  So
1253      avoid setting SA_ONSTACK until the user has requested stack overflow
1254      handling.  */
1255   if (stk_user_handler)
1256     action.sa_flags |= SA_ONSTACK;
1257 # endif
1258   sigaction (sig, &action, (struct sigaction *) NULL);
1259 }
1260
1261 #endif /* HAVE_SIGSEGV_RECOVERY || HAVE_STACK_OVERFLOW_RECOVERY */
1262
1263 int
1264 sigsegv_install_handler (sigsegv_handler_t handler)
1265 {
1266 #if HAVE_SIGSEGV_RECOVERY
1267   user_handler = handler;
1268
1269   SIGSEGV_FOR_ALL_SIGNALS (sig, install_for (sig);)
1270
1271   return 0;
1272 #else
1273   return -1;
1274 #endif
1275 }
1276
1277 void
1278 sigsegv_deinstall_handler (void)
1279 {
1280 #if HAVE_SIGSEGV_RECOVERY
1281   user_handler = (sigsegv_handler_t)NULL;
1282
1283 # if HAVE_STACK_OVERFLOW_RECOVERY
1284   if (!stk_user_handler)
1285 # endif
1286     {
1287       SIGSEGV_FOR_ALL_SIGNALS (sig, signal (sig, SIG_DFL);)
1288     }
1289 #endif
1290 }
1291
1292 int
1293 sigsegv_leave_handler (void (*continuation) (void*, void*, void*),
1294                        void* cont_arg1, void* cont_arg2, void* cont_arg3)
1295 {
1296 #if HAVE_STACK_OVERFLOW_RECOVERY
1297   /*
1298    * Reset the system's knowledge that we are executing on the alternate
1299    * stack. If we didn't do that, siglongjmp would be needed instead of
1300    * longjmp to leave the signal handler.
1301    */
1302   sigsegv_reset_onstack_flag ();
1303 #endif
1304   (*continuation) (cont_arg1, cont_arg2, cont_arg3);
1305   return 1;
1306 }
1307
1308 int
1309 stackoverflow_install_handler (stackoverflow_handler_t handler,
1310                                void *extra_stack, size_t extra_stack_size)
1311 {
1312 #if HAVE_STACK_OVERFLOW_RECOVERY
1313 # if HAVE_STACKVMA
1314   if (!stack_top)
1315     {
1316       int dummy;
1317       remember_stack_top (&dummy);
1318       if (!stack_top)
1319         return -1;
1320     }
1321 # endif
1322
1323   stk_user_handler = handler;
1324   stk_extra_stack = (uintptr_t) extra_stack;
1325   stk_extra_stack_size = extra_stack_size;
1326   {
1327     stack_t ss;
1328 # if SIGALTSTACK_SS_REVERSED
1329     ss.ss_sp = (char *) extra_stack + extra_stack_size - sizeof (void *);
1330     ss.ss_size = extra_stack_size - sizeof (void *);
1331 # else
1332     ss.ss_sp = extra_stack;
1333     ss.ss_size = extra_stack_size;
1334 # endif
1335     ss.ss_flags = 0; /* no SS_DISABLE */
1336     if (sigaltstack (&ss, (stack_t*)0) < 0)
1337       return -1;
1338   }
1339
1340   /* Install the signal handlers with SA_ONSTACK.  */
1341   SIGSEGV_FOR_ALL_SIGNALS (sig, install_for (sig);)
1342   return 0;
1343 #else
1344   return -1;
1345 #endif
1346 }
1347
1348 void
1349 stackoverflow_deinstall_handler (void)
1350 {
1351 #if HAVE_STACK_OVERFLOW_RECOVERY
1352   stk_user_handler = (stackoverflow_handler_t) NULL;
1353
1354 # if HAVE_SIGSEGV_RECOVERY
1355   if (user_handler)
1356     {
1357       /* Reinstall the signal handlers without SA_ONSTACK, to avoid Linux
1358          bug.  */
1359       SIGSEGV_FOR_ALL_SIGNALS (sig, install_for (sig);)
1360     }
1361   else
1362 # endif
1363     {
1364       SIGSEGV_FOR_ALL_SIGNALS (sig, signal (sig, SIG_DFL);)
1365     }
1366
1367   {
1368     stack_t ss;
1369     ss.ss_flags = SS_DISABLE;
1370     if (sigaltstack (&ss, (stack_t *) 0) < 0)
1371       perror ("gnulib sigsegv (stackoverflow_deinstall_handler)");
1372   }
1373 #endif
1374 }