Як виявити помилку сегментації в Linux?

Question 1

Мені потрібно виявити помилку сегментації в операціях очищення бібліотеки сторонніх виробників. Це трапляється іноді безпосередньо перед виходом моєї програми, і я не можу визначити справжню причину цього. У програмуванні Windows я міг зробити це за допомогою __try - __catch. Чи існує крос-платформенний або специфічний для платформи спосіб зробити те саме? Мені це потрібно в Linux, gcc.

Question 2

У Linux ми можемо мати це як виняток.

Зазвичай, коли ваша програма виконує помилку сегментації, їй надсилається SIGSEGVсигнал. Ви можете налаштувати власний обробник для цього сигналу та пом'якшити наслідки. Звичайно, ви дійсно повинні бути впевнені, що зможете виправити ситуацію. У вашому випадку, я думаю, вам слід замість цього налагодити ваш код.

Повернутися до теми. Нещодавно я зіткнувся з бібліотекою ( короткий посібник ), яка перетворює такі сигнали на винятки, тому ви можете написати такий код:

try
{
    *(int*) 0 = 0;
}
catch (std::exception& e)
{
    std::cerr << "Exception caught : " << e.what() << std::endl;
}

~~Однак не перевіряв.~~ Працює на моєму x86-64 Gentoo box. У нього є серверна база для платформи (запозичена з реалізації Java gcc), тому вона може працювати на багатьох платформах. Він просто підтримує x86 та x86-64 нестандартно, але ви можете отримати серверні файли з libjava, який знаходиться у джерелах gcc.

Question 3

Ось приклад того, як це зробити в C.

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

void segfault_sigaction(int signal, siginfo_t *si, void *arg)
{
    printf("Caught segfault at address %p\n", si->si_addr);
    exit(0);
}

int main(void)
{
    int *foo = NULL;
    struct sigaction sa;

    memset(&sa, 0, sizeof(struct sigaction));
    sigemptyset(&sa.sa_mask);
    sa.sa_sigaction = segfault_sigaction;
    sa.sa_flags   = SA_SIGINFO;

    sigaction(SIGSEGV, &sa, NULL);

    /* Cause a seg fault */
    *foo = 1;

    return 0;
}

Question 4

Для переносимості, мабуть, слід використовувати std::signalстандартну бібліотеку C ++, але існує багато обмежень щодо того, що може зробити обробник сигналу. На жаль, неможливо зловити SIGSEGV із програми C ++ без введення невизначеної поведінки, оскільки в специфікації сказано:

це невизначене поведінку для виклику будь-бібліотечної функції з обробника, крім дуже вузького підмножини стандартних бібліотечних функцій ( abort, exit, деякі атомарні функцій, переустановите поточний обробник сигналу memcpy, memmove, риси типу, `ЗОГО :: рухатися , std::forward, і ще трохи ).
це невизначена поведінка, якщо обробник використовує throwвираз.
це невизначена поведінка, якщо обробник повертається при обробці SIGFPE, SIGILL, SIGSEGV

Це доводить, що неможливо зловити SIGSEGV із програми використовуючи строго стандартний та портативний C ++. SIGSEGV все ще перехоплюється операційною системою і зазвичай повідомляється батьківському процесу при виклику функції сімейства очікування .

Можливо, ви зіткнетеся з такою ж проблемою із використанням сигналу POSIX, оскільки в пункті 2.4.3 „Сигнальні дії” є пункт :

Поведінка процесу є невизначеним після того, як він повертається , як правило з функції сигналу виділяються для SIGBUS, SIGFPE, SIGILL, або сигналу SIGSEGV , який не був генеруються kill(), sigqueue()абоraise() .

Слово про longjumpс. Припускаючи, що ми використовуємо сигнали POSIX, використовуючиlongjump для імітації розмотування стека не допоможе:

Хоча longjmp()це функція, безпечна для асинхронного сигналу, якщо вона викликається від обробника сигналу, який перервав функцію, що не захищає асинхронний сигнал, або еквівалент (наприклад, обробка, еквівалентна exit()виконуваній після повернення з початкового виклику до main()), поведінка будь-якого наступного виклику функції, що не захищає асинхронний сигнал, або еквівалента не визначена.

Це означає , що продовження викликається при виклику LongJump не може надійно називають зазвичай корисну бібліотеку функції , такими як printf, mallocабо exitчи повернення з основних , не викликаючи невизначений поведінка. Таким чином, продовження може виконувати лише обмежені операції і може виходити лише через якийсь ненормальний механізм припинення.

Якщо коротко сказати, зловити SIGSEGV і відновити виконання програми в портативному комп'ютері, можливо, неможливо без введення UB. Навіть якщо ви працюєте на платформі Windows, для якої у вас є доступ до структурованої обробки винятків, варто зазначити, що MSDN рекомендує ніколи не намагатися обробляти апаратні винятки: Виключення апаратного забезпечення

Question 5

Рішення C ++ знайдено тут ( http://www.cplusplus.com/forum/unices/16430/ )

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void ouch(int sig)
{
    printf("OUCH! - I got signal %d\n", sig);
}
int main()
{
    struct sigaction act;
    act.sa_handler = ouch;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGINT, &act, 0);
    while(1) {
        printf("Hello World!\n");
        sleep(1);
    }
}

Question 6

Іноді ми хочемо зловити a SIGSEGV щоб з’ясувати, чи є покажчик дійсним, тобто якщо він посилається на дійсну адресу пам’яті. (Або навіть перевірити, чи може якесь довільне значення бути покажчиком.)

Один із варіантів - перевірити його isValidPtr()(працював на Android):

int isValidPtr(const void*p, int len) {
    if (!p) {
    return 0;
    }
    int ret = 1;
    int nullfd = open("/dev/random", O_WRONLY);
    if (write(nullfd, p, len) < 0) {
    ret = 0;
    /* Not OK */
    }
    close(nullfd);
    return ret;
}
int isValidOrNullPtr(const void*p, int len) {
    return !p||isValidPtr(p, len);
}

Інший варіант - прочитати атрибути захисту пам’яті, що трохи складніше (працює на Android):

re_mprot.c:

#include <errno.h>
#include <malloc.h>
//#define PAGE_SIZE 4096
#include "dlog.h"
#include "stdlib.h"
#include "re_mprot.h"

struct buffer {
    int pos;
    int size;
    char* mem;
};

char* _buf_reset(struct buffer*b) {
    b->mem[b->pos] = 0;
    b->pos = 0;
    return b->mem;
}

struct buffer* _new_buffer(int length) {
    struct buffer* res = malloc(sizeof(struct buffer)+length+4);
    res->pos = 0;
    res->size = length;
    res->mem = (void*)(res+1);
    return res;
}

int _buf_putchar(struct buffer*b, int c) {
    b->mem[b->pos++] = c;
    return b->pos >= b->size;
}

void show_mappings(void)
{
    DLOG("-----------------------------------------------\n");
    int a;
    FILE *f = fopen("/proc/self/maps", "r");
    struct buffer* b = _new_buffer(1024);
    while ((a = fgetc(f)) >= 0) {
    if (_buf_putchar(b,a) || a == '\n') {
        DLOG("/proc/self/maps: %s",_buf_reset(b));
    }
    }
    if (b->pos) {
    DLOG("/proc/self/maps: %s",_buf_reset(b));
    }
    free(b);
    fclose(f);
    DLOG("-----------------------------------------------\n");
}

unsigned int read_mprotection(void* addr) {
    int a;
    unsigned int res = MPROT_0;
    FILE *f = fopen("/proc/self/maps", "r");
    struct buffer* b = _new_buffer(1024);
    while ((a = fgetc(f)) >= 0) {
    if (_buf_putchar(b,a) || a == '\n') {
        char*end0 = (void*)0;
        unsigned long addr0 = strtoul(b->mem, &end0, 0x10);
        char*end1 = (void*)0;
        unsigned long addr1 = strtoul(end0+1, &end1, 0x10);
        if ((void*)addr0 < addr && addr < (void*)addr1) {
            res |= (end1+1)[0] == 'r' ? MPROT_R : 0;
            res |= (end1+1)[1] == 'w' ? MPROT_W : 0;
            res |= (end1+1)[2] == 'x' ? MPROT_X : 0;
            res |= (end1+1)[3] == 'p' ? MPROT_P
                 : (end1+1)[3] == 's' ? MPROT_S : 0;
            break;
        }
        _buf_reset(b);
    }
    }
    free(b);
    fclose(f);
    return res;
}

int has_mprotection(void* addr, unsigned int prot, unsigned int prot_mask) {
    unsigned prot1 = read_mprotection(addr);
    return (prot1 & prot_mask) == prot;
}

char* _mprot_tostring_(char*buf, unsigned int prot) {
    buf[0] = prot & MPROT_R ? 'r' : '-';
    buf[1] = prot & MPROT_W ? 'w' : '-';
    buf[2] = prot & MPROT_X ? 'x' : '-';
    buf[3] = prot & MPROT_S ? 's' : prot & MPROT_P ? 'p' :  '-';
    buf[4] = 0;
    return buf;
}

re_mprot.h:

#include <alloca.h>
#include "re_bits.h"
#include <sys/mman.h>

void show_mappings(void);

enum {
    MPROT_0 = 0, // not found at all
    MPROT_R = PROT_READ,                                 // readable
    MPROT_W = PROT_WRITE,                                // writable
    MPROT_X = PROT_EXEC,                                 // executable
    MPROT_S = FIRST_UNUSED_BIT(MPROT_R|MPROT_W|MPROT_X), // shared
    MPROT_P = MPROT_S<<1,                                // private
};

// returns a non-zero value if the address is mapped (because either MPROT_P or MPROT_S will be set for valid addresses)
unsigned int read_mprotection(void* addr);

// check memory protection against the mask
// returns true if all bits corresponding to non-zero bits in the mask
// are the same in prot and read_mprotection(addr)
int has_mprotection(void* addr, unsigned int prot, unsigned int prot_mask);

// convert the protection mask into a string. Uses alloca(), no need to free() the memory!
#define mprot_tostring(x) ( _mprot_tostring_( (char*)alloca(8) , (x) ) )
char* _mprot_tostring_(char*buf, unsigned int prot);

PS DLOG()- printf()це журнал Android. FIRST_UNUSED_BIT()визначено тут .

PPS Можливо, не є гарною ідеєю викликати alloca () у циклі - пам’ять може не звільнятися, поки функція не повернеться.