Jak ustalić, czy kod działa w kontekście obsługi sygnału?

Question

Właśnie się dowiedziałem, że ktoś dzwoni - od obsługi sygnału - zdecydowanie nie jest to funkcja bezpieczna dla sygnałów asynchronicznych, którą napisałem. I, oczywiście, obarczam się winą (pomimo ostrzeżeń w mojej dokumentacji). (Ten sam koder wywołuje wszystkie funkcje niesynchronizowane z sygnałem z jego nośnika sygnału.) Westchnienie.)

Więc teraz jestem ciekawy: jak uniknąć tej sytuacji? Chciałbym być w stanie łatwo określić, czy mój kod jest uruchomiony w kontekście procedury obsługi sygnału (język C, ale nie rozwiązanie stosuje się do każdego języka):

int myfunc(void) { 
    if(in_signal_handler_context()) { return(-1) } 
    // rest of function goes here 
    return(0); 
} 

to pod Linuksem. Mam nadzieję, że to nie jest łatwa odpowiedź, bo inaczej poczułbym się jak idiota.

Answer 1

Wygląda na to, że nowszy system Linux/x86 (prawdopodobnie od czasu pojawienia się jądra 2.6.x) wywołuje procedury obsługi sygnałów od vdso. Możesz użyć tego faktu, by zadać następujące okropne włamanie do niczego nie podejrzewającego świata:

#include <stdio.h> 
#include <stdlib.h> 
#include <stdint.h> 
#include <string.h> 
#include <signal.h> 

#include <unistd.h> 

uintmax_t vdso_start = 0; 
uintmax_t vdso_end = 0;    /* actually, next byte */ 

int check_stack_for_vdso(uint32_t *esp, size_t len) 
{ 
    size_t i; 

    for (i = 0; i < len; i++, esp++) 
      if (*esp >= vdso_start && *esp < vdso_end) 
        return 1; 

    return 0; 
} 

void handler(int signo) 
{ 
    uint32_t *esp; 

    __asm__ __volatile__ ("mov %%esp, %0" : "=r"(esp)); 
    /* XXX only for demonstration, don't call printf from a signal handler */ 
    printf("handler: check_stack_for_vdso() = %d\n", check_stack_for_vdso(esp, 20)); 
} 

void parse_maps() 
{ 
    FILE *maps; 
    char buf[256]; 
    char path[7]; 
    uintmax_t start, end, offset, inode; 
    char r, w, x, p; 
    unsigned major, minor; 

    maps = fopen("/proc/self/maps", "rt"); 
    if (maps == NULL) 
      return; 

    while (!feof(maps) && !ferror(maps)) { 
      if (fgets(buf, 256, maps) != NULL) { 
        if (sscanf(buf, "%jx-%jx %c%c%c%c %jx %u:%u %ju %6s", 
            &start, &end, &r, &w, &x, &p, &offset, 
            &major, &minor, &inode, path) == 11) { 
          if (!strcmp(path, "[vdso]")) { 
            vdso_start = start; 
            vdso_end = end; 
            break; 
          } 
        } 
      } 
    } 

    fclose(maps); 

    printf("[vdso] at %jx-%jx\n", vdso_start, vdso_end); 
} 

int main() 
{ 
    struct sigaction sa; 
    uint32_t *esp; 

    parse_maps(); 
    memset(&sa, 0, sizeof(struct sigaction)); 
    sa.sa_handler = handler; 
    sa.sa_flags = SA_RESTART; 

    if (sigaction(SIGUSR1, &sa, NULL) < 0) { 
      perror("sigaction"); 
      exit(1); 
    } 

    __asm__ __volatile__ ("mov %%esp, %0" : "=r"(esp)); 
    printf("before kill: check_stack_for_vdso() = %d\n", check_stack_for_vdso(esp, 20)); 

    kill(getpid(), SIGUSR1); 

    __asm__ __volatile__ ("mov %%esp, %0" : "=r"(esp)); 
    printf("after kill: check_stack_for_vdso() = %d\n", check_stack_for_vdso(esp, 20)); 

    return 0; 
} 

SCNR.

Answer 2

Istnieją dwa właściwe sposoby radzenia sobie z tym:

• Czy twoi współpracownicy przestać robić coś złego. Powodzenia z tym szefem ...

• Spraw, aby Twoja funkcja była ponownie dostępna i asynchroniczna. Jeśli to konieczne, podaj funkcję z innym podpisem (na przykład używając powszechnie używanej konwencji nazewnictwa) z dodatkowymi argumentami niezbędnymi do zachowania stanu.

chodzi o bez właściwego sposób to zrobić na Linuksie z LIBC można użyć backtrace() i przyjaciół, aby przejść do listy połączeń swojej funkcji. To nie łatwo dostać prawo, bezpieczne lub przenośny, ale może to zrobić na chwilę:

/* 
* *** Warning *** 
* 
* Black, fragile and unportable magic ahead 
* 
* Do not use this, lest the daemons of hell be unleashed upon you 
*/ 
int in_signal_handler_context() { 
     int i, n; 
     void *bt[1000]; 
     char **bts = NULL; 

     n = backtrace(bt, 1000); 
     bts = backtrace_symbols(bt, n); 

     for (i = 0; i < n; ++i) 
       printf("%i - %s\n", i, bts[i]); 

     /* Have a look at the caller chain */ 
     for (i = 0; i < n; ++i) { 
       /* Far more checks are needed here to avoid misfires */ 
       if (strstr(bts[i], "(__libc_start_main+") != NULL) 
         return 0; 
       if (strstr(bts[i], "libc.so.6(+") != NULL) 
         return 1; 
     } 

     return 0; 
} 


void unsafe() { 
     if (in_signal_handler_context()) 
       printf("John, you know you are an idiot, right?\n"); 
} 

W moim zdaniem, może być tylko lepiej rzucić zamiast być zmuszony do pisania kodu jak to.

Answer 3

Możesz coś wymyślić, używając sigaltstack. Skonfiguruj alternatywny stos sygnału, uzyskaj wskaźnik stosu w sposób asynchroniczny, jeśli w alternatywnym stosie będzie dalej, w przeciwnym razie przerywaj().

Answer 4

Zgaduję, że musisz wykonać następujące czynności. Jest to kompleksowe rozwiązanie, łączące najlepsze praktyki nie tylko z kodowaniem, ale także z inżynierią oprogramowania!

1. Przekonaj szefa, że ​​konwencja nazewnictwa dotycząca programów obsługi sygnałów jest dobrą rzeczą. Zaproponuj, na przykład, Hungarian notation, i powiedz, że był on używany w Microsoft z wielkim sukcesem. Wszystkie procedury obsługi sygnałów rozpoczynają się od sighnd, np. sighndInterrupt.
2. Twoja funkcja, która wykrywa kontekst obsługi sygnału byłoby wykonać następujące czynności:
   1. Pobierz backtrace().
   2. Sprawdź, czy którakolwiek z funkcji zaczyna się od sighnd.... Jeśli tak, to gratuluję, jesteś w obsłudze sygnału!
   3. W przeciwnym razie nie jesteś.
3. Spróbuj unikać pracy z Jimmy w tej samej firmie. "Może być tylko jeden", wiesz.

Answer 5

kodu zoptymalizowanego na -O2 lub lepsza (Istr) odkryli potrzebę dodania -fno-pomijanie-frame-pointer

inny gcc zoptymalizuje informacje kontekstowe stos

Answer 6

Jeśli możemy założyć swoje aplikacja nie blokuje ręcznie sygnałów za pomocą sigprocmask() lub pthread_sigmask(), to jest całkiem proste: uzyskaj bieżący identyfikator wątku (tid). Otwórz /proc/tid/status i uzyskaj wartości dla SigBlk i SigCgt. AND te dwie wartości. Jeśli wynik tego AND jest różny od zera, wątek ten jest aktualnie uruchomiony z wewnątrz procedury obsługi sygnału. Testowałem to sam i to działa.