-pthread and test program

[Richard Nyberg]

This program i from the lang/ocaml port. It is supposed to check
wether stack overflow is detectable or not.

The test is compiled in two different ways:
1) cc stackov.c
2) cc -pthread stackov.c

The first binary exits fast with a value of 0.
The second binary however, never exits. It just runs
forever eating CPU. Is this a bug in libc_r?

        -Richard

/***********************************************************************/
/*                                                                     */
/*                           Objective Caml                            */
/*                                                                     */
/*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         */
/*                                                                     */
/*  Copyright 2001 Institut National de Recherche en Informatique et   */
/*  en Automatique.  All rights reserved.  This file is distributed    */
/*  under the terms of the GNU Library General Public License, with    */
/*  the special exception on linking described in file ../../LICENSE.  */
/*                                                                     */
/***********************************************************************/

/* $Id: stackov.c,v 1.3 2001/12/07 13:39:44 xleroy Exp $ */

#include <stdio.h>
#include <signal.h>
#include <sys/resource.h>

static char sig_alt_stack[SIGSTKSZ];
static char * system_stack_top;

#if defined(TARGET_i386) && defined(SYS_linux_elf)
static void segv_handler(int signo, struct sigcontext sc)
{
  char * fault_addr = (char *) sc.cr2;
#else
static void segv_handler(int signo, siginfo_t * info, void * context)
{
  char * fault_addr = (char *) info->si_addr;
#endif
  struct rlimit limit;

  if (getrlimit(RLIMIT_STACK, &limit) == 0 &&
      ((long) fault_addr & (sizeof(long) - 1)) == 0 &&
      fault_addr < system_stack_top &&
      fault_addr >= system_stack_top - limit.rlim_cur - 0x2000) {
    _exit(0);
  } else {
    _exit(4);
  }
}

void f(char * c);
void g(char * c) { char d[1024]; f(d); }
void f(char * c) { char d[1024]; g(d); }

int main(int argc, char ** argv)
{
  struct sigaltstack stk;
  struct sigaction act;
  struct rlimit limit;

  stk.ss_sp = sig_alt_stack;
  stk.ss_size = SIGSTKSZ;
  stk.ss_flags = 0;
#if defined(TARGET_i386) && defined(SYS_linux_elf)
  act.sa_handler = (void (*)(int)) segv_handler;
  act.sa_flags = SA_ONSTACK | SA_NODEFER;
#else
  act.sa_sigaction = segv_handler;
  act.sa_flags = SA_SIGINFO | SA_ONSTACK | SA_NODEFER;
#endif  
  sigemptyset(&act.sa_mask);
  system_stack_top = (char *) &act;
  limit.rlim_max = limit.rlim_cur = 0x20000;
  if (sigaltstack(&stk, NULL) != 0) { perror("sigaltstack"); return 2; }
  if (sigaction(SIGSEGV, &act, NULL) != 0) { perror("sigaction"); return 2; }
  if (setrlimit(RLIMIT_STACK, &limit) != 0) { perror("setrlimit"); return 2; }
  f(NULL);
  return 2;
}