Example #1
0
void NaClSignalStackUnregister(void)
{
  /*
   * Unregister the signal stack in case a fault occurs between the
   * thread deallocating the signal stack and exiting.  Such a fault
   * could be unsafe if the address space were reallocated before the
   * fault, although that is unlikely.
   */
  stack_t st;
  st.ss_size = 0;
  st.ss_sp = NULL;
  st.ss_flags = SS_DISABLE;
  ZLOGFAIL(sigaltstack(&st, NULL) == -1, errno, "Failed to unregister signal stack");
}
Example #2
0
void NaClSignalStackRegister(void *stack) {
  /*
   * If we set up signal handlers, we must ensure that any thread that
   * runs untrusted code has an alternate signal stack set up.  The
   * default for a new thread is to use the stack pointer from the
   * point at which the fault occurs, but it would not be safe to use
   * untrusted code's %esp/%rsp value.
   */
  stack_t st;
  st.ss_size = SIGNAL_STACK_SIZE;
  st.ss_sp = ((uint8_t *) stack) + STACK_GUARD_SIZE;
  st.ss_flags = 0;
  ZLOGFAIL(sigaltstack(&st, NULL) == -1, errno, "Failed to register signal stack");
}
Example #3
0
int
main()
{
    puts("-- 1 (should block) --");

    struct sigaction newAction;
    newAction.sa_handler = (sighandler_t)sigHandler;
    newAction.sa_mask = 0;
    newAction.sa_flags = SA_ONESHOT | SA_ONSTACK | SA_RESTART;
#if defined(__BEOS__) || defined(__HAIKU__)
    newAction.sa_userdata = (void*)kUserDataMagic;
#endif
    sigaction(SIGALRM, &newAction, NULL);

    ualarm(10000, 0);
    wait_for_key();

    puts("-- 2 (does not block, should call handler twice) --");

    newAction.sa_flags = 0;
    sigaction(SIGALRM, &newAction, NULL);

    ualarm(0, 50000);
    wait_for_key();
    wait_for_key();

    ualarm(0, 0);

    puts("-- 3 (alternate stack, should block) --");

#if defined(__BEOS__) && !defined(__HAIKU__)
    set_signal_stack(sAlternateStack, SIGSTKSZ);
#else
    stack_t newStack;
    newStack.ss_sp = sAlternateStack;
    newStack.ss_size = SIGSTKSZ;
    newStack.ss_flags = 0;
    if (sigaltstack(&newStack, NULL) != 0)
        fprintf(stderr, "sigaltstack() failed: %s\n", strerror(errno));
#endif

    newAction.sa_flags = SA_RESTART | SA_ONSTACK;
    sigaction(SIGALRM, &newAction, NULL);

    ualarm(10000, 0);
    wait_for_key();

    puts("-- end --");
    return 0;
}
Example #4
0
void print_signal_stack() {
  int ret_val;
  stack_t oss;

  ret_val = sigaltstack(NULL, &oss);
  if(ret_val) {
    perror("ERROR, sigaltstack failed");
    exit(1);
  }

  printf("ESP of original stack: %p, top: %p, size: %ld, disabled = %s\n",
         oss.ss_sp, (unsigned char *)oss.ss_sp + oss.ss_size, oss.ss_size,
         (oss.ss_flags & SS_DISABLE) ? "true" : "false");
}
Example #5
0
int arch_os_thread_init(struct thread *thread) {
    stack_t sigstack;
    /* Signal handlers are normally run on the main stack, but we've
     * swapped stacks, require that the control stack contain only
     * boxed data, and expands upwards while the C stack expands
     * downwards. */
    sigstack.ss_sp    = calc_altstack_base(thread);
    sigstack.ss_flags = 0;
    sigstack.ss_size  = calc_altstack_size(thread);
    if(sigaltstack(&sigstack,0)<0)
        lose("Cannot sigaltstack: %s\n",strerror(errno));

    return 1;                   /* success */
}
Example #6
0
/*
 * Register the minithread clock handler by making
 * mini_clock_handler point to it.
 *
 * Then set the signal handler for SIGRTMAX-1 to
 * handle_interrupt.  This signal handler will either
 * interrupt the minithreads, or drop the interrupt,
 * depending on safety conditions.
 *
 * The signals are handled on their own stack to reduce
 * chances of an overrun.
 */
void
minithread_clock_init(interrupt_handler_t clock_handler){
    timer_t timerid;
    struct sigevent sev;
    struct itimerspec its;
    struct sigaction sa;
    stack_t ss;
    mini_clock_handler = clock_handler;

    sem_init(&interrupt_received_sema,0,0);

    ss.ss_sp = malloc(SIGSTKSZ);
    if (ss.ss_sp == NULL){
        perror("malloc.");
        abort();
    }
    ss.ss_size = SIGSTKSZ;
    ss.ss_flags = 0;
    if (sigaltstack(&ss, NULL) == -1){
        perror("signal stack");
        abort();
    }


    /* Establish handler for timer signal */
    sa.sa_handler = (void*)handle_interrupt;
    sa.sa_flags = SA_SIGINFO | SA_RESTART | SA_ONSTACK;
    sa.sa_sigaction= (void*)handle_interrupt;
    sigemptyset(&sa.sa_mask);
    sigaddset(&sa.sa_mask,SIGRTMAX-1);
    sigaddset(&sa.sa_mask,SIGRTMAX-2);
    if (sigaction(SIGRTMAX-1, &sa, NULL) == -1)
        errExit("sigaction");

    /* Create the timer */
    sev.sigev_notify = SIGEV_SIGNAL;
    sev.sigev_signo = SIGRTMAX-1;
    sev.sigev_value.sival_ptr = &timerid;
    if (timer_create(CLOCK_THREAD_CPUTIME_ID, &sev, &timerid) == -1)
        errExit("timer_create");

    /* Start the timer */
    its.it_value.tv_sec = (PERIOD) / 1000000000;
    its.it_value.tv_nsec = (PERIOD) % 1000000000;
    its.it_interval.tv_sec = its.it_value.tv_sec;
    its.it_interval.tv_nsec = its.it_value.tv_nsec;

    if (timer_settime(timerid, 0, &its, NULL) == -1)
        errExit("timer_settime");
}
Example #7
0
/* alternate stack for SIGSEGV */
void
rb_register_sigaltstack(rb_thread_t *th)
{
    stack_t newSS, oldSS;

    if (!th->altstack)
	rb_bug("rb_register_sigaltstack: th->altstack not initialized\n");

    newSS.ss_sp = th->altstack;
    newSS.ss_size = ALT_STACK_SIZE;
    newSS.ss_flags = 0;

    sigaltstack(&newSS, &oldSS); /* ignore error. */
}
Example #8
0
int main()
{
	struct sigaction act;
	
	act.sa_handler = handler;
	act.sa_flags = SA_ONSTACK;
	sigemptyset(&act.sa_mask);
	if (sigaction(SIGXFSZ,  &act, 0) == -1) {
		perror("Unexpected error while attempting to setup test "
		       "pre-conditions");
		return PTS_UNRESOLVED;
	} else {
                printf("INFO: sigaction((SIGXFSZ,  &act, 0) returned successfully\n");
        }


	if ((alt_ss.ss_sp = (void *)malloc(SIGSTKSZ)) == NULL) {
		perror("Unexpected error while attempting to setup test "
		       "pre-conditions");
		return PTS_UNRESOLVED;
	} else {
                printf("INFO: Successfully malloc'd alternative stack\n");
        }

	alt_ss.ss_size = SIGSTKSZ;
	alt_ss.ss_flags = 0;
	
	if (sigaltstack(&alt_ss, (stack_t *)0) == -1) {
		perror("Unexpected error while attempting to setup test "
		       "pre-conditions");
		return PTS_UNRESOLVED;
	} else {
                printf("INFO: sigaltstack(&alt_ss, (stack_t *)0) returned successfully\n");
        }


	if (raise(SIGXFSZ) == -1) {
		perror("Unexpected error while attempting to setup test "
		       "pre-conditions");
		return PTS_UNRESOLVED;
	} else {
                printf("INFO: raise(SGABRT) returned successfully\n");
        }


	printf("Test PASSED\n");

	return PTS_PASS;	
}
Example #9
0
CrashHandlerSetup::CrashHandlerSetup()
{
#ifdef BUILD_CRASH_HANDLER
    if (qgetenv("QTC_USE_CRASH_HANDLER").isEmpty())
        return;

    const QString crashHandlerPath = qApp->applicationDirPath()
        + QLatin1String("/qtcreator_crash_handler");
    crashHandlerPathC = qstrdup(qPrintable(crashHandlerPath));

    // Setup an alternative stack for the signal handler. This way we are able to handle SIGSEGV
    // even if the normal process stack is exhausted.
    stack_t ss;
    ss.ss_sp = signalHandlerStack = malloc(SIGSTKSZ); // Usual requirements for alternative signal stack.
    if (ss.ss_sp == 0) {
        qWarning("Warning: Could not allocate space for alternative signal stack (%s).", Q_FUNC_INFO);
        return;
    }
    ss.ss_size = SIGSTKSZ;
    ss.ss_flags = 0;
    if (sigaltstack(&ss, 0) == -1) {
        qWarning("Warning: Failed to set alternative signal stack (%s).", Q_FUNC_INFO);
        return;
    }

    // Install signal handler for calling the crash handler.
    struct sigaction sa;
    if (sigemptyset(&sa.sa_mask) == -1) {
        qWarning("Warning: Failed to empty signal set (%s).", Q_FUNC_INFO);
        return;
    }
    sa.sa_handler = &signalHandler;
    // SA_RESETHAND - Restore signal action to default after signal handler has been called.
    // SA_NODEFER - Don't block the signal after it was triggered (otherwise blocked signals get
    // inherited via fork() and execve()). Without this the signal will not be delivered to the
    // restarted Qt Creator.
    // SA_ONSTACK - Use alternative stack.
    sa.sa_flags = SA_RESETHAND | SA_NODEFER | SA_ONSTACK;
    // See "man 7 signal" for an overview of signals.
    // Do not add SIGPIPE here, QProcess and QTcpSocket use it.
    const int signalsToHandle[] = { SIGILL, SIGABRT, SIGFPE, SIGSEGV, SIGBUS, 0 };
    for (int i = 0; signalsToHandle[i]; ++i) {
        if (sigaction(signalsToHandle[i], &sa, 0) == -1 ) {
            qWarning("Warning: Failed to install signal handler for signal \"%s\" (%s).",
                strsignal(signalsToHandle[i]), Q_FUNC_INFO);
        }
    }
#endif // BUILD_CRASH_HANDLER
}
Example #10
0
static void
setup_alternate_signal_stack (void)
{
#ifdef HAVE_SIGALTSTACK
  stack_t ss;

  /* FreeBSD versions older than 11.0 use char * for ss_sp instead of
     void *.  This cast works with both types.  */
  ss.ss_sp = (char *) xmalloc (SIGSTKSZ);
  ss.ss_size = SIGSTKSZ;
  ss.ss_flags = 0;

  sigaltstack(&ss, NULL);
#endif
}
Example #11
0
void
check_stack(void *buf, const char *label)
{
	struct sigaltstack ss;

	bzero(&ss, sizeof(ss));
	if (sigaltstack(NULL, &ss) != 0)
		err(1, "failed to get sigaltstack in %s", label);
	if (ss.ss_sp != buf ||
	    ss.ss_size != SIGSTKSZ ||
	    ss.ss_flags != 0)
		errx(1, "bad sigaltstack value in %s: "
		    "buf=%p ss_sp=%p ss_size=%zu ss_flags=0x%x",
		    label, buf, ss.ss_sp, ss.ss_size, ss.ss_flags);
}
    FatalConditionHandler::FatalConditionHandler() {
        isSet = true;
        stack_t sigStack;
        sigStack.ss_sp = altStackMem;
        sigStack.ss_size = SIGSTKSZ;
        sigStack.ss_flags = 0;
        sigaltstack(&sigStack, &oldSigStack);
        struct sigaction sa = { };

        sa.sa_handler = handleSignal;
        sa.sa_flags = SA_ONSTACK;
        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
        }
    }
Example #13
0
void AndroidCrashReport::Init()
{
	void* libcorkscrew = dlopen("/system/lib/libcorkscrew.so", RTLD_NOW);
	if (libcorkscrew)
	{
		unwind_backtrace_signal_arch = (t_unwind_backtrace_signal_arch) dlsym(libcorkscrew, "unwind_backtrace_signal_arch");
		if (!unwind_backtrace_signal_arch) LOGE("unwind_backtrace_signal_arch not found");

		acquire_my_map_info_list = (t_acquire_my_map_info_list) dlsym(libcorkscrew, "acquire_my_map_info_list");
		if (!acquire_my_map_info_list) LOGE("acquire_my_map_info_list not found");

		get_backtrace_symbols = (t_get_backtrace_symbols) dlsym(libcorkscrew, "get_backtrace_symbols");
		if (!get_backtrace_symbols) LOGE("get_backtrace_symbols not found");

		free_backtrace_symbols = (t_free_backtrace_symbols) dlsym(libcorkscrew, "free_backtrace_symbols");
		if (!free_backtrace_symbols) LOGE("free_backtrace_symbols not found");

		release_my_map_info_list = (t_release_my_map_info_list) dlsym(libcorkscrew, "release_my_map_info_list");
		if (!release_my_map_info_list) LOGE("release_my_map_info_list not found");
	}
	else
	{
		LOGE("libcorkscrew not found");
	}

	s_sigstk.ss_size = 64 * 1024;
	s_sigstk.ss_sp = malloc(s_sigstk.ss_size);
	s_sigstk.ss_flags = 0;
	
	if (sigaltstack(&s_sigstk, 0) < 0)
	{
		Logger::Error("Could not initialize alternative signal stack");
	}
	
	for (int i = 0; i < fatalSignalsCount; i++)
	{
		struct sigaction sa;
		memset(&sa, 0, sizeof(sa));
		sa.sa_flags = SA_SIGINFO|SA_ONSTACK;
		sigemptyset(&sa.sa_mask);
		sa.sa_sigaction = &SignalHandler;
		
		if (sigaction(fatalSignals[i], &sa, NULL) != 0)
		{
			Logger::Error("Signal registration for failed:");
		}
	}
}
bool regist_signal_stack()
{
	void* signal_stack = malloc(SIGSTKSZ);
	stack_t stack;
	memset(&stack, 0, sizeof(stack));
	stack.ss_sp = (char*)signal_stack;
	stack.ss_size = SIGSTKSZ;

	if (sigaltstack(&stack, NULL) == -1)
	{
		LOG_ERROR("sigaltstack() error");
		return false;
	}

	return true;
}
Example #15
0
void* setup_altstack(void) {
   stack_t ss;

       ss.ss_sp = malloc(20*1024);
       if (ss.ss_sp == 0) {
	   return NULL;
       }
       ss.ss_size = 20*1024;
       ss.ss_flags = 0;
       
       if (sigaltstack(&ss, NULL) == -1) {
	   perror("sigaltstack");
           return NULL;
       }
       return ss.ss_sp;
}
Example #16
0
File: signal.c Project: fi8on/ruby
/* alternate stack for SIGSEGV */
void
rb_register_sigaltstack(rb_thread_t *th)
{
    stack_t newSS, oldSS;

    if (th->altstack) return;

    newSS.ss_sp = th->altstack = malloc(ALT_STACK_SIZE);
    if (newSS.ss_sp == NULL)
	/* should handle error */
	rb_bug("rb_register_sigaltstack. malloc error\n");
    newSS.ss_size = ALT_STACK_SIZE;
    newSS.ss_flags = 0;

    sigaltstack(&newSS, &oldSS); /* ignore error. */
}
Example #17
0
File: 6-1.c Project: Nan619/ltp-ddt
void handler(int signo)
{
	stack_t handler_s;

	if (sigaltstack((stack_t *) 0, &handler_s) == -1) {
		perror
		    ("Unexpected error while attempting to setup test pre-conditions");
		exit(PTS_UNRESOLVED);
	}

	if (handler_s.ss_flags != SS_ONSTACK) {
		printf
		    ("Test FAILED: The alternate stack's ss_flags member does not contain SS_ONSTACK even though the handler is executing on the alternate stack\n");
		exit(PTS_FAIL);
	}
}
void NaClSetSignalHandler(void) {
  struct sigaction action;
  stack_t stack;

  stack.ss_sp = g_nacl_altstack;
  stack.ss_flags = 0;
  stack.ss_size = NACL_ARRAY_SIZE(g_nacl_altstack);
  sigaltstack(&stack, (stack_t *) NULL);

  memset(&action, 0, sizeof action);
  action.sa_sigaction = NaClSignalHandler;
  sigfillset(&action.sa_mask);
  action.sa_flags = SA_ONSTACK | SA_SIGINFO;

  CHECK(0 == sigaction(kExpectedSignal, &action, (struct sigaction *) NULL));
}
Example #19
0
void takedown_altstack(void* stack) {
#  if defined(_AIX)
   stack_t ss;
#  else
   struct sigaltstack ss;
#  endif
   int result;
   
   ss.ss_flags = SS_DISABLE;
   ss.ss_sp = (void*)47;  // This value should be ignored when ss_flags is SS_DISABLE
   ss.ss_size = 29;       // This value should be ignored when ss_flags is SS_DISABLE
   
   {
       result = sigaltstack(&ss, NULL);
       free(stack);
   }
}
Example #20
0
int set_alt_stack(port_tls_data_t* tlsdata, Boolean set)
{
    stack_t sigalt;

    // sets alternative stack
    sigalt.ss_sp = tlsdata->guard_stack_addr;
    sigalt.ss_size = tlsdata->guard_stack_size;
//#if defined(FREEBSD)
    sigalt.ss_flags = set ? 0 : SS_DISABLE;
//#else
//    sigalt.ss_flags = set ? SS_ONSTACK : SS_DISABLE;
//#endif
    if (sigaltstack(&sigalt, NULL) != 0)
        return errno;

    return 0;
}
Example #21
0
File: 13-2.c Project: kraj/ltp
void handler(int signo LTP_ATTRIBUTE_UNUSED)
{
	stack_t oss;

	printf("Caught SIGUSR2\n");

	if (sigaltstack(NULL, &oss) == -1) {
		perror("Unexpected error while attempting to setup test "
		       "pre-conditions");
		exit(-1);
	}

	if (oss.ss_sp != current.ss_sp || oss.ss_size != current.ss_size) {
		printf("Test FAILED\n");
		exit(-1);
	}
}
Example #22
0
void handler(int signo)
{
	stack_t oss;

	printf("Caught SIGPIPE\n");

	if (sigaltstack((stack_t *) 0, &oss) == -1) {
		perror("Unexpected error while attempting to setup test "
		       "pre-conditions");
		exit(-1);
	}

	if (oss.ss_sp != current.ss_sp || oss.ss_size != current.ss_size) {
		printf("Test FAILED\n");
		exit(-1);
	}
}
Example #23
0
File: 12-4.c Project: 1587/ltp
void handler(int signo)
{
	stack_t ss;

	printf("Caught SIGCHLD\n");

	if (sigaltstack(NULL, &ss) == -1) {
		perror("Unexpected error while attempting to setup test "
		       "pre-conditions");
		exit(-1);
	}

	if (ss.ss_sp != alt_ss.ss_sp || ss.ss_size != alt_ss.ss_size) {
		printf("Test FAILED\n");
		exit(-1);
	}
}
Example #24
0
int cc_install_handlers(int argc, char **argv, int num_signals, int *signals, const char *logfile, int (*user_info)(char*, char*))
{
	struct sigaction sa;
	stack_t altss;
	int retval;

	if(argc == 2 && strcmp(argv[1], crash_switch) == 0)
		crash_handler(logfile);

	cc_user_info = user_info;

	if(argv[0][0] == '/')
		snprintf(argv0, sizeof(argv0), "%s", argv[0]);
	else
	{
		getcwd(argv0, sizeof(argv0));
		retval = strlen(argv0);
		snprintf(argv0+retval, sizeof(argv0)-retval, "/%s", argv[0]);
	}

	/* Set an alternate signal stack so SIGSEGVs caused by stack overflows
	 * still run */
	altss.ss_sp = altstack;
	altss.ss_flags = 0;
	altss.ss_size = sizeof(altstack);
	sigaltstack(&altss, NULL);

	memset(&sa, 0, sizeof(sa));
	sa.sa_sigaction = crash_catcher;
	sa.sa_flags = SA_RESETHAND | SA_NODEFER | SA_SIGINFO | SA_ONSTACK;
	sigemptyset(&sa.sa_mask);

	retval = 0;
	while(num_signals--)
	{
		if((*signals != SIGSEGV && *signals != SIGILL && *signals != SIGFPE &&
		    *signals != SIGBUS) || sigaction(*signals, &sa, NULL) == -1)
		{
			*signals = 0;
			retval = -1;
		}
		++signals;
	}
	return retval;
}
static void signalHandlerEnable() {
    bool handled = false;
#ifdef SHOULD_USE_SIGNAL_STACK
#if !defined(_WIN32)
    // alternate stack on Linux for stack overflows
    static uint8_t alternate_stack[SIGSTKSZ];
    stack_t ss = {};
    ss.ss_sp = (void*) alternate_stack;
    ss.ss_size = SIGSTKSZ;
    ss.ss_flags = 0;
    sigaltstack(&ss, NULL);
    
    struct sigaction sig_action = {};
    sig_action.sa_sigaction = stanfordCppLibPosixSignalHandler;
    sigemptyset(&sig_action.sa_mask);
#ifdef __APPLE__
    // backtrace() doesn't work on OS X when we use an alternate stack
    sig_action.sa_flags = SA_SIGINFO;
#else
    sig_action.sa_flags = SA_SIGINFO | SA_ONSTACK;
#endif // __APPLE__
    sigaction(SIGSEGV, &sig_action, NULL);
    sigaction(SIGFPE,  &sig_action, NULL);
    sigaction(SIGILL,  &sig_action, NULL);
    sigaction(SIGTERM, &sig_action, NULL);
    sigaction(SIGABRT, &sig_action, NULL);
    handled = true;
#endif // not win32
#endif // SHOULD_USE_SIGNAL_STACK

    SIGNALS_HANDLED.clear();
    SIGNALS_HANDLED.push_back(SIGSEGV);
    SIGNALS_HANDLED.push_back(SIGILL);
    SIGNALS_HANDLED.push_back(SIGFPE);
#ifdef SPL_AUTOGRADER_MODE
    SIGNALS_HANDLED.push_back(SIGINT);
#else // not SPL_AUTOGRADER_MODE
    SIGNALS_HANDLED.push_back(SIGABRT);
#endif // SPL_AUTOGRADER_MODE
    if (!handled) {
        for (int sig : SIGNALS_HANDLED) {
            signal(sig, stanfordCppLibSignalHandler);
        }
    }
}
int main()
{
	static char stack[SIGSTKSZ];
	printf ("top of static stack near %p(%luM, %luG) \n",  ADDR(&stack));
	stack_t ss = {
		.ss_size = SIGSTKSZ,
		.ss_sp = stack,
	};
	struct sigaction sa = {
		.sa_handler = handler,
		.sa_flags = SA_ONSTACK
	};
	sigaltstack(&ss, 0);
	sigfillset(&sa.sa_mask);
	sigaction(SIGSEGV, &sa, 0);
	infinite_recursion(0);
	return 0;
}
Example #27
0
void InstallExceptionHandler()
{
	stack_t signal_stack;
	signal_stack.ss_sp = malloc(SIGSTKSZ);
	signal_stack.ss_size = SIGSTKSZ;
	signal_stack.ss_flags = 0;
	if (sigaltstack(&signal_stack, nullptr))
		PanicAlert("sigaltstack failed");
	struct sigaction sa;
	sa.sa_handler = nullptr;
	sa.sa_sigaction = &sigsegv_handler;
	sa.sa_flags = SA_SIGINFO;
	sigemptyset(&sa.sa_mask);
	sigaction(SIGSEGV, &sa, nullptr);
#ifdef __APPLE__
	sigaction(SIGBUS, &sa, nullptr);
#endif
}
Example #28
0
static void install_crash_handler() {
  stack_t ss;
  struct sigaction sa;

  memset(&ss, 0, sizeof(ss));
  memset(&sa, 0, sizeof(sa));
  ss.ss_size = sizeof(g_alt_stack);
  ss.ss_sp = g_alt_stack;
  GPR_ASSERT(sigaltstack(&ss, NULL) == 0);
  sa.sa_flags = (int)(SA_SIGINFO | SA_ONSTACK | SA_RESETHAND);
  sa.sa_sigaction = crash_handler;
  GPR_ASSERT(sigaction(SIGILL, &sa, NULL) == 0);
  GPR_ASSERT(sigaction(SIGABRT, &sa, NULL) == 0);
  GPR_ASSERT(sigaction(SIGBUS, &sa, NULL) == 0);
  GPR_ASSERT(sigaction(SIGSEGV, &sa, NULL) == 0);
  GPR_ASSERT(sigaction(SIGTERM, &sa, NULL) == 0);
  GPR_ASSERT(sigaction(SIGQUIT, &sa, NULL) == 0);
}
Example #29
0
/* Handling SIGSEGV is tricky.
 * If we've blown the stack, we need to call the handler in its own stack.
 */
int signal_setup (void)
{
    struct sigaction act;
    stack_t ss;

    ss.ss_sp = xzmalloc (SIGSTKSZ);
    ss.ss_flags = 0;
    ss.ss_size = SIGSTKSZ;
    if (sigaltstack (&ss, NULL) < 0)
        return -1;

    memset (&act, 0, sizeof (act));
    sigemptyset (&act.sa_mask);
    act.sa_handler = sigsegv_handler;
    act.sa_flags = SA_ONSTACK;

    return sigaction (SIGSEGV, &act, NULL);
}
Example #30
0
static void signal_init_altstack(char *err, size_t err_len,
				stack_t *alt_stack)
{
	/* Set up alternate stack */
	alt_stack->ss_sp = calloc(1, SIGSTKSZ);
	if (!alt_stack->ss_sp) {
		snprintf(err, err_len, "signal_init_altstack: failed to "
			"allocate %d bytes for alternate stack.", SIGSTKSZ);
		return;
	}
	alt_stack->ss_size = SIGSTKSZ;
	if (sigaltstack(alt_stack, NULL)) {
		int ret = errno;
		snprintf(err, err_len, "signal_init_altstack: sigaltstack "
			 "failed with error %d", ret);
		free(alt_stack->ss_sp);
		return;
	}
}