lkml.org 
[lkml]   [2009]   [Mar]   [14]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
From
SubjectSignal delivery order
Date
(Please CC me, I'm not subscribed.)

Attached is a test program that tests the order in which synchronously
triggered sigsegvs and pthread_kill() generated signals get delivered.

The test program triggers sigsegvs from a thread and tests whether the
the sigsegv handler is invoked when the sigusr1 handler is already
running. If that happens it exits with exit code 27. It seems that if
the signal is sent by pthread_kill() and its signum is lower than that
of sigsegv then it can be delivered before sigsegv. A normal kill does
not seem to do this.

I would expect that no asynchronously generated signal (and here I
include those sent by pthread_kill()) can overtake a sigsegv even if
its signum is lower.

Reaching this diagnosis led me to an identical looking issue documented
at: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4355769 .

Cheers,
Gabor Melis

PS: tested on x86 linux Debian Lenny, kernel: 2.6.26-1-686, glibc:
2.7-18
#include <signal.h>
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/mman.h>
#include <sys/ucontext.h>
#include <unistd.h>

int test_signal;
int *page_address;
pthread_t tid;

int is_signal_blocked(int signum)
{
sigset_t set;
pthread_sigmask(SIG_BLOCK, 0, &set);
return (sigismember(&set, signum));
}

void test_handler(int signal, siginfo_t *info, void *context)
{
}

void sigsegv_handler(int signal, siginfo_t *info, void *context)
{
/* The test signal is blocked only in test_handler. */
if (is_signal_blocked(test_signal)) {
_exit(27);
}
mprotect(page_address, 4096, PROT_READ | PROT_WRITE);
}

void *make_faults(void *arg)
{
while (1) {
mprotect(page_address, 4096, PROT_NONE);
*page_address = 1;
}
}

void *reserve_page(void)
{
int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
void *actual = mmap(0, 4096, PROT_NONE, flags, -1, 0);
if (actual == MAP_FAILED) {
perror("mmap");
return 0;
}
return actual;
}

void install_handlers(void)
{
struct sigaction sa;
sa.sa_flags = SA_SIGINFO;
sigemptyset(&sa.sa_mask);
sa.sa_sigaction = test_handler;
sigaction(test_signal, &sa, 0);
sa.sa_sigaction = sigsegv_handler;
sigaction(SIGSEGV, &sa, 0);
}

void test_with_pthread_kill()
{
page_address = (int *)reserve_page();
install_handlers();
if (pthread_create(&tid, 0, make_faults, 0) < 0)
perror("pthread_create");
while(1) {
pthread_kill(tid, test_signal);
}
}

void test_with_kill()
{
pid_t pid = fork();
if (pid == 0) {
page_address = (int *)reserve_page();
install_handlers();
make_faults(0);
} else {
while (1) {
kill(pid, test_signal);
}
}
}

int main(void)
{
test_signal = SIGUSR1;
test_with_pthread_kill();
/* Forking and kill()ing works as expected: */
/* test_with_kill(); */
}
\
 
 \ /
  Last update: 2009-03-14 17:53    [W:0.057 / U:53.440 seconds]
©2003-2018 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site