coredump


Предыдущая | Следующая
  • https://coderoad.ru/17965/%D0%9A%D0%B0%D0%BA-%D1%81%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B4%D0%B0%D0%BC%D0%BF-%D1%8F%D0%B4%D1%80%D0%B0-%D0%B2-Linux-%D0%BD%D0%B0-segmentation-faulthttps://coderoad.ru/17965/%D0%9A%D0%B0%D0%BA-%D1%81%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B4%D0%B0%D0%BC%D0%BF-%D1%8F%D0%B4%D1%80%D0%B0-%D0%B2-Linux-%D0%BD%D0%B0-segmentation-faulthttps://coderoad.ru/17965/%D0%9A%D0%B0%D0%BA-%D1%81%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B4%D0%B0%D0%BC%D0%BF-%D1%8F%D0%B4%D1%80%D0%B0-%D0%B2-Linux-%D0%BD%D0%B0-segmentation-faulthttps://coderoad.ru/17965/%D0%9A%D0%B0%D0%BA-%D1%81%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B4%D0%B0%D0%BC%D0%BF-%D1%8F%D0%B4%D1%80%D0%B0-%D0%B2-Linux-%D0%BD%D0%B0-segmentation-faulthttps://coderoad.ru/17965/%D0%9A%D0%B0%D0%BA-%D1%81%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B4%D0%B0%D0%BC%D0%BF-%D1%8F%D0%B4%D1%80%D0%B0-%D0%B2-Linux-%D0%BD%D0%B0-segmentation-faulthttps://coderoad.ru/17965/%D0%9A%D0%B0%D0%BA-%D1%81%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B4%D0%B0%D0%BC%D0%BF-%D1%8F%D0%B4%D1%80%D0%B0-%D0%B2-Linux-%D0%BD%D0%B0-segmentation-faulthttps://coderoad.ru/17965/%D0%9A%D0%B0%D0%BA-%D1%81%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B4%D0%B0%D0%BC%D0%BF-%D1%8F%D0%B4%D1%80%D0%B0-%D0%B2-Linux-%D0%BD%D0%B0-segmentation-faulthttps://coderoad.ru/17965/%D0%9A%D0%B0%D0%BA-%D1%81%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B4%D0%B0%D0%BC%D0%BF-%D1%8F%D0%B4%D1%80%D0%B0-%D0%B2-Linux-%D0%BD%D0%B0-segmentation-faulthttps://coderoad.ru/17965/%D0%9A%D0%B0%D0%BA-%D1%81%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B4%D0%B0%D0%BC%D0%BF-%D1%8F%D0%B4%D1%80%D0%B0-%D0%B2-Linux-%D0%BD%D0%B0-segmentation-faulthttps://coderoad.ru/17965/%D0%9A%D0%B0%D0%BA-%D1%81%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B4%D0%B0%D0%BC%D0%BF-%D1%8F%D0%B4%D1%80%D0%B0-%D0%B2-Linux-%D0%BD%D0%B0-segmentation-fault

  • Я получаю ошибку сегментации (дамп ядра) в следующем коде: void Update_Log( ) { struct logData update; int file; char *writeBuffer=NULL; if((file=creat(/home/user/Desktop/DMS/DMS/filename.txt,O_RDONLY|O_WRONLY))==-1) perror(file not opened); update.clientName=user; update.filename=user;...

  • Linux: дамп ядра о сигнале 4

    На платформе linux моя прикладная программа иногда получала дамп ядра из-за сигнала 4. И я нахожу, что сигнал 4 означает незаконную инструкцию. Поэтому у меня есть один вопрос: Как получить незаконную инструкцию и что может вызвать дамп ядра signal 4.



254
 

Это зависит от того, какой shell вы используете. Если вы используете bash, то команда ulimit управляет несколькими настройками, связанными с выполнением программы,например, следует ли сбрасывать ядро. Если вы наберете

ulimit -c unlimited

тогда это скажет bash, что его программы могут сбрасывать ядра любого размера. Вы можете указать размер, например 52M вместо неограниченного, если хотите, но на практике это не должно быть необходимо, так как размер основных файлов, вероятно, никогда не будет проблемой для вас.

В tcsh вы бы набрали

limit coredumpsize unlimited
Eli Courtwright   20 августа 2008 в 13:50


60
 

Как было объяснено выше, реальный вопрос, который здесь задается, заключается в том, как включить дампы ядра в системе, где они не включены. Ответ на этот вопрос ДАН здесь.

Если вы пришли сюда в надежде узнать, как создать дамп ядра для зависшего процесса, то ответ таков:

gcore <pid>

если gcore недоступен в вашей системе, то

kill -ABRT <pid>

Не используйте kill -SEGV, так как это часто вызывает обработчик сигнала, что затрудняет диагностику застрявшего процесса

George Co   05 февраля 2013 в 14:28


33
 

Чтобы проверить, где генерируются дампы ядра, выполните:

sysctl kernel.core_pattern

или:

cat /proc/sys/kernel/core_pattern

где %e - имя процесса, а %t -системное время. Вы можете изменить его в /etc/sysctl.conf и перезагрузить на sysctl -p .

Если основные файлы не сгенерированы (проверьте их по: sleep 10 & и killall -SIGSEGV sleep), проверьте ограничения по: ulimit -a .

Если размер вашего основного файла ограничен, запустите:

ulimit -c unlimited

чтобы сделать его неограниченным.

Затем проверьте еще раз, если сброс ядра прошел успешно, вы увидите “(Сброс ядра)” после указания segmentation fault, как показано ниже:

Segmentation fault: 11 (ядро бросила)

См. также: Core dumped - но основной файл не находится в текущем каталоге?


Ubuntu

В Ubuntu основные дампы обрабатываются Apport и могут быть расположены в /var/crash/ . Однако в стабильных выпусках он по умолчанию отключен.

Для получения более подробной информации, пожалуйста, проверьте: где я могу найти дамп ядра в Ubuntu? .

macOS

Для macOS см.: Как генерировать дампы ядра в Mac OS X?

kenorb   08 сентября 2015 в 15:27

  • segmentation fault (дамп памяти)

    Я получаю ошибку сегментации (дамп ядра), когда пытаюсь запустить это. Он прекрасно компилируется, но я получаю ошибку, и я не знаю почему. Я пытался редактировать свой код всеми возможными способами, но все еще получаю эту ошибку. У меня уже кончились идеи. Любая помощь была бы очень кстати....

  • Linux: обработка segmentation fault и получение дампа ядра

    Когда мое приложение выходит из строя с segmentation fault, я хотел бы получить дамп ядра из системы. Я делаю это, настраивая перед рукой ulimit -c unlimited Я также хотел бы иметь указание в моих журналах приложений, что произошло segmentation fault. Я делаю это с помощью sigaction() . Однако...

 


27
 

В конце концов я прикрепил gdb к процессу до того, как он разбился, а затем, когда он получил segfault, я выполнил команду generate-core-file . Это вынужденная генерация дампа ядра.

Nathan Fellman   20 августа 2008 в 17:33


19
 

Может быть, вы могли бы сделать это таким образом, эта программа является демонстрацией того, как поймать a segmentation fault и вывести его на отладчик (это исходный код, используемый под AIX ) и напечатать стек trace до точки A segmentation fault. Вам нужно будет изменить переменную sprintf , чтобы использовать gdb в случае Linux.

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <stdarg.h>static void signal_handler(int);
static void dumpstack(void);
static void cleanup(void);
void init_signals(void);
void panic(const char *, ...);struct sigaction sigact;
char *progname;int main(int argc, char **argv) {
    char *s;
    progname = *(argv);
    atexit(cleanup);
    init_signals();
    printf("About to seg fault by assigning zero to *s\n");
    *s = 0;
    sigemptyset(&sigact.sa_mask);
    return 0;
}void init_signals(void) {
    sigact.sa_handler = signal_handler;
    sigemptyset(&sigact.sa_mask);
    sigact.sa_flags = 0;
    sigaction(SIGINT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGSEGV);
    sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGBUS);
    sigaction(SIGBUS, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGQUIT);
    sigaction(SIGQUIT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGHUP);
    sigaction(SIGHUP, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGKILL);
    sigaction(SIGKILL, &sigact, (struct sigaction *)NULL);
}static void signal_handler(int sig) {
    if (sig == SIGHUP) panic("FATAL: Program hanged up\n");
    if (sig == SIGSEGV || sig == SIGBUS){
        dumpstack();
        panic("FATAL: %s Fault. Logged StackTrace\n", (sig == SIGSEGV) ? "Segmentation" : ((sig == SIGBUS) ? "Bus" : "Unknown"));
    }
    if (sig == SIGQUIT) panic("QUIT signal ended program\n");
    if (sig == SIGKILL) panic("KILL signal ended program\n");
    if (sig == SIGINT) ;
}void panic(const char *fmt, ...) {
    char buf[50];
    va_list argptr;
    va_start(argptr, fmt);
    vsprintf(buf, fmt, argptr);
    va_end(argptr);
    fprintf(stderr, buf);
    exit(-1);
}static void dumpstack(void) {
    /* Got this routine from http://www.whitefang.com/unix/faq_toc.html
    ** Section 6.5. Modified to redirect to file to prevent clutter
    */
    /* This needs to be changed... */
    char dbx[160];    sprintf(dbx, "echo 'where\ndetach' | dbx -a %d > %s.dump", getpid(), progname);
    /* Change the dbx to gdb */    system(dbx);
    return;
}void cleanup(void) {
    sigemptyset(&sigact.sa_mask);
    /* Do any cleaning up chores here */
}

Возможно ,вам придется дополнительно добавить параметр, чтобы получить gdb для сброса ядра, как показано здесь в этом блоге.

t0mm13b   26 января 2010 в 13:46


16
 

Есть еще много вещей, которые могут повлиять на генерацию дампа ядра. Я столкнулся с этим:

  • каталог для дампа должен быть доступен для записи. По умолчанию это текущий каталог процесса, но его можно изменить, установив /proc/sys/kernel/core_pattern .
  • в некоторых условиях значение kernel в /proc/sys/fs/suid_dumpable может препятствовать созданию ядра.

Есть и другие ситуации, которые могут помешать генерации, описанные на справочной странице-попробуйте man core .

mlutescu   08 февраля 2012 в 10:07


10
 

Для Ubuntu 14.04

  1. Проверьте, включен ли дамп ядра:

    ulimit -a
  2. Одна из линий должна быть :

    core file size          (blocks, -c) unlimited
  3. Если нет :

    gedit ~/.bashrc и добавьте ulimit -c unlimited в конец файла и сохраните, повторно запустите terminal.

  4. Создайте свое приложение с помощью отладочной информации :

    В Makefile -O0 -g

  5. Запустите приложение, создающее дамп ядра (файл дампа ядра с именем ' core’ должен быть создан рядом с файлом application_name):

    ./application_name
  6. Работать под gdb:

    gdb application_name core
mrgloom   02 марта 2016 в 12:25


9
 

Для того, чтобы активировать соответствующий дамп памяти, выполните следующие действия:

  1. В /etc/profile прокомментируйте строку:

    # ulimit -S -c 0 > /dev/null 2>&1
  2. В /etc/security/limits.conf закомментируйте строку:

    *               soft    core            0
  3. выполните cmd limit coredumpsize unlimited и проверьте его с помощью cmd limit :

    # limit coredumpsize unlimited
    # limit
    cputime      unlimited
    filesize     unlimited
    datasize     unlimited
    stacksize    10240 kbytes
    coredumpsize unlimited
    memoryuse    unlimited
    vmemoryuse   unlimited
    descriptors  1024
    memorylocked 32 kbytes
    maxproc      528383
    #
  4. чтобы проверить, записан ли основной файл, вы можете убить связанный процесс с помощью cmd kill -s SEGV <PID> (не нужно, просто на случай, если основной файл не будет записан, это можно использовать в качестве проверки):

    # kill -s SEGV <PID>

Как только corefile будет записан, убедитесь, что вы снова деактивировали настройки coredump в соответствующих файлах (1./2./3.)!

Edgar Jordi   19 октября 2012 в 06:34


4
 

По умолчанию вы получите основной файл. Убедитесь, что текущий каталог процесса доступен для записи, иначе основной файл не будет создан.

Mark Harrison   20 августа 2008 в 14:38


2
 

Лучше включить дамп ядра программно, используя системный вызов setrlimit .

пример:

#include <sys/resource.h>bool enable_core_dump(){    
    struct rlimit corelim;    corelim.rlim_cur = RLIM_INFINITY;
    corelim.rlim_max = RLIM_INFINITY;    return (0 == setrlimit(RLIMIT_CORE, &corelim));
}
kgbook   24 августа 2018 в 08:52


1
 

Стоит отметить, что если у вас есть настроенный systemd , то все немного по-другому. Настройка, как правило, есть основные файлы могут передавать посредством core_pattern значение параметра, через systemd-coredump(8) . Базовый размер файла rlimit, как правило, настраивается как уже "unlimited".

Затем можно получить дампы ядра с помощью coredumpctl(1) .

Хранение дампов ядра и т. д. настраивается coredump.conf(5) . Есть примеры того, как получить основные файлы на man-странице coredumpctl, но вкратце это будет выглядеть так:

Найти системный файл:

[vps@phoenix]~$ coredumpctl list test_me | tail -1
Sun 2019-01-20 11:17:33 CET   16163  1224  1224  11 present /home/vps/test_me

Получить основной файл:

[vps@phoenix]~$ coredumpctl -o test_me.core dump 16163
Pawel Veselov   20 января 2019 в 10:59


1
 

Ubuntu 19.04

Все остальные ответы сами по себе мне не помогли. Но следующий итог сделал свое дело

Создайте ~/.config/apport/settings со следующим содержимым:

[main]
unpackaged=true

(Это говорит apport также писать основные дампы для пользовательских приложений)

Регистрация: ulimit -c . Если он выводит 0, исправьте его с помощью

ulimit -c unlimited

Просто на всякий случай перезагрузите Аппорт:

sudo systemctl restart apport

Файлы сбоев теперь записываются в /var/crash/ . Но вы не можете использовать их с gdb. Чтобы использовать их с gdb, используйте

apport-unpack <location_of_report> <target_directory>

Дополнительная информация:

  • Некоторые ответы предполагают изменение core_pattern . Имейте в виду, что этот файл может быть перезаписан службой apport при перезапуске.
  • Просто остановка аппорта не сделала своей работы
  • Значение ulimit -c может быть изменено автоматически, пока вы пытаетесь найти другие ответы в интернете. Обязательно регулярно проверяйте его во время настройки создания дампа ядра.

Рекомендации:

  • https://stackoverflow.com/a/47481884/6702598
    • Я получаю ошибку сегментации (дамп ядра) в следующем коде: void Update_Log( ) { struct logData update; int file; char *writeBuffer=NULL; if((file=creat(/home/user/Desktop/DMS/DMS/filename.txt,O_RDONLY|O_WRONLY))==-1) perror(file not opened); update.clientName=user; update.filename=user;...

    • Linux: дамп ядра о сигнале 4

      На платформе linux моя прикладная программа иногда получала дамп ядра из-за сигнала 4. И я нахожу, что сигнал 4 означает незаконную инструкцию. Поэтому у меня есть один вопрос: Как получить незаконную инструкцию и что может вызвать дамп ядра signal 4.



    254
     

    Это зависит от того, какой shell вы используете. Если вы используете bash, то команда ulimit управляет несколькими настройками, связанными с выполнением программы,например, следует ли сбрасывать ядро. Если вы наберете

    ulimit -c unlimited

    тогда это скажет bash, что его программы могут сбрасывать ядра любого размера. Вы можете указать размер, например 52M вместо неограниченного, если хотите, но на практике это не должно быть необходимо, так как размер основных файлов, вероятно, никогда не будет проблемой для вас.

    В tcsh вы бы набрали

    limit coredumpsize unlimited
    Eli Courtwright   20 августа 2008 в 13:50


    60
     

    Как было объяснено выше, реальный вопрос, который здесь задается, заключается в том, как включить дампы ядра в системе, где они не включены. Ответ на этот вопрос ДАН здесь.

    Если вы пришли сюда в надежде узнать, как создать дамп ядра для зависшего процесса, то ответ таков:

    gcore <pid>

    если gcore недоступен в вашей системе, то

    kill -ABRT <pid>

    Не используйте kill -SEGV, так как это часто вызывает обработчик сигнала, что затрудняет диагностику застрявшего процесса

    George Co   05 февраля 2013 в 14:28


    33
     

    Чтобы проверить, где генерируются дампы ядра, выполните:

    sysctl kernel.core_pattern

    или:

    cat /proc/sys/kernel/core_pattern

    где %e - имя процесса, а %t -системное время. Вы можете изменить его в /etc/sysctl.conf и перезагрузить на sysctl -p .

    Если основные файлы не сгенерированы (проверьте их по: sleep 10 & и killall -SIGSEGV sleep), проверьте ограничения по: ulimit -a .

    Если размер вашего основного файла ограничен, запустите:

    ulimit -c unlimited

    чтобы сделать его неограниченным.

    Затем проверьте еще раз, если сброс ядра прошел успешно, вы увидите “(Сброс ядра)” после указания segmentation fault, как показано ниже:

    Segmentation fault: 11 (ядро бросила)

    См. также: Core dumped - но основной файл не находится в текущем каталоге?


    Ubuntu

    В Ubuntu основные дампы обрабатываются Apport и могут быть расположены в /var/crash/ . Однако в стабильных выпусках он по умолчанию отключен.

    Для получения более подробной информации, пожалуйста, проверьте: где я могу найти дамп ядра в Ubuntu? .

    macOS

    Для macOS см.: Как генерировать дампы ядра в Mac OS X?

    kenorb   08 сентября 2015 в 15:27

    • segmentation fault (дамп памяти)

      Я получаю ошибку сегментации (дамп ядра), когда пытаюсь запустить это. Он прекрасно компилируется, но я получаю ошибку, и я не знаю почему. Я пытался редактировать свой код всеми возможными способами, но все еще получаю эту ошибку. У меня уже кончились идеи. Любая помощь была бы очень кстати....

    • Linux: обработка segmentation fault и получение дампа ядра

      Когда мое приложение выходит из строя с segmentation fault, я хотел бы получить дамп ядра из системы. Я делаю это, настраивая перед рукой ulimit -c unlimited Я также хотел бы иметь указание в моих журналах приложений, что произошло segmentation fault. Я делаю это с помощью sigaction() . Однако...

     


    27
     

    В конце концов я прикрепил gdb к процессу до того, как он разбился, а затем, когда он получил segfault, я выполнил команду generate-core-file . Это вынужденная генерация дампа ядра.

    Nathan Fellman   20 августа 2008 в 17:33


    19
     

    Может быть, вы могли бы сделать это таким образом, эта программа является демонстрацией того, как поймать a segmentation fault и вывести его на отладчик (это исходный код, используемый под AIX ) и напечатать стек trace до точки A segmentation fault. Вам нужно будет изменить переменную sprintf , чтобы использовать gdb в случае Linux.

    #include <stdio.h>
    #include <signal.h>
    #include <stdlib.h>
    #include <stdarg.h>static void signal_handler(int);
    static void dumpstack(void);
    static void cleanup(void);
    void init_signals(void);
    void panic(const char *, ...);struct sigaction sigact;
    char *progname;int main(int argc, char **argv) {
        char *s;
        progname = *(argv);
        atexit(cleanup);
        init_signals();
        printf("About to seg fault by assigning zero to *s\n");
        *s = 0;
        sigemptyset(&sigact.sa_mask);
        return 0;
    }void init_signals(void) {
        sigact.sa_handler = signal_handler;
        sigemptyset(&sigact.sa_mask);
        sigact.sa_flags = 0;
        sigaction(SIGINT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGSEGV);
        sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGBUS);
        sigaction(SIGBUS, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGQUIT);
        sigaction(SIGQUIT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGHUP);
        sigaction(SIGHUP, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGKILL);
        sigaction(SIGKILL, &sigact, (struct sigaction *)NULL);
    }static void signal_handler(int sig) {
        if (sig == SIGHUP) panic("FATAL: Program hanged up\n");
        if (sig == SIGSEGV || sig == SIGBUS){
            dumpstack();
            panic("FATAL: %s Fault. Logged StackTrace\n", (sig == SIGSEGV) ? "Segmentation" : ((sig == SIGBUS) ? "Bus" : "Unknown"));
        }
        if (sig == SIGQUIT) panic("QUIT signal ended program\n");
        if (sig == SIGKILL) panic("KILL signal ended program\n");
        if (sig == SIGINT) ;
    }void panic(const char *fmt, ...) {
        char buf[50];
        va_list argptr;
        va_start(argptr, fmt);
        vsprintf(buf, fmt, argptr);
        va_end(argptr);
        fprintf(stderr, buf);
        exit(-1);
    }static void dumpstack(void) {
        /* Got this routine from http://www.whitefang.com/unix/faq_toc.html
        ** Section 6.5. Modified to redirect to file to prevent clutter
        */
        /* This needs to be changed... */
        char dbx[160];    sprintf(dbx, "echo 'where\ndetach' | dbx -a %d > %s.dump", getpid(), progname);
        /* Change the dbx to gdb */    system(dbx);
        return;
    }void cleanup(void) {
        sigemptyset(&sigact.sa_mask);
        /* Do any cleaning up chores here */
    }

    Возможно ,вам придется дополнительно добавить параметр, чтобы получить gdb для сброса ядра, как показано здесь в этом блоге.

    t0mm13b   26 января 2010 в 13:46


    16
     

    Есть еще много вещей, которые могут повлиять на генерацию дампа ядра. Я столкнулся с этим:

    • каталог для дампа должен быть доступен для записи. По умолчанию это текущий каталог процесса, но его можно изменить, установив /proc/sys/kernel/core_pattern .
    • в некоторых условиях значение kernel в /proc/sys/fs/suid_dumpable может препятствовать созданию ядра.

    Есть и другие ситуации, которые могут помешать генерации, описанные на справочной странице-попробуйте man core .

    mlutescu   08 февраля 2012 в 10:07


    10
     

    Для Ubuntu 14.04

    1. Проверьте, включен ли дамп ядра:

      ulimit -a
    2. Одна из линий должна быть :

      core file size          (blocks, -c) unlimited
    3. Если нет :

      gedit ~/.bashrc и добавьте ulimit -c unlimited в конец файла и сохраните, повторно запустите terminal.

    4. Создайте свое приложение с помощью отладочной информации :

      В Makefile -O0 -g

    5. Запустите приложение, создающее дамп ядра (файл дампа ядра с именем ' core’ должен быть создан рядом с файлом application_name):

      ./application_name
    6. Работать под gdb:

      gdb application_name core
    mrgloom   02 марта 2016 в 12:25


    9
     

    Для того, чтобы активировать соответствующий дамп памяти, выполните следующие действия:

    1. В /etc/profile прокомментируйте строку:

      # ulimit -S -c 0 > /dev/null 2>&1
    2. В /etc/security/limits.conf закомментируйте строку:

      *               soft    core            0
    3. выполните cmd limit coredumpsize unlimited и проверьте его с помощью cmd limit :

      # limit coredumpsize unlimited
      # limit
      cputime      unlimited
      filesize     unlimited
      datasize     unlimited
      stacksize    10240 kbytes
      coredumpsize unlimited
      memoryuse    unlimited
      vmemoryuse   unlimited
      descriptors  1024
      memorylocked 32 kbytes
      maxproc      528383
      #
    4. чтобы проверить, записан ли основной файл, вы можете убить связанный процесс с помощью cmd kill -s SEGV <PID> (не нужно, просто на случай, если основной файл не будет записан, это можно использовать в качестве проверки):

      # kill -s SEGV <PID>

    Как только corefile будет записан, убедитесь, что вы снова деактивировали настройки coredump в соответствующих файлах (1./2./3.)!

    Edgar Jordi   19 октября 2012 в 06:34


    4
     

    По умолчанию вы получите основной файл. Убедитесь, что текущий каталог процесса доступен для записи, иначе основной файл не будет создан.

    Mark Harrison   20 августа 2008 в 14:38


    2
     

    Лучше включить дамп ядра программно, используя системный вызов setrlimit .

    пример:

    #include <sys/resource.h>bool enable_core_dump(){    
        struct rlimit corelim;    corelim.rlim_cur = RLIM_INFINITY;
        corelim.rlim_max = RLIM_INFINITY;    return (0 == setrlimit(RLIMIT_CORE, &corelim));
    }
    kgbook   24 августа 2018 в 08:52


    1
     

    Стоит отметить, что если у вас есть настроенный systemd , то все немного по-другому. Настройка, как правило, есть основные файлы могут передавать посредством core_pattern значение параметра, через systemd-coredump(8) . Базовый размер файла rlimit, как правило, настраивается как уже "unlimited".

    Затем можно получить дампы ядра с помощью coredumpctl(1) .

    Хранение дампов ядра и т. д. настраивается coredump.conf(5) . Есть примеры того, как получить основные файлы на man-странице coredumpctl, но вкратце это будет выглядеть так:

    Найти системный файл:

    [vps@phoenix]~$ coredumpctl list test_me | tail -1
    Sun 2019-01-20 11:17:33 CET   16163  1224  1224  11 present /home/vps/test_me

    Получить основной файл:

    [vps@phoenix]~$ coredumpctl -o test_me.core dump 16163
    Pawel Veselov   20 января 2019 в 10:59


    1
     

    Ubuntu 19.04

    Все остальные ответы сами по себе мне не помогли. Но следующий итог сделал свое дело

    Создайте ~/.config/apport/settings со следующим содержимым:

    [main]
    unpackaged=true

    (Это говорит apport также писать основные дампы для пользовательских приложений)

    Регистрация: ulimit -c . Если он выводит 0, исправьте его с помощью

    ulimit -c unlimited

    Просто на всякий случай перезагрузите Аппорт:

    sudo systemctl restart apport

    Файлы сбоев теперь записываются в /var/crash/ . Но вы не можете использовать их с gdb. Чтобы использовать их с gdb, используйте

    apport-unpack <location_of_report> <target_directory>

    Дополнительная информация:

    • Некоторые ответы предполагают изменение core_pattern . Имейте в виду, что этот файл может быть перезаписан службой apport при перезапуске.
    • Просто остановка аппорта не сделала своей работы
    • Значение ulimit -c может быть изменено автоматически, пока вы пытаетесь найти другие ответы в интернете. Обязательно регулярно проверяйте его во время настройки создания дампа ядра.

    Рекомендации:

    • https://stackoverflow.com/a/47481884/6702598
      • Я получаю ошибку сегментации (дамп ядра) в следующем коде: void Update_Log( ) { struct logData update; int file; char *writeBuffer=NULL; if((file=creat(/home/user/Desktop/DMS/DMS/filename.txt,O_RDONLY|O_WRONLY))==-1) perror(file not opened); update.clientName=user; update.filename=user;...

      • Linux: дамп ядра о сигнале 4

        На платформе linux моя прикладная программа иногда получала дамп ядра из-за сигнала 4. И я нахожу, что сигнал 4 означает незаконную инструкцию. Поэтому у меня есть один вопрос: Как получить незаконную инструкцию и что может вызвать дамп ядра signal 4.



      254
       

      Это зависит от того, какой shell вы используете. Если вы используете bash, то команда ulimit управляет несколькими настройками, связанными с выполнением программы,например, следует ли сбрасывать ядро. Если вы наберете

      ulimit -c unlimited

      тогда это скажет bash, что его программы могут сбрасывать ядра любого размера. Вы можете указать размер, например 52M вместо неограниченного, если хотите, но на практике это не должно быть необходимо, так как размер основных файлов, вероятно, никогда не будет проблемой для вас.

      В tcsh вы бы набрали

      limit coredumpsize unlimited
      Eli Courtwright   20 августа 2008 в 13:50


      60
       

      Как было объяснено выше, реальный вопрос, который здесь задается, заключается в том, как включить дампы ядра в системе, где они не включены. Ответ на этот вопрос ДАН здесь.

      Если вы пришли сюда в надежде узнать, как создать дамп ядра для зависшего процесса, то ответ таков:

      gcore <pid>

      если gcore недоступен в вашей системе, то

      kill -ABRT <pid>

      Не используйте kill -SEGV, так как это часто вызывает обработчик сигнала, что затрудняет диагностику застрявшего процесса

      George Co   05 февраля 2013 в 14:28


      33
       

      Чтобы проверить, где генерируются дампы ядра, выполните:

      sysctl kernel.core_pattern

      или:

      cat /proc/sys/kernel/core_pattern

      где %e - имя процесса, а %t -системное время. Вы можете изменить его в /etc/sysctl.conf и перезагрузить на sysctl -p .

      Если основные файлы не сгенерированы (проверьте их по: sleep 10 & и killall -SIGSEGV sleep), проверьте ограничения по: ulimit -a .

      Если размер вашего основного файла ограничен, запустите:

      ulimit -c unlimited

      чтобы сделать его неограниченным.

      Затем проверьте еще раз, если сброс ядра прошел успешно, вы увидите “(Сброс ядра)” после указания segmentation fault, как показано ниже:

      Segmentation fault: 11 (ядро бросила)

      См. также: Core dumped - но основной файл не находится в текущем каталоге?


      Ubuntu

      В Ubuntu основные дампы обрабатываются Apport и могут быть расположены в /var/crash/ . Однако в стабильных выпусках он по умолчанию отключен.

      Для получения более подробной информации, пожалуйста, проверьте: где я могу найти дамп ядра в Ubuntu? .

      macOS

      Для macOS см.: Как генерировать дампы ядра в Mac OS X?

      kenorb   08 сентября 2015 в 15:27

      • segmentation fault (дамп памяти)

        Я получаю ошибку сегментации (дамп ядра), когда пытаюсь запустить это. Он прекрасно компилируется, но я получаю ошибку, и я не знаю почему. Я пытался редактировать свой код всеми возможными способами, но все еще получаю эту ошибку. У меня уже кончились идеи. Любая помощь была бы очень кстати....

      • Linux: обработка segmentation fault и получение дампа ядра

        Когда мое приложение выходит из строя с segmentation fault, я хотел бы получить дамп ядра из системы. Я делаю это, настраивая перед рукой ulimit -c unlimited Я также хотел бы иметь указание в моих журналах приложений, что произошло segmentation fault. Я делаю это с помощью sigaction() . Однако...

       


      27
       

      В конце концов я прикрепил gdb к процессу до того, как он разбился, а затем, когда он получил segfault, я выполнил команду generate-core-file . Это вынужденная генерация дампа ядра.

      Nathan Fellman   20 августа 2008 в 17:33


      19
       

      Может быть, вы могли бы сделать это таким образом, эта программа является демонстрацией того, как поймать a segmentation fault и вывести его на отладчик (это исходный код, используемый под AIX ) и напечатать стек trace до точки A segmentation fault. Вам нужно будет изменить переменную sprintf , чтобы использовать gdb в случае Linux.

      #include <stdio.h>
      #include <signal.h>
      #include <stdlib.h>
      #include <stdarg.h>static void signal_handler(int);
      static void dumpstack(void);
      static void cleanup(void);
      void init_signals(void);
      void panic(const char *, ...);struct sigaction sigact;
      char *progname;int main(int argc, char **argv) {
          char *s;
          progname = *(argv);
          atexit(cleanup);
          init_signals();
          printf("About to seg fault by assigning zero to *s\n");
          *s = 0;
          sigemptyset(&sigact.sa_mask);
          return 0;
      }void init_signals(void) {
          sigact.sa_handler = signal_handler;
          sigemptyset(&sigact.sa_mask);
          sigact.sa_flags = 0;
          sigaction(SIGINT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGSEGV);
          sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGBUS);
          sigaction(SIGBUS, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGQUIT);
          sigaction(SIGQUIT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGHUP);
          sigaction(SIGHUP, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGKILL);
          sigaction(SIGKILL, &sigact, (struct sigaction *)NULL);
      }static void signal_handler(int sig) {
          if (sig == SIGHUP) panic("FATAL: Program hanged up\n");
          if (sig == SIGSEGV || sig == SIGBUS){
              dumpstack();
              panic("FATAL: %s Fault. Logged StackTrace\n", (sig == SIGSEGV) ? "Segmentation" : ((sig == SIGBUS) ? "Bus" : "Unknown"));
          }
          if (sig == SIGQUIT) panic("QUIT signal ended program\n");
          if (sig == SIGKILL) panic("KILL signal ended program\n");
          if (sig == SIGINT) ;
      }void panic(const char *fmt, ...) {
          char buf[50];
          va_list argptr;
          va_start(argptr, fmt);
          vsprintf(buf, fmt, argptr);
          va_end(argptr);
          fprintf(stderr, buf);
          exit(-1);
      }static void dumpstack(void) {
          /* Got this routine from http://www.whitefang.com/unix/faq_toc.html
          ** Section 6.5. Modified to redirect to file to prevent clutter
          */
          /* This needs to be changed... */
          char dbx[160];    sprintf(dbx, "echo 'where\ndetach' | dbx -a %d > %s.dump", getpid(), progname);
          /* Change the dbx to gdb */    system(dbx);
          return;
      }void cleanup(void) {
          sigemptyset(&sigact.sa_mask);
          /* Do any cleaning up chores here */
      }

      Возможно ,вам придется дополнительно добавить параметр, чтобы получить gdb для сброса ядра, как показано здесь в этом блоге.

      t0mm13b   26 января 2010 в 13:46


      16
       

      Есть еще много вещей, которые могут повлиять на генерацию дампа ядра. Я столкнулся с этим:

      • каталог для дампа должен быть доступен для записи. По умолчанию это текущий каталог процесса, но его можно изменить, установив /proc/sys/kernel/core_pattern .
      • в некоторых условиях значение kernel в /proc/sys/fs/suid_dumpable может препятствовать созданию ядра.

      Есть и другие ситуации, которые могут помешать генерации, описанные на справочной странице-попробуйте man core .

      mlutescu   08 февраля 2012 в 10:07


      10
       

      Для Ubuntu 14.04

      1. Проверьте, включен ли дамп ядра:

        ulimit -a
      2. Одна из линий должна быть :

        core file size          (blocks, -c) unlimited
      3. Если нет :

        gedit ~/.bashrc и добавьте ulimit -c unlimited в конец файла и сохраните, повторно запустите terminal.

      4. Создайте свое приложение с помощью отладочной информации :

        В Makefile -O0 -g

      5. Запустите приложение, создающее дамп ядра (файл дампа ядра с именем ' core’ должен быть создан рядом с файлом application_name):

        ./application_name
      6. Работать под gdb:

        gdb application_name core
      mrgloom   02 марта 2016 в 12:25


      9
       

      Для того, чтобы активировать соответствующий дамп памяти, выполните следующие действия:

      1. В /etc/profile прокомментируйте строку:

        # ulimit -S -c 0 > /dev/null 2>&1
      2. В /etc/security/limits.conf закомментируйте строку:

        *               soft    core            0
      3. выполните cmd limit coredumpsize unlimited и проверьте его с помощью cmd limit :

        # limit coredumpsize unlimited
        # limit
        cputime      unlimited
        filesize     unlimited
        datasize     unlimited
        stacksize    10240 kbytes
        coredumpsize unlimited
        memoryuse    unlimited
        vmemoryuse   unlimited
        descriptors  1024
        memorylocked 32 kbytes
        maxproc      528383
        #
      4. чтобы проверить, записан ли основной файл, вы можете убить связанный процесс с помощью cmd kill -s SEGV <PID> (не нужно, просто на случай, если основной файл не будет записан, это можно использовать в качестве проверки):

        # kill -s SEGV <PID>

      Как только corefile будет записан, убедитесь, что вы снова деактивировали настройки coredump в соответствующих файлах (1./2./3.)!

      Edgar Jordi   19 октября 2012 в 06:34


      4
       

      По умолчанию вы получите основной файл. Убедитесь, что текущий каталог процесса доступен для записи, иначе основной файл не будет создан.

      Mark Harrison   20 августа 2008 в 14:38


      2
       

      Лучше включить дамп ядра программно, используя системный вызов setrlimit .

      пример:

      #include <sys/resource.h>bool enable_core_dump(){    
          struct rlimit corelim;    corelim.rlim_cur = RLIM_INFINITY;
          corelim.rlim_max = RLIM_INFINITY;    return (0 == setrlimit(RLIMIT_CORE, &corelim));
      }
      kgbook   24 августа 2018 в 08:52


      1
       

      Стоит отметить, что если у вас есть настроенный systemd , то все немного по-другому. Настройка, как правило, есть основные файлы могут передавать посредством core_pattern значение параметра, через systemd-coredump(8) . Базовый размер файла rlimit, как правило, настраивается как уже "unlimited".

      Затем можно получить дампы ядра с помощью coredumpctl(1) .

      Хранение дампов ядра и т. д. настраивается coredump.conf(5) . Есть примеры того, как получить основные файлы на man-странице coredumpctl, но вкратце это будет выглядеть так:

      Найти системный файл:

      [vps@phoenix]~$ coredumpctl list test_me | tail -1
      Sun 2019-01-20 11:17:33 CET   16163  1224  1224  11 present /home/vps/test_me

      Получить основной файл:

      [vps@phoenix]~$ coredumpctl -o test_me.core dump 16163
      Pawel Veselov   20 января 2019 в 10:59


      1
       

      Ubuntu 19.04

      Все остальные ответы сами по себе мне не помогли. Но следующий итог сделал свое дело

      Создайте ~/.config/apport/settings со следующим содержимым:

      [main]
      unpackaged=true

      (Это говорит apport также писать основные дампы для пользовательских приложений)

      Регистрация: ulimit -c . Если он выводит 0, исправьте его с помощью

      ulimit -c unlimited

      Просто на всякий случай перезагрузите Аппорт:

      sudo systemctl restart apport

      Файлы сбоев теперь записываются в /var/crash/ . Но вы не можете использовать их с gdb. Чтобы использовать их с gdb, используйте

      apport-unpack <location_of_report> <target_directory>

      Дополнительная информация:

      • Некоторые ответы предполагают изменение core_pattern . Имейте в виду, что этот файл может быть перезаписан службой apport при перезапуске.
      • Просто остановка аппорта не сделала своей работы
      • Значение ulimit -c может быть изменено автоматически, пока вы пытаетесь найти другие ответы в интернете. Обязательно регулярно проверяйте его во время настройки создания дампа ядра.

      Рекомендации:

      • https://stackoverflow.com/a/47481884/6702598
        • Я получаю ошибку сегментации (дамп ядра) в следующем коде: void Update_Log( ) { struct logData update; int file; char *writeBuffer=NULL; if((file=creat(/home/user/Desktop/DMS/DMS/filename.txt,O_RDONLY|O_WRONLY))==-1) perror(file not opened); update.clientName=user; update.filename=user;...

        • Linux: дамп ядра о сигнале 4

          На платформе linux моя прикладная программа иногда получала дамп ядра из-за сигнала 4. И я нахожу, что сигнал 4 означает незаконную инструкцию. Поэтому у меня есть один вопрос: Как получить незаконную инструкцию и что может вызвать дамп ядра signal 4.



        254
         

        Это зависит от того, какой shell вы используете. Если вы используете bash, то команда ulimit управляет несколькими настройками, связанными с выполнением программы,например, следует ли сбрасывать ядро. Если вы наберете

        ulimit -c unlimited

        тогда это скажет bash, что его программы могут сбрасывать ядра любого размера. Вы можете указать размер, например 52M вместо неограниченного, если хотите, но на практике это не должно быть необходимо, так как размер основных файлов, вероятно, никогда не будет проблемой для вас.

        В tcsh вы бы набрали

        limit coredumpsize unlimited
        Eli Courtwright   20 августа 2008 в 13:50


        60
         

        Как было объяснено выше, реальный вопрос, который здесь задается, заключается в том, как включить дампы ядра в системе, где они не включены. Ответ на этот вопрос ДАН здесь.

        Если вы пришли сюда в надежде узнать, как создать дамп ядра для зависшего процесса, то ответ таков:

        gcore <pid>

        если gcore недоступен в вашей системе, то

        kill -ABRT <pid>

        Не используйте kill -SEGV, так как это часто вызывает обработчик сигнала, что затрудняет диагностику застрявшего процесса

        George Co   05 февраля 2013 в 14:28


        33
         

        Чтобы проверить, где генерируются дампы ядра, выполните:

        sysctl kernel.core_pattern

        или:

        cat /proc/sys/kernel/core_pattern

        где %e - имя процесса, а %t -системное время. Вы можете изменить его в /etc/sysctl.conf и перезагрузить на sysctl -p .

        Если основные файлы не сгенерированы (проверьте их по: sleep 10 & и killall -SIGSEGV sleep), проверьте ограничения по: ulimit -a .

        Если размер вашего основного файла ограничен, запустите:

        ulimit -c unlimited

        чтобы сделать его неограниченным.

        Затем проверьте еще раз, если сброс ядра прошел успешно, вы увидите “(Сброс ядра)” после указания segmentation fault, как показано ниже:

        Segmentation fault: 11 (ядро бросила)

        См. также: Core dumped - но основной файл не находится в текущем каталоге?


        Ubuntu

        В Ubuntu основные дампы обрабатываются Apport и могут быть расположены в /var/crash/ . Однако в стабильных выпусках он по умолчанию отключен.

        Для получения более подробной информации, пожалуйста, проверьте: где я могу найти дамп ядра в Ubuntu? .

        macOS

        Для macOS см.: Как генерировать дампы ядра в Mac OS X?

        kenorb   08 сентября 2015 в 15:27

        • segmentation fault (дамп памяти)

          Я получаю ошибку сегментации (дамп ядра), когда пытаюсь запустить это. Он прекрасно компилируется, но я получаю ошибку, и я не знаю почему. Я пытался редактировать свой код всеми возможными способами, но все еще получаю эту ошибку. У меня уже кончились идеи. Любая помощь была бы очень кстати....

        • Linux: обработка segmentation fault и получение дампа ядра

          Когда мое приложение выходит из строя с segmentation fault, я хотел бы получить дамп ядра из системы. Я делаю это, настраивая перед рукой ulimit -c unlimited Я также хотел бы иметь указание в моих журналах приложений, что произошло segmentation fault. Я делаю это с помощью sigaction() . Однако...

         


        27
         

        В конце концов я прикрепил gdb к процессу до того, как он разбился, а затем, когда он получил segfault, я выполнил команду generate-core-file . Это вынужденная генерация дампа ядра.

        Nathan Fellman   20 августа 2008 в 17:33


        19
         

        Может быть, вы могли бы сделать это таким образом, эта программа является демонстрацией того, как поймать a segmentation fault и вывести его на отладчик (это исходный код, используемый под AIX ) и напечатать стек trace до точки A segmentation fault. Вам нужно будет изменить переменную sprintf , чтобы использовать gdb в случае Linux.

        #include <stdio.h>
        #include <signal.h>
        #include <stdlib.h>
        #include <stdarg.h>static void signal_handler(int);
        static void dumpstack(void);
        static void cleanup(void);
        void init_signals(void);
        void panic(const char *, ...);struct sigaction sigact;
        char *progname;int main(int argc, char **argv) {
            char *s;
            progname = *(argv);
            atexit(cleanup);
            init_signals();
            printf("About to seg fault by assigning zero to *s\n");
            *s = 0;
            sigemptyset(&sigact.sa_mask);
            return 0;
        }void init_signals(void) {
            sigact.sa_handler = signal_handler;
            sigemptyset(&sigact.sa_mask);
            sigact.sa_flags = 0;
            sigaction(SIGINT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGSEGV);
            sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGBUS);
            sigaction(SIGBUS, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGQUIT);
            sigaction(SIGQUIT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGHUP);
            sigaction(SIGHUP, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGKILL);
            sigaction(SIGKILL, &sigact, (struct sigaction *)NULL);
        }static void signal_handler(int sig) {
            if (sig == SIGHUP) panic("FATAL: Program hanged up\n");
            if (sig == SIGSEGV || sig == SIGBUS){
                dumpstack();
                panic("FATAL: %s Fault. Logged StackTrace\n", (sig == SIGSEGV) ? "Segmentation" : ((sig == SIGBUS) ? "Bus" : "Unknown"));
            }
            if (sig == SIGQUIT) panic("QUIT signal ended program\n");
            if (sig == SIGKILL) panic("KILL signal ended program\n");
            if (sig == SIGINT) ;
        }void panic(const char *fmt, ...) {
            char buf[50];
            va_list argptr;
            va_start(argptr, fmt);
            vsprintf(buf, fmt, argptr);
            va_end(argptr);
            fprintf(stderr, buf);
            exit(-1);
        }static void dumpstack(void) {
            /* Got this routine from http://www.whitefang.com/unix/faq_toc.html
            ** Section 6.5. Modified to redirect to file to prevent clutter
            */
            /* This needs to be changed... */
            char dbx[160];    sprintf(dbx, "echo 'where\ndetach' | dbx -a %d > %s.dump", getpid(), progname);
            /* Change the dbx to gdb */    system(dbx);
            return;
        }void cleanup(void) {
            sigemptyset(&sigact.sa_mask);
            /* Do any cleaning up chores here */
        }

        Возможно ,вам придется дополнительно добавить параметр, чтобы получить gdb для сброса ядра, как показано здесь в этом блоге.

        t0mm13b   26 января 2010 в 13:46


        16
         

        Есть еще много вещей, которые могут повлиять на генерацию дампа ядра. Я столкнулся с этим:

        • каталог для дампа должен быть доступен для записи. По умолчанию это текущий каталог процесса, но его можно изменить, установив /proc/sys/kernel/core_pattern .
        • в некоторых условиях значение kernel в /proc/sys/fs/suid_dumpable может препятствовать созданию ядра.

        Есть и другие ситуации, которые могут помешать генерации, описанные на справочной странице-попробуйте man core .

        mlutescu   08 февраля 2012 в 10:07


        10
         

        Для Ubuntu 14.04

        1. Проверьте, включен ли дамп ядра:

          ulimit -a
        2. Одна из линий должна быть :

          core file size          (blocks, -c) unlimited
        3. Если нет :

          gedit ~/.bashrc и добавьте ulimit -c unlimited в конец файла и сохраните, повторно запустите terminal.

        4. Создайте свое приложение с помощью отладочной информации :

          В Makefile -O0 -g

        5. Запустите приложение, создающее дамп ядра (файл дампа ядра с именем ' core’ должен быть создан рядом с файлом application_name):

          ./application_name
        6. Работать под gdb:

          gdb application_name core
        mrgloom   02 марта 2016 в 12:25


        9
         

        Для того, чтобы активировать соответствующий дамп памяти, выполните следующие действия:

        1. В /etc/profile прокомментируйте строку:

          # ulimit -S -c 0 > /dev/null 2>&1
        2. В /etc/security/limits.conf закомментируйте строку:

          *               soft    core            0
        3. выполните cmd limit coredumpsize unlimited и проверьте его с помощью cmd limit :

          # limit coredumpsize unlimited
          # limit
          cputime      unlimited
          filesize     unlimited
          datasize     unlimited
          stacksize    10240 kbytes
          coredumpsize unlimited
          memoryuse    unlimited
          vmemoryuse   unlimited
          descriptors  1024
          memorylocked 32 kbytes
          maxproc      528383
          #
        4. чтобы проверить, записан ли основной файл, вы можете убить связанный процесс с помощью cmd kill -s SEGV <PID> (не нужно, просто на случай, если основной файл не будет записан, это можно использовать в качестве проверки):

          # kill -s SEGV <PID>

        Как только corefile будет записан, убедитесь, что вы снова деактивировали настройки coredump в соответствующих файлах (1./2./3.)!

        Edgar Jordi   19 октября 2012 в 06:34


        4
         

        По умолчанию вы получите основной файл. Убедитесь, что текущий каталог процесса доступен для записи, иначе основной файл не будет создан.

        Mark Harrison   20 августа 2008 в 14:38


        2
         

        Лучше включить дамп ядра программно, используя системный вызов setrlimit .

        пример:

        #include <sys/resource.h>bool enable_core_dump(){    
            struct rlimit corelim;    corelim.rlim_cur = RLIM_INFINITY;
            corelim.rlim_max = RLIM_INFINITY;    return (0 == setrlimit(RLIMIT_CORE, &corelim));
        }
        kgbook   24 августа 2018 в 08:52


        1
         

        Стоит отметить, что если у вас есть настроенный systemd , то все немного по-другому. Настройка, как правило, есть основные файлы могут передавать посредством core_pattern значение параметра, через systemd-coredump(8) . Базовый размер файла rlimit, как правило, настраивается как уже "unlimited".

        Затем можно получить дампы ядра с помощью coredumpctl(1) .

        Хранение дампов ядра и т. д. настраивается coredump.conf(5) . Есть примеры того, как получить основные файлы на man-странице coredumpctl, но вкратце это будет выглядеть так:

        Найти системный файл:

        [vps@phoenix]~$ coredumpctl list test_me | tail -1
        Sun 2019-01-20 11:17:33 CET   16163  1224  1224  11 present /home/vps/test_me

        Получить основной файл:

        [vps@phoenix]~$ coredumpctl -o test_me.core dump 16163
        Pawel Veselov   20 января 2019 в 10:59


        1
         

        Ubuntu 19.04

        Все остальные ответы сами по себе мне не помогли. Но следующий итог сделал свое дело

        Создайте ~/.config/apport/settings со следующим содержимым:

        [main]
        unpackaged=true

        (Это говорит apport также писать основные дампы для пользовательских приложений)

        Регистрация: ulimit -c . Если он выводит 0, исправьте его с помощью

        ulimit -c unlimited

        Просто на всякий случай перезагрузите Аппорт:

        sudo systemctl restart apport

        Файлы сбоев теперь записываются в /var/crash/ . Но вы не можете использовать их с gdb. Чтобы использовать их с gdb, используйте

        apport-unpack <location_of_report> <target_directory>

        Дополнительная информация:

        • Некоторые ответы предполагают изменение core_pattern . Имейте в виду, что этот файл может быть перезаписан службой apport при перезапуске.
        • Просто остановка аппорта не сделала своей работы
        • Значение ulimit -c может быть изменено автоматически, пока вы пытаетесь найти другие ответы в интернете. Обязательно регулярно проверяйте его во время настройки создания дампа ядра.

        Рекомендации:

        • https://stackoverflow.com/a/47481884/6702598
          • Я получаю ошибку сегментации (дамп ядра) в следующем коде: void Update_Log( ) { struct logData update; int file; char *writeBuffer=NULL; if((file=creat(/home/user/Desktop/DMS/DMS/filename.txt,O_RDONLY|O_WRONLY))==-1) perror(file not opened); update.clientName=user; update.filename=user;...

          • Linux: дамп ядра о сигнале 4

            На платформе linux моя прикладная программа иногда получала дамп ядра из-за сигнала 4. И я нахожу, что сигнал 4 означает незаконную инструкцию. Поэтому у меня есть один вопрос: Как получить незаконную инструкцию и что может вызвать дамп ядра signal 4.



          254
           

          Это зависит от того, какой shell вы используете. Если вы используете bash, то команда ulimit управляет несколькими настройками, связанными с выполнением программы,например, следует ли сбрасывать ядро. Если вы наберете

          ulimit -c unlimited

          тогда это скажет bash, что его программы могут сбрасывать ядра любого размера. Вы можете указать размер, например 52M вместо неограниченного, если хотите, но на практике это не должно быть необходимо, так как размер основных файлов, вероятно, никогда не будет проблемой для вас.

          В tcsh вы бы набрали

          limit coredumpsize unlimited
          Eli Courtwright   20 августа 2008 в 13:50


          60
           

          Как было объяснено выше, реальный вопрос, который здесь задается, заключается в том, как включить дампы ядра в системе, где они не включены. Ответ на этот вопрос ДАН здесь.

          Если вы пришли сюда в надежде узнать, как создать дамп ядра для зависшего процесса, то ответ таков:

          gcore <pid>

          если gcore недоступен в вашей системе, то

          kill -ABRT <pid>

          Не используйте kill -SEGV, так как это часто вызывает обработчик сигнала, что затрудняет диагностику застрявшего процесса

          George Co   05 февраля 2013 в 14:28


          33
           

          Чтобы проверить, где генерируются дампы ядра, выполните:

          sysctl kernel.core_pattern

          или:

          cat /proc/sys/kernel/core_pattern

          где %e - имя процесса, а %t -системное время. Вы можете изменить его в /etc/sysctl.conf и перезагрузить на sysctl -p .

          Если основные файлы не сгенерированы (проверьте их по: sleep 10 & и killall -SIGSEGV sleep), проверьте ограничения по: ulimit -a .

          Если размер вашего основного файла ограничен, запустите:

          ulimit -c unlimited

          чтобы сделать его неограниченным.

          Затем проверьте еще раз, если сброс ядра прошел успешно, вы увидите “(Сброс ядра)” после указания segmentation fault, как показано ниже:

          Segmentation fault: 11 (ядро бросила)

          См. также: Core dumped - но основной файл не находится в текущем каталоге?


          Ubuntu

          В Ubuntu основные дампы обрабатываются Apport и могут быть расположены в /var/crash/ . Однако в стабильных выпусках он по умолчанию отключен.

          Для получения более подробной информации, пожалуйста, проверьте: где я могу найти дамп ядра в Ubuntu? .

          macOS

          Для macOS см.: Как генерировать дампы ядра в Mac OS X?

          kenorb   08 сентября 2015 в 15:27

          • segmentation fault (дамп памяти)

            Я получаю ошибку сегментации (дамп ядра), когда пытаюсь запустить это. Он прекрасно компилируется, но я получаю ошибку, и я не знаю почему. Я пытался редактировать свой код всеми возможными способами, но все еще получаю эту ошибку. У меня уже кончились идеи. Любая помощь была бы очень кстати....

          • Linux: обработка segmentation fault и получение дампа ядра

            Когда мое приложение выходит из строя с segmentation fault, я хотел бы получить дамп ядра из системы. Я делаю это, настраивая перед рукой ulimit -c unlimited Я также хотел бы иметь указание в моих журналах приложений, что произошло segmentation fault. Я делаю это с помощью sigaction() . Однако...

           


          27
           

          В конце концов я прикрепил gdb к процессу до того, как он разбился, а затем, когда он получил segfault, я выполнил команду generate-core-file . Это вынужденная генерация дампа ядра.

          Nathan Fellman   20 августа 2008 в 17:33


          19
           

          Может быть, вы могли бы сделать это таким образом, эта программа является демонстрацией того, как поймать a segmentation fault и вывести его на отладчик (это исходный код, используемый под AIX ) и напечатать стек trace до точки A segmentation fault. Вам нужно будет изменить переменную sprintf , чтобы использовать gdb в случае Linux.

          #include <stdio.h>
          #include <signal.h>
          #include <stdlib.h>
          #include <stdarg.h>static void signal_handler(int);
          static void dumpstack(void);
          static void cleanup(void);
          void init_signals(void);
          void panic(const char *, ...);struct sigaction sigact;
          char *progname;int main(int argc, char **argv) {
              char *s;
              progname = *(argv);
              atexit(cleanup);
              init_signals();
              printf("About to seg fault by assigning zero to *s\n");
              *s = 0;
              sigemptyset(&sigact.sa_mask);
              return 0;
          }void init_signals(void) {
              sigact.sa_handler = signal_handler;
              sigemptyset(&sigact.sa_mask);
              sigact.sa_flags = 0;
              sigaction(SIGINT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGSEGV);
              sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGBUS);
              sigaction(SIGBUS, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGQUIT);
              sigaction(SIGQUIT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGHUP);
              sigaction(SIGHUP, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGKILL);
              sigaction(SIGKILL, &sigact, (struct sigaction *)NULL);
          }static void signal_handler(int sig) {
              if (sig == SIGHUP) panic("FATAL: Program hanged up\n");
              if (sig == SIGSEGV || sig == SIGBUS){
                  dumpstack();
                  panic("FATAL: %s Fault. Logged StackTrace\n", (sig == SIGSEGV) ? "Segmentation" : ((sig == SIGBUS) ? "Bus" : "Unknown"));
              }
              if (sig == SIGQUIT) panic("QUIT signal ended program\n");
              if (sig == SIGKILL) panic("KILL signal ended program\n");
              if (sig == SIGINT) ;
          }void panic(const char *fmt, ...) {
              char buf[50];
              va_list argptr;
              va_start(argptr, fmt);
              vsprintf(buf, fmt, argptr);
              va_end(argptr);
              fprintf(stderr, buf);
              exit(-1);
          }static void dumpstack(void) {
              /* Got this routine from http://www.whitefang.com/unix/faq_toc.html
              ** Section 6.5. Modified to redirect to file to prevent clutter
              */
              /* This needs to be changed... */
              char dbx[160];    sprintf(dbx, "echo 'where\ndetach' | dbx -a %d > %s.dump", getpid(), progname);
              /* Change the dbx to gdb */    system(dbx);
              return;
          }void cleanup(void) {
              sigemptyset(&sigact.sa_mask);
              /* Do any cleaning up chores here */
          }

          Возможно ,вам придется дополнительно добавить параметр, чтобы получить gdb для сброса ядра, как показано здесь в этом блоге.

          t0mm13b   26 января 2010 в 13:46


          16
           

          Есть еще много вещей, которые могут повлиять на генерацию дампа ядра. Я столкнулся с этим:

          • каталог для дампа должен быть доступен для записи. По умолчанию это текущий каталог процесса, но его можно изменить, установив /proc/sys/kernel/core_pattern .
          • в некоторых условиях значение kernel в /proc/sys/fs/suid_dumpable может препятствовать созданию ядра.

          Есть и другие ситуации, которые могут помешать генерации, описанные на справочной странице-попробуйте man core .

          mlutescu   08 февраля 2012 в 10:07


          10
           

          Для Ubuntu 14.04

          1. Проверьте, включен ли дамп ядра:

            ulimit -a
          2. Одна из линий должна быть :

            core file size          (blocks, -c) unlimited
          3. Если нет :

            gedit ~/.bashrc и добавьте ulimit -c unlimited в конец файла и сохраните, повторно запустите terminal.

          4. Создайте свое приложение с помощью отладочной информации :

            В Makefile -O0 -g

          5. Запустите приложение, создающее дамп ядра (файл дампа ядра с именем ' core’ должен быть создан рядом с файлом application_name):

            ./application_name
          6. Работать под gdb:

            gdb application_name core
          mrgloom   02 марта 2016 в 12:25


          9
           

          Для того, чтобы активировать соответствующий дамп памяти, выполните следующие действия:

          1. В /etc/profile прокомментируйте строку:

            # ulimit -S -c 0 > /dev/null 2>&1
          2. В /etc/security/limits.conf закомментируйте строку:

            *               soft    core            0
          3. выполните cmd limit coredumpsize unlimited и проверьте его с помощью cmd limit :

            # limit coredumpsize unlimited
            # limit
            cputime      unlimited
            filesize     unlimited
            datasize     unlimited
            stacksize    10240 kbytes
            coredumpsize unlimited
            memoryuse    unlimited
            vmemoryuse   unlimited
            descriptors  1024
            memorylocked 32 kbytes
            maxproc      528383
            #
          4. чтобы проверить, записан ли основной файл, вы можете убить связанный процесс с помощью cmd kill -s SEGV <PID> (не нужно, просто на случай, если основной файл не будет записан, это можно использовать в качестве проверки):

            # kill -s SEGV <PID>

          Как только corefile будет записан, убедитесь, что вы снова деактивировали настройки coredump в соответствующих файлах (1./2./3.)!

          Edgar Jordi   19 октября 2012 в 06:34


          4
           

          По умолчанию вы получите основной файл. Убедитесь, что текущий каталог процесса доступен для записи, иначе основной файл не будет создан.

          Mark Harrison   20 августа 2008 в 14:38


          2
           

          Лучше включить дамп ядра программно, используя системный вызов setrlimit .

          пример:

          #include <sys/resource.h>bool enable_core_dump(){    
              struct rlimit corelim;    corelim.rlim_cur = RLIM_INFINITY;
              corelim.rlim_max = RLIM_INFINITY;    return (0 == setrlimit(RLIMIT_CORE, &corelim));
          }
          kgbook   24 августа 2018 в 08:52


          1
           

          Стоит отметить, что если у вас есть настроенный systemd , то все немного по-другому. Настройка, как правило, есть основные файлы могут передавать посредством core_pattern значение параметра, через systemd-coredump(8) . Базовый размер файла rlimit, как правило, настраивается как уже "unlimited".

          Затем можно получить дампы ядра с помощью coredumpctl(1) .

          Хранение дампов ядра и т. д. настраивается coredump.conf(5) . Есть примеры того, как получить основные файлы на man-странице coredumpctl, но вкратце это будет выглядеть так:

          Найти системный файл:

          [vps@phoenix]~$ coredumpctl list test_me | tail -1
          Sun 2019-01-20 11:17:33 CET   16163  1224  1224  11 present /home/vps/test_me

          Получить основной файл:

          [vps@phoenix]~$ coredumpctl -o test_me.core dump 16163
          Pawel Veselov   20 января 2019 в 10:59


          1
           

          Ubuntu 19.04

          Все остальные ответы сами по себе мне не помогли. Но следующий итог сделал свое дело

          Создайте ~/.config/apport/settings со следующим содержимым:

          [main]
          unpackaged=true

          (Это говорит apport также писать основные дампы для пользовательских приложений)

          Регистрация: ulimit -c . Если он выводит 0, исправьте его с помощью

          ulimit -c unlimited

          Просто на всякий случай перезагрузите Аппорт:

          sudo systemctl restart apport

          Файлы сбоев теперь записываются в /var/crash/ . Но вы не можете использовать их с gdb. Чтобы использовать их с gdb, используйте

          apport-unpack <location_of_report> <target_directory>

          Дополнительная информация:

          • Некоторые ответы предполагают изменение core_pattern . Имейте в виду, что этот файл может быть перезаписан службой apport при перезапуске.
          • Просто остановка аппорта не сделала своей работы
          • Значение ulimit -c может быть изменено автоматически, пока вы пытаетесь найти другие ответы в интернете. Обязательно регулярно проверяйте его во время настройки создания дампа ядра.

          Рекомендации:

          • https://stackoverflow.com/a/47481884/6702598
            • Я получаю ошибку сегментации (дамп ядра) в следующем коде: void Update_Log( ) { struct logData update; int file; char *writeBuffer=NULL; if((file=creat(/home/user/Desktop/DMS/DMS/filename.txt,O_RDONLY|O_WRONLY))==-1) perror(file not opened); update.clientName=user; update.filename=user;...

            • Linux: дамп ядра о сигнале 4

              На платформе linux моя прикладная программа иногда получала дамп ядра из-за сигнала 4. И я нахожу, что сигнал 4 означает незаконную инструкцию. Поэтому у меня есть один вопрос: Как получить незаконную инструкцию и что может вызвать дамп ядра signal 4.



            254
             

            Это зависит от того, какой shell вы используете. Если вы используете bash, то команда ulimit управляет несколькими настройками, связанными с выполнением программы,например, следует ли сбрасывать ядро. Если вы наберете

            ulimit -c unlimited

            тогда это скажет bash, что его программы могут сбрасывать ядра любого размера. Вы можете указать размер, например 52M вместо неограниченного, если хотите, но на практике это не должно быть необходимо, так как размер основных файлов, вероятно, никогда не будет проблемой для вас.

            В tcsh вы бы набрали

            limit coredumpsize unlimited
            Eli Courtwright   20 августа 2008 в 13:50


            60
             

            Как было объяснено выше, реальный вопрос, который здесь задается, заключается в том, как включить дампы ядра в системе, где они не включены. Ответ на этот вопрос ДАН здесь.

            Если вы пришли сюда в надежде узнать, как создать дамп ядра для зависшего процесса, то ответ таков:

            gcore <pid>

            если gcore недоступен в вашей системе, то

            kill -ABRT <pid>

            Не используйте kill -SEGV, так как это часто вызывает обработчик сигнала, что затрудняет диагностику застрявшего процесса

            George Co   05 февраля 2013 в 14:28


            33
             

            Чтобы проверить, где генерируются дампы ядра, выполните:

            sysctl kernel.core_pattern

            или:

            cat /proc/sys/kernel/core_pattern

            где %e - имя процесса, а %t -системное время. Вы можете изменить его в /etc/sysctl.conf и перезагрузить на sysctl -p .

            Если основные файлы не сгенерированы (проверьте их по: sleep 10 & и killall -SIGSEGV sleep), проверьте ограничения по: ulimit -a .

            Если размер вашего основного файла ограничен, запустите:

            ulimit -c unlimited

            чтобы сделать его неограниченным.

            Затем проверьте еще раз, если сброс ядра прошел успешно, вы увидите “(Сброс ядра)” после указания segmentation fault, как показано ниже:

            Segmentation fault: 11 (ядро бросила)

            См. также: Core dumped - но основной файл не находится в текущем каталоге?


            Ubuntu

            В Ubuntu основные дампы обрабатываются Apport и могут быть расположены в /var/crash/ . Однако в стабильных выпусках он по умолчанию отключен.

            Для получения более подробной информации, пожалуйста, проверьте: где я могу найти дамп ядра в Ubuntu? .

            macOS

            Для macOS см.: Как генерировать дампы ядра в Mac OS X?

            kenorb   08 сентября 2015 в 15:27

            • segmentation fault (дамп памяти)

              Я получаю ошибку сегментации (дамп ядра), когда пытаюсь запустить это. Он прекрасно компилируется, но я получаю ошибку, и я не знаю почему. Я пытался редактировать свой код всеми возможными способами, но все еще получаю эту ошибку. У меня уже кончились идеи. Любая помощь была бы очень кстати....

            • Linux: обработка segmentation fault и получение дампа ядра

              Когда мое приложение выходит из строя с segmentation fault, я хотел бы получить дамп ядра из системы. Я делаю это, настраивая перед рукой ulimit -c unlimited Я также хотел бы иметь указание в моих журналах приложений, что произошло segmentation fault. Я делаю это с помощью sigaction() . Однако...

             


            27
             

            В конце концов я прикрепил gdb к процессу до того, как он разбился, а затем, когда он получил segfault, я выполнил команду generate-core-file . Это вынужденная генерация дампа ядра.

            Nathan Fellman   20 августа 2008 в 17:33


            19
             

            Может быть, вы могли бы сделать это таким образом, эта программа является демонстрацией того, как поймать a segmentation fault и вывести его на отладчик (это исходный код, используемый под AIX ) и напечатать стек trace до точки A segmentation fault. Вам нужно будет изменить переменную sprintf , чтобы использовать gdb в случае Linux.

            #include <stdio.h>
            #include <signal.h>
            #include <stdlib.h>
            #include <stdarg.h>static void signal_handler(int);
            static void dumpstack(void);
            static void cleanup(void);
            void init_signals(void);
            void panic(const char *, ...);struct sigaction sigact;
            char *progname;int main(int argc, char **argv) {
                char *s;
                progname = *(argv);
                atexit(cleanup);
                init_signals();
                printf("About to seg fault by assigning zero to *s\n");
                *s = 0;
                sigemptyset(&sigact.sa_mask);
                return 0;
            }void init_signals(void) {
                sigact.sa_handler = signal_handler;
                sigemptyset(&sigact.sa_mask);
                sigact.sa_flags = 0;
                sigaction(SIGINT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGSEGV);
                sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGBUS);
                sigaction(SIGBUS, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGQUIT);
                sigaction(SIGQUIT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGHUP);
                sigaction(SIGHUP, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGKILL);
                sigaction(SIGKILL, &sigact, (struct sigaction *)NULL);
            }static void signal_handler(int sig) {
                if (sig == SIGHUP) panic("FATAL: Program hanged up\n");
                if (sig == SIGSEGV || sig == SIGBUS){
                    dumpstack();
                    panic("FATAL: %s Fault. Logged StackTrace\n", (sig == SIGSEGV) ? "Segmentation" : ((sig == SIGBUS) ? "Bus" : "Unknown"));
                }
                if (sig == SIGQUIT) panic("QUIT signal ended program\n");
                if (sig == SIGKILL) panic("KILL signal ended program\n");
                if (sig == SIGINT) ;
            }void panic(const char *fmt, ...) {
                char buf[50];
                va_list argptr;
                va_start(argptr, fmt);
                vsprintf(buf, fmt, argptr);
                va_end(argptr);
                fprintf(stderr, buf);
                exit(-1);
            }static void dumpstack(void) {
                /* Got this routine from http://www.whitefang.com/unix/faq_toc.html
                ** Section 6.5. Modified to redirect to file to prevent clutter
                */
                /* This needs to be changed... */
                char dbx[160];    sprintf(dbx, "echo 'where\ndetach' | dbx -a %d > %s.dump", getpid(), progname);
                /* Change the dbx to gdb */    system(dbx);
                return;
            }void cleanup(void) {
                sigemptyset(&sigact.sa_mask);
                /* Do any cleaning up chores here */
            }

            Возможно ,вам придется дополнительно добавить параметр, чтобы получить gdb для сброса ядра, как показано здесь в этом блоге.

            t0mm13b   26 января 2010 в 13:46


            16
             

            Есть еще много вещей, которые могут повлиять на генерацию дампа ядра. Я столкнулся с этим:

            • каталог для дампа должен быть доступен для записи. По умолчанию это текущий каталог процесса, но его можно изменить, установив /proc/sys/kernel/core_pattern .
            • в некоторых условиях значение kernel в /proc/sys/fs/suid_dumpable может препятствовать созданию ядра.

            Есть и другие ситуации, которые могут помешать генерации, описанные на справочной странице-попробуйте man core .

            mlutescu   08 февраля 2012 в 10:07


            10
             

            Для Ubuntu 14.04

            1. Проверьте, включен ли дамп ядра:

              ulimit -a
            2. Одна из линий должна быть :

              core file size          (blocks, -c) unlimited
            3. Если нет :

              gedit ~/.bashrc и добавьте ulimit -c unlimited в конец файла и сохраните, повторно запустите terminal.

            4. Создайте свое приложение с помощью отладочной информации :

              В Makefile -O0 -g

            5. Запустите приложение, создающее дамп ядра (файл дампа ядра с именем ' core’ должен быть создан рядом с файлом application_name):

              ./application_name
            6. Работать под gdb:

              gdb application_name core
            mrgloom   02 марта 2016 в 12:25


            9
             

            Для того, чтобы активировать соответствующий дамп памяти, выполните следующие действия:

            1. В /etc/profile прокомментируйте строку:

              # ulimit -S -c 0 > /dev/null 2>&1
            2. В /etc/security/limits.conf закомментируйте строку:

              *               soft    core            0
            3. выполните cmd limit coredumpsize unlimited и проверьте его с помощью cmd limit :

              # limit coredumpsize unlimited
              # limit
              cputime      unlimited
              filesize     unlimited
              datasize     unlimited
              stacksize    10240 kbytes
              coredumpsize unlimited
              memoryuse    unlimited
              vmemoryuse   unlimited
              descriptors  1024
              memorylocked 32 kbytes
              maxproc      528383
              #
            4. чтобы проверить, записан ли основной файл, вы можете убить связанный процесс с помощью cmd kill -s SEGV <PID> (не нужно, просто на случай, если основной файл не будет записан, это можно использовать в качестве проверки):

              # kill -s SEGV <PID>

            Как только corefile будет записан, убедитесь, что вы снова деактивировали настройки coredump в соответствующих файлах (1./2./3.)!

            Edgar Jordi   19 октября 2012 в 06:34


            4
             

            По умолчанию вы получите основной файл. Убедитесь, что текущий каталог процесса доступен для записи, иначе основной файл не будет создан.

            Mark Harrison   20 августа 2008 в 14:38


            2
             

            Лучше включить дамп ядра программно, используя системный вызов setrlimit .

            пример:

            #include <sys/resource.h>bool enable_core_dump(){    
                struct rlimit corelim;    corelim.rlim_cur = RLIM_INFINITY;
                corelim.rlim_max = RLIM_INFINITY;    return (0 == setrlimit(RLIMIT_CORE, &corelim));
            }
            kgbook   24 августа 2018 в 08:52


            1
             

            Стоит отметить, что если у вас есть настроенный systemd , то все немного по-другому. Настройка, как правило, есть основные файлы могут передавать посредством core_pattern значение параметра, через systemd-coredump(8) . Базовый размер файла rlimit, как правило, настраивается как уже "unlimited".

            Затем можно получить дампы ядра с помощью coredumpctl(1) .

            Хранение дампов ядра и т. д. настраивается coredump.conf(5) . Есть примеры того, как получить основные файлы на man-странице coredumpctl, но вкратце это будет выглядеть так:

            Найти системный файл:

            [vps@phoenix]~$ coredumpctl list test_me | tail -1
            Sun 2019-01-20 11:17:33 CET   16163  1224  1224  11 present /home/vps/test_me

            Получить основной файл:

            [vps@phoenix]~$ coredumpctl -o test_me.core dump 16163
            Pawel Veselov   20 января 2019 в 10:59


            1
             

            Ubuntu 19.04

            Все остальные ответы сами по себе мне не помогли. Но следующий итог сделал свое дело

            Создайте ~/.config/apport/settings со следующим содержимым:

            [main]
            unpackaged=true

            (Это говорит apport также писать основные дампы для пользовательских приложений)

            Регистрация: ulimit -c . Если он выводит 0, исправьте его с помощью

            ulimit -c unlimited

            Просто на всякий случай перезагрузите Аппорт:

            sudo systemctl restart apport

            Файлы сбоев теперь записываются в /var/crash/ . Но вы не можете использовать их с gdb. Чтобы использовать их с gdb, используйте

            apport-unpack <location_of_report> <target_directory>

            Дополнительная информация:

            • Некоторые ответы предполагают изменение core_pattern . Имейте в виду, что этот файл может быть перезаписан службой apport при перезапуске.
            • Просто остановка аппорта не сделала своей работы
            • Значение ulimit -c может быть изменено автоматически, пока вы пытаетесь найти другие ответы в интернете. Обязательно регулярно проверяйте его во время настройки создания дампа ядра.

            Рекомендации:

            • https://stackoverflow.com/a/47481884/6702598
              • Я получаю ошибку сегментации (дамп ядра) в следующем коде: void Update_Log( ) { struct logData update; int file; char *writeBuffer=NULL; if((file=creat(/home/user/Desktop/DMS/DMS/filename.txt,O_RDONLY|O_WRONLY))==-1) perror(file not opened); update.clientName=user; update.filename=user;...

              • Linux: дамп ядра о сигнале 4

                На платформе linux моя прикладная программа иногда получала дамп ядра из-за сигнала 4. И я нахожу, что сигнал 4 означает незаконную инструкцию. Поэтому у меня есть один вопрос: Как получить незаконную инструкцию и что может вызвать дамп ядра signal 4.



              254
               

              Это зависит от того, какой shell вы используете. Если вы используете bash, то команда ulimit управляет несколькими настройками, связанными с выполнением программы,например, следует ли сбрасывать ядро. Если вы наберете

              ulimit -c unlimited

              тогда это скажет bash, что его программы могут сбрасывать ядра любого размера. Вы можете указать размер, например 52M вместо неограниченного, если хотите, но на практике это не должно быть необходимо, так как размер основных файлов, вероятно, никогда не будет проблемой для вас.

              В tcsh вы бы набрали

              limit coredumpsize unlimited
              Eli Courtwright   20 августа 2008 в 13:50


              60
               

              Как было объяснено выше, реальный вопрос, который здесь задается, заключается в том, как включить дампы ядра в системе, где они не включены. Ответ на этот вопрос ДАН здесь.

              Если вы пришли сюда в надежде узнать, как создать дамп ядра для зависшего процесса, то ответ таков:

              gcore <pid>

              если gcore недоступен в вашей системе, то

              kill -ABRT <pid>

              Не используйте kill -SEGV, так как это часто вызывает обработчик сигнала, что затрудняет диагностику застрявшего процесса

              George Co   05 февраля 2013 в 14:28


              33
               

              Чтобы проверить, где генерируются дампы ядра, выполните:

              sysctl kernel.core_pattern

              или:

              cat /proc/sys/kernel/core_pattern

              где %e - имя процесса, а %t -системное время. Вы можете изменить его в /etc/sysctl.conf и перезагрузить на sysctl -p .

              Если основные файлы не сгенерированы (проверьте их по: sleep 10 & и killall -SIGSEGV sleep), проверьте ограничения по: ulimit -a .

              Если размер вашего основного файла ограничен, запустите:

              ulimit -c unlimited

              чтобы сделать его неограниченным.

              Затем проверьте еще раз, если сброс ядра прошел успешно, вы увидите “(Сброс ядра)” после указания segmentation fault, как показано ниже:

              Segmentation fault: 11 (ядро бросила)

              См. также: Core dumped - но основной файл не находится в текущем каталоге?


              Ubuntu

              В Ubuntu основные дампы обрабатываются Apport и могут быть расположены в /var/crash/ . Однако в стабильных выпусках он по умолчанию отключен.

              Для получения более подробной информации, пожалуйста, проверьте: где я могу найти дамп ядра в Ubuntu? .

              macOS

              Для macOS см.: Как генерировать дампы ядра в Mac OS X?

              kenorb   08 сентября 2015 в 15:27

              • segmentation fault (дамп памяти)

                Я получаю ошибку сегментации (дамп ядра), когда пытаюсь запустить это. Он прекрасно компилируется, но я получаю ошибку, и я не знаю почему. Я пытался редактировать свой код всеми возможными способами, но все еще получаю эту ошибку. У меня уже кончились идеи. Любая помощь была бы очень кстати....

              • Linux: обработка segmentation fault и получение дампа ядра

                Когда мое приложение выходит из строя с segmentation fault, я хотел бы получить дамп ядра из системы. Я делаю это, настраивая перед рукой ulimit -c unlimited Я также хотел бы иметь указание в моих журналах приложений, что произошло segmentation fault. Я делаю это с помощью sigaction() . Однако...

               


              27
               

              В конце концов я прикрепил gdb к процессу до того, как он разбился, а затем, когда он получил segfault, я выполнил команду generate-core-file . Это вынужденная генерация дампа ядра.

              Nathan Fellman   20 августа 2008 в 17:33


              19
               

              Может быть, вы могли бы сделать это таким образом, эта программа является демонстрацией того, как поймать a segmentation fault и вывести его на отладчик (это исходный код, используемый под AIX ) и напечатать стек trace до точки A segmentation fault. Вам нужно будет изменить переменную sprintf , чтобы использовать gdb в случае Linux.

              #include <stdio.h>
              #include <signal.h>
              #include <stdlib.h>
              #include <stdarg.h>static void signal_handler(int);
              static void dumpstack(void);
              static void cleanup(void);
              void init_signals(void);
              void panic(const char *, ...);struct sigaction sigact;
              char *progname;int main(int argc, char **argv) {
                  char *s;
                  progname = *(argv);
                  atexit(cleanup);
                  init_signals();
                  printf("About to seg fault by assigning zero to *s\n");
                  *s = 0;
                  sigemptyset(&sigact.sa_mask);
                  return 0;
              }void init_signals(void) {
                  sigact.sa_handler = signal_handler;
                  sigemptyset(&sigact.sa_mask);
                  sigact.sa_flags = 0;
                  sigaction(SIGINT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGSEGV);
                  sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGBUS);
                  sigaction(SIGBUS, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGQUIT);
                  sigaction(SIGQUIT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGHUP);
                  sigaction(SIGHUP, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGKILL);
                  sigaction(SIGKILL, &sigact, (struct sigaction *)NULL);
              }static void signal_handler(int sig) {
                  if (sig == SIGHUP) panic("FATAL: Program hanged up\n");
                  if (sig == SIGSEGV || sig == SIGBUS){
                      dumpstack();
                      panic("FATAL: %s Fault. Logged StackTrace\n", (sig == SIGSEGV) ? "Segmentation" : ((sig == SIGBUS) ? "Bus" : "Unknown"));
                  }
                  if (sig == SIGQUIT) panic("QUIT signal ended program\n");
                  if (sig == SIGKILL) panic("KILL signal ended program\n");
                  if (sig == SIGINT) ;
              }void panic(const char *fmt, ...) {
                  char buf[50];
                  va_list argptr;
                  va_start(argptr, fmt);
                  vsprintf(buf, fmt, argptr);
                  va_end(argptr);
                  fprintf(stderr, buf);
                  exit(-1);
              }static void dumpstack(void) {
                  /* Got this routine from http://www.whitefang.com/unix/faq_toc.html
                  ** Section 6.5. Modified to redirect to file to prevent clutter
                  */
                  /* This needs to be changed... */
                  char dbx[160];    sprintf(dbx, "echo 'where\ndetach' | dbx -a %d > %s.dump", getpid(), progname);
                  /* Change the dbx to gdb */    system(dbx);
                  return;
              }void cleanup(void) {
                  sigemptyset(&sigact.sa_mask);
                  /* Do any cleaning up chores here */
              }

              Возможно ,вам придется дополнительно добавить параметр, чтобы получить gdb для сброса ядра, как показано здесь в этом блоге.

              t0mm13b   26 января 2010 в 13:46


              16
               

              Есть еще много вещей, которые могут повлиять на генерацию дампа ядра. Я столкнулся с этим:

              • каталог для дампа должен быть доступен для записи. По умолчанию это текущий каталог процесса, но его можно изменить, установив /proc/sys/kernel/core_pattern .
              • в некоторых условиях значение kernel в /proc/sys/fs/suid_dumpable может препятствовать созданию ядра.

              Есть и другие ситуации, которые могут помешать генерации, описанные на справочной странице-попробуйте man core .

              mlutescu   08 февраля 2012 в 10:07


              10
               

              Для Ubuntu 14.04

              1. Проверьте, включен ли дамп ядра:

                ulimit -a
              2. Одна из линий должна быть :

                core file size          (blocks, -c) unlimited
              3. Если нет :

                gedit ~/.bashrc и добавьте ulimit -c unlimited в конец файла и сохраните, повторно запустите terminal.

              4. Создайте свое приложение с помощью отладочной информации :

                В Makefile -O0 -g

              5. Запустите приложение, создающее дамп ядра (файл дампа ядра с именем ' core’ должен быть создан рядом с файлом application_name):

                ./application_name
              6. Работать под gdb:

                gdb application_name core
              mrgloom   02 марта 2016 в 12:25


              9
               

              Для того, чтобы активировать соответствующий дамп памяти, выполните следующие действия:

              1. В /etc/profile прокомментируйте строку:

                # ulimit -S -c 0 > /dev/null 2>&1
              2. В /etc/security/limits.conf закомментируйте строку:

                *               soft    core            0
              3. выполните cmd limit coredumpsize unlimited и проверьте его с помощью cmd limit :

                # limit coredumpsize unlimited
                # limit
                cputime      unlimited
                filesize     unlimited
                datasize     unlimited
                stacksize    10240 kbytes
                coredumpsize unlimited
                memoryuse    unlimited
                vmemoryuse   unlimited
                descriptors  1024
                memorylocked 32 kbytes
                maxproc      528383
                #
              4. чтобы проверить, записан ли основной файл, вы можете убить связанный процесс с помощью cmd kill -s SEGV <PID> (не нужно, просто на случай, если основной файл не будет записан, это можно использовать в качестве проверки):

                # kill -s SEGV <PID>

              Как только corefile будет записан, убедитесь, что вы снова деактивировали настройки coredump в соответствующих файлах (1./2./3.)!

              Edgar Jordi   19 октября 2012 в 06:34


              4
               

              По умолчанию вы получите основной файл. Убедитесь, что текущий каталог процесса доступен для записи, иначе основной файл не будет создан.

              Mark Harrison   20 августа 2008 в 14:38


              2
               

              Лучше включить дамп ядра программно, используя системный вызов setrlimit .

              пример:

              #include <sys/resource.h>bool enable_core_dump(){    
                  struct rlimit corelim;    corelim.rlim_cur = RLIM_INFINITY;
                  corelim.rlim_max = RLIM_INFINITY;    return (0 == setrlimit(RLIMIT_CORE, &corelim));
              }
              kgbook   24 августа 2018 в 08:52


              1
               

              Стоит отметить, что если у вас есть настроенный systemd , то все немного по-другому. Настройка, как правило, есть основные файлы могут передавать посредством core_pattern значение параметра, через systemd-coredump(8) . Базовый размер файла rlimit, как правило, настраивается как уже "unlimited".

              Затем можно получить дампы ядра с помощью coredumpctl(1) .

              Хранение дампов ядра и т. д. настраивается coredump.conf(5) . Есть примеры того, как получить основные файлы на man-странице coredumpctl, но вкратце это будет выглядеть так:

              Найти системный файл:

              [vps@phoenix]~$ coredumpctl list test_me | tail -1
              Sun 2019-01-20 11:17:33 CET   16163  1224  1224  11 present /home/vps/test_me

              Получить основной файл:

              [vps@phoenix]~$ coredumpctl -o test_me.core dump 16163
              Pawel Veselov   20 января 2019 в 10:59


              1
               

              Ubuntu 19.04

              Все остальные ответы сами по себе мне не помогли. Но следующий итог сделал свое дело

              Создайте ~/.config/apport/settings со следующим содержимым:

              [main]
              unpackaged=true

              (Это говорит apport также писать основные дампы для пользовательских приложений)

              Регистрация: ulimit -c . Если он выводит 0, исправьте его с помощью

              ulimit -c unlimited

              Просто на всякий случай перезагрузите Аппорт:

              sudo systemctl restart apport

              Файлы сбоев теперь записываются в /var/crash/ . Но вы не можете использовать их с gdb. Чтобы использовать их с gdb, используйте

              apport-unpack <location_of_report> <target_directory>

              Дополнительная информация:

              • Некоторые ответы предполагают изменение core_pattern . Имейте в виду, что этот файл может быть перезаписан службой apport при перезапуске.
              • Просто остановка аппорта не сделала своей работы
              • Значение ulimit -c может быть изменено автоматически, пока вы пытаетесь найти другие ответы в интернете. Обязательно регулярно проверяйте его во время настройки создания дампа ядра.

              Рекомендации:

              • https://stackoverflow.com/a/47481884/6702598
                • Я получаю ошибку сегментации (дамп ядра) в следующем коде: void Update_Log( ) { struct logData update; int file; char *writeBuffer=NULL; if((file=creat(/home/user/Desktop/DMS/DMS/filename.txt,O_RDONLY|O_WRONLY))==-1) perror(file not opened); update.clientName=user; update.filename=user;...

                • Linux: дамп ядра о сигнале 4

                  На платформе linux моя прикладная программа иногда получала дамп ядра из-за сигнала 4. И я нахожу, что сигнал 4 означает незаконную инструкцию. Поэтому у меня есть один вопрос: Как получить незаконную инструкцию и что может вызвать дамп ядра signal 4.



                254
                 

                Это зависит от того, какой shell вы используете. Если вы используете bash, то команда ulimit управляет несколькими настройками, связанными с выполнением программы,например, следует ли сбрасывать ядро. Если вы наберете

                ulimit -c unlimited

                тогда это скажет bash, что его программы могут сбрасывать ядра любого размера. Вы можете указать размер, например 52M вместо неограниченного, если хотите, но на практике это не должно быть необходимо, так как размер основных файлов, вероятно, никогда не будет проблемой для вас.

                В tcsh вы бы набрали

                limit coredumpsize unlimited
                Eli Courtwright   20 августа 2008 в 13:50


                60
                 

                Как было объяснено выше, реальный вопрос, который здесь задается, заключается в том, как включить дампы ядра в системе, где они не включены. Ответ на этот вопрос ДАН здесь.

                Если вы пришли сюда в надежде узнать, как создать дамп ядра для зависшего процесса, то ответ таков:

                gcore <pid>

                если gcore недоступен в вашей системе, то

                kill -ABRT <pid>

                Не используйте kill -SEGV, так как это часто вызывает обработчик сигнала, что затрудняет диагностику застрявшего процесса

                George Co   05 февраля 2013 в 14:28


                33
                 

                Чтобы проверить, где генерируются дампы ядра, выполните:

                sysctl kernel.core_pattern

                или:

                cat /proc/sys/kernel/core_pattern

                где %e - имя процесса, а %t -системное время. Вы можете изменить его в /etc/sysctl.conf и перезагрузить на sysctl -p .

                Если основные файлы не сгенерированы (проверьте их по: sleep 10 & и killall -SIGSEGV sleep), проверьте ограничения по: ulimit -a .

                Если размер вашего основного файла ограничен, запустите:

                ulimit -c unlimited

                чтобы сделать его неограниченным.

                Затем проверьте еще раз, если сброс ядра прошел успешно, вы увидите “(Сброс ядра)” после указания segmentation fault, как показано ниже:

                Segmentation fault: 11 (ядро бросила)

                См. также: Core dumped - но основной файл не находится в текущем каталоге?


                Ubuntu

                В Ubuntu основные дампы обрабатываются Apport и могут быть расположены в /var/crash/ . Однако в стабильных выпусках он по умолчанию отключен.

                Для получения более подробной информации, пожалуйста, проверьте: где я могу найти дамп ядра в Ubuntu? .

                macOS

                Для macOS см.: Как генерировать дампы ядра в Mac OS X?

                kenorb   08 сентября 2015 в 15:27

                • segmentation fault (дамп памяти)

                  Я получаю ошибку сегментации (дамп ядра), когда пытаюсь запустить это. Он прекрасно компилируется, но я получаю ошибку, и я не знаю почему. Я пытался редактировать свой код всеми возможными способами, но все еще получаю эту ошибку. У меня уже кончились идеи. Любая помощь была бы очень кстати....

                • Linux: обработка segmentation fault и получение дампа ядра

                  Когда мое приложение выходит из строя с segmentation fault, я хотел бы получить дамп ядра из системы. Я делаю это, настраивая перед рукой ulimit -c unlimited Я также хотел бы иметь указание в моих журналах приложений, что произошло segmentation fault. Я делаю это с помощью sigaction() . Однако...

                 


                27
                 

                В конце концов я прикрепил gdb к процессу до того, как он разбился, а затем, когда он получил segfault, я выполнил команду generate-core-file . Это вынужденная генерация дампа ядра.

                Nathan Fellman   20 августа 2008 в 17:33


                19
                 

                Может быть, вы могли бы сделать это таким образом, эта программа является демонстрацией того, как поймать a segmentation fault и вывести его на отладчик (это исходный код, используемый под AIX ) и напечатать стек trace до точки A segmentation fault. Вам нужно будет изменить переменную sprintf , чтобы использовать gdb в случае Linux.

                #include <stdio.h>
                #include <signal.h>
                #include <stdlib.h>
                #include <stdarg.h>static void signal_handler(int);
                static void dumpstack(void);
                static void cleanup(void);
                void init_signals(void);
                void panic(const char *, ...);struct sigaction sigact;
                char *progname;int main(int argc, char **argv) {
                    char *s;
                    progname = *(argv);
                    atexit(cleanup);
                    init_signals();
                    printf("About to seg fault by assigning zero to *s\n");
                    *s = 0;
                    sigemptyset(&sigact.sa_mask);
                    return 0;
                }void init_signals(void) {
                    sigact.sa_handler = signal_handler;
                    sigemptyset(&sigact.sa_mask);
                    sigact.sa_flags = 0;
                    sigaction(SIGINT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGSEGV);
                    sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGBUS);
                    sigaction(SIGBUS, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGQUIT);
                    sigaction(SIGQUIT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGHUP);
                    sigaction(SIGHUP, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGKILL);
                    sigaction(SIGKILL, &sigact, (struct sigaction *)NULL);
                }static void signal_handler(int sig) {
                    if (sig == SIGHUP) panic("FATAL: Program hanged up\n");
                    if (sig == SIGSEGV || sig == SIGBUS){
                        dumpstack();
                        panic("FATAL: %s Fault. Logged StackTrace\n", (sig == SIGSEGV) ? "Segmentation" : ((sig == SIGBUS) ? "Bus" : "Unknown"));
                    }
                    if (sig == SIGQUIT) panic("QUIT signal ended program\n");
                    if (sig == SIGKILL) panic("KILL signal ended program\n");
                    if (sig == SIGINT) ;
                }void panic(const char *fmt, ...) {
                    char buf[50];
                    va_list argptr;
                    va_start(argptr, fmt);
                    vsprintf(buf, fmt, argptr);
                    va_end(argptr);
                    fprintf(stderr, buf);
                    exit(-1);
                }static void dumpstack(void) {
                    /* Got this routine from http://www.whitefang.com/unix/faq_toc.html
                    ** Section 6.5. Modified to redirect to file to prevent clutter
                    */
                    /* This needs to be changed... */
                    char dbx[160];    sprintf(dbx, "echo 'where\ndetach' | dbx -a %d > %s.dump", getpid(), progname);
                    /* Change the dbx to gdb */    system(dbx);
                    return;
                }void cleanup(void) {
                    sigemptyset(&sigact.sa_mask);
                    /* Do any cleaning up chores here */
                }

                Возможно ,вам придется дополнительно добавить параметр, чтобы получить gdb для сброса ядра, как показано здесь в этом блоге.

                t0mm13b   26 января 2010 в 13:46


                16
                 

                Есть еще много вещей, которые могут повлиять на генерацию дампа ядра. Я столкнулся с этим:

                • каталог для дампа должен быть доступен для записи. По умолчанию это текущий каталог процесса, но его можно изменить, установив /proc/sys/kernel/core_pattern .
                • в некоторых условиях значение kernel в /proc/sys/fs/suid_dumpable может препятствовать созданию ядра.

                Есть и другие ситуации, которые могут помешать генерации, описанные на справочной странице-попробуйте man core .

                mlutescu   08 февраля 2012 в 10:07


                10
                 

                Для Ubuntu 14.04

                1. Проверьте, включен ли дамп ядра:

                  ulimit -a
                2. Одна из линий должна быть :

                  core file size          (blocks, -c) unlimited
                3. Если нет :

                  gedit ~/.bashrc и добавьте ulimit -c unlimited в конец файла и сохраните, повторно запустите terminal.

                4. Создайте свое приложение с помощью отладочной информации :

                  В Makefile -O0 -g

                5. Запустите приложение, создающее дамп ядра (файл дампа ядра с именем ' core’ должен быть создан рядом с файлом application_name):

                  ./application_name
                6. Работать под gdb:

                  gdb application_name core
                mrgloom   02 марта 2016 в 12:25


                9
                 

                Для того, чтобы активировать соответствующий дамп памяти, выполните следующие действия:

                1. В /etc/profile прокомментируйте строку:

                  # ulimit -S -c 0 > /dev/null 2>&1
                2. В /etc/security/limits.conf закомментируйте строку:

                  *               soft    core            0
                3. выполните cmd limit coredumpsize unlimited и проверьте его с помощью cmd limit :

                  # limit coredumpsize unlimited
                  # limit
                  cputime      unlimited
                  filesize     unlimited
                  datasize     unlimited
                  stacksize    10240 kbytes
                  coredumpsize unlimited
                  memoryuse    unlimited
                  vmemoryuse   unlimited
                  descriptors  1024
                  memorylocked 32 kbytes
                  maxproc      528383
                  #
                4. чтобы проверить, записан ли основной файл, вы можете убить связанный процесс с помощью cmd kill -s SEGV <PID> (не нужно, просто на случай, если основной файл не будет записан, это можно использовать в качестве проверки):

                  # kill -s SEGV <PID>

                Как только corefile будет записан, убедитесь, что вы снова деактивировали настройки coredump в соответствующих файлах (1./2./3.)!

                Edgar Jordi   19 октября 2012 в 06:34


                4
                 

                По умолчанию вы получите основной файл. Убедитесь, что текущий каталог процесса доступен для записи, иначе основной файл не будет создан.

                Mark Harrison   20 августа 2008 в 14:38


                2
                 

                Лучше включить дамп ядра программно, используя системный вызов setrlimit .

                пример:

                #include <sys/resource.h>bool enable_core_dump(){    
                    struct rlimit corelim;    corelim.rlim_cur = RLIM_INFINITY;
                    corelim.rlim_max = RLIM_INFINITY;    return (0 == setrlimit(RLIMIT_CORE, &corelim));
                }
                kgbook   24 августа 2018 в 08:52


                1
                 

                Стоит отметить, что если у вас есть настроенный systemd , то все немного по-другому. Настройка, как правило, есть основные файлы могут передавать посредством core_pattern значение параметра, через systemd-coredump(8) . Базовый размер файла rlimit, как правило, настраивается как уже "unlimited".

                Затем можно получить дампы ядра с помощью coredumpctl(1) .

                Хранение дампов ядра и т. д. настраивается coredump.conf(5) . Есть примеры того, как получить основные файлы на man-странице coredumpctl, но вкратце это будет выглядеть так:

                Найти системный файл:

                [vps@phoenix]~$ coredumpctl list test_me | tail -1
                Sun 2019-01-20 11:17:33 CET   16163  1224  1224  11 present /home/vps/test_me

                Получить основной файл:

                [vps@phoenix]~$ coredumpctl -o test_me.core dump 16163
                Pawel Veselov   20 января 2019 в 10:59


                1
                 

                Ubuntu 19.04

                Все остальные ответы сами по себе мне не помогли. Но следующий итог сделал свое дело

                Создайте ~/.config/apport/settings со следующим содержимым:

                [main]
                unpackaged=true

                (Это говорит apport также писать основные дампы для пользовательских приложений)

                Регистрация: ulimit -c . Если он выводит 0, исправьте его с помощью

                ulimit -c unlimited

                Просто на всякий случай перезагрузите Аппорт:

                sudo systemctl restart apport

                Файлы сбоев теперь записываются в /var/crash/ . Но вы не можете использовать их с gdb. Чтобы использовать их с gdb, используйте

                apport-unpack <location_of_report> <target_directory>

                Дополнительная информация:

                • Некоторые ответы предполагают изменение core_pattern . Имейте в виду, что этот файл может быть перезаписан службой apport при перезапуске.
                • Просто остановка аппорта не сделала своей работы
                • Значение ulimit -c может быть изменено автоматически, пока вы пытаетесь найти другие ответы в интернете. Обязательно регулярно проверяйте его во время настройки создания дампа ядра.

                Рекомендации:

                • https://stackoverflow.com/a/47481884/6702598
                  • Я получаю ошибку сегментации (дамп ядра) в следующем коде: void Update_Log( ) { struct logData update; int file; char *writeBuffer=NULL; if((file=creat(/home/user/Desktop/DMS/DMS/filename.txt,O_RDONLY|O_WRONLY))==-1) perror(file not opened); update.clientName=user; update.filename=user;...

                  • Linux: дамп ядра о сигнале 4

                    На платформе linux моя прикладная программа иногда получала дамп ядра из-за сигнала 4. И я нахожу, что сигнал 4 означает незаконную инструкцию. Поэтому у меня есть один вопрос: Как получить незаконную инструкцию и что может вызвать дамп ядра signal 4.



                  254
                   

                  Это зависит от того, какой shell вы используете. Если вы используете bash, то команда ulimit управляет несколькими настройками, связанными с выполнением программы,например, следует ли сбрасывать ядро. Если вы наберете

                  ulimit -c unlimited

                  тогда это скажет bash, что его программы могут сбрасывать ядра любого размера. Вы можете указать размер, например 52M вместо неограниченного, если хотите, но на практике это не должно быть необходимо, так как размер основных файлов, вероятно, никогда не будет проблемой для вас.

                  В tcsh вы бы набрали

                  limit coredumpsize unlimited
                  Eli Courtwright   20 августа 2008 в 13:50


                  60
                   

                  Как было объяснено выше, реальный вопрос, который здесь задается, заключается в том, как включить дампы ядра в системе, где они не включены. Ответ на этот вопрос ДАН здесь.

                  Если вы пришли сюда в надежде узнать, как создать дамп ядра для зависшего процесса, то ответ таков:

                  gcore <pid>

                  если gcore недоступен в вашей системе, то

                  kill -ABRT <pid>

                  Не используйте kill -SEGV, так как это часто вызывает обработчик сигнала, что затрудняет диагностику застрявшего процесса

                  George Co   05 февраля 2013 в 14:28


                  33
                   

                  Чтобы проверить, где генерируются дампы ядра, выполните:

                  sysctl kernel.core_pattern

                  или:

                  cat /proc/sys/kernel/core_pattern

                  где %e - имя процесса, а %t -системное время. Вы можете изменить его в /etc/sysctl.conf и перезагрузить на sysctl -p .

                  Если основные файлы не сгенерированы (проверьте их по: sleep 10 & и killall -SIGSEGV sleep), проверьте ограничения по: ulimit -a .

                  Если размер вашего основного файла ограничен, запустите:

                  ulimit -c unlimited

                  чтобы сделать его неограниченным.

                  Затем проверьте еще раз, если сброс ядра прошел успешно, вы увидите “(Сброс ядра)” после указания segmentation fault, как показано ниже:

                  Segmentation fault: 11 (ядро бросила)

                  См. также: Core dumped - но основной файл не находится в текущем каталоге?


                  Ubuntu

                  В Ubuntu основные дампы обрабатываются Apport и могут быть расположены в /var/crash/ . Однако в стабильных выпусках он по умолчанию отключен.

                  Для получения более подробной информации, пожалуйста, проверьте: где я могу найти дамп ядра в Ubuntu? .

                  macOS

                  Для macOS см.: Как генерировать дампы ядра в Mac OS X?

                  kenorb   08 сентября 2015 в 15:27

                  • segmentation fault (дамп памяти)

                    Я получаю ошибку сегментации (дамп ядра), когда пытаюсь запустить это. Он прекрасно компилируется, но я получаю ошибку, и я не знаю почему. Я пытался редактировать свой код всеми возможными способами, но все еще получаю эту ошибку. У меня уже кончились идеи. Любая помощь была бы очень кстати....

                  • Linux: обработка segmentation fault и получение дампа ядра

                    Когда мое приложение выходит из строя с segmentation fault, я хотел бы получить дамп ядра из системы. Я делаю это, настраивая перед рукой ulimit -c unlimited Я также хотел бы иметь указание в моих журналах приложений, что произошло segmentation fault. Я делаю это с помощью sigaction() . Однако...

                   


                  27
                   

                  В конце концов я прикрепил gdb к процессу до того, как он разбился, а затем, когда он получил segfault, я выполнил команду generate-core-file . Это вынужденная генерация дампа ядра.

                  Nathan Fellman   20 августа 2008 в 17:33


                  19
                   

                  Может быть, вы могли бы сделать это таким образом, эта программа является демонстрацией того, как поймать a segmentation fault и вывести его на отладчик (это исходный код, используемый под AIX ) и напечатать стек trace до точки A segmentation fault. Вам нужно будет изменить переменную sprintf , чтобы использовать gdb в случае Linux.

                  #include <stdio.h>
                  #include <signal.h>
                  #include <stdlib.h>
                  #include <stdarg.h>static void signal_handler(int);
                  static void dumpstack(void);
                  static void cleanup(void);
                  void init_signals(void);
                  void panic(const char *, ...);struct sigaction sigact;
                  char *progname;int main(int argc, char **argv) {
                      char *s;
                      progname = *(argv);
                      atexit(cleanup);
                      init_signals();
                      printf("About to seg fault by assigning zero to *s\n");
                      *s = 0;
                      sigemptyset(&sigact.sa_mask);
                      return 0;
                  }void init_signals(void) {
                      sigact.sa_handler = signal_handler;
                      sigemptyset(&sigact.sa_mask);
                      sigact.sa_flags = 0;
                      sigaction(SIGINT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGSEGV);
                      sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGBUS);
                      sigaction(SIGBUS, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGQUIT);
                      sigaction(SIGQUIT, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGHUP);
                      sigaction(SIGHUP, &sigact, (struct sigaction *)NULL);    sigaddset(&sigact.sa_mask, SIGKILL);
                      sigaction(SIGKILL, &sigact, (struct sigaction *)NULL);
                  }static void signal_handler(int sig) {
                      if (sig == SIGHUP) panic("FATAL: Program hanged up\n");
                      if (sig == SIGSEGV || sig == SIGBUS){
                          dumpstack();
                          panic("FATAL: %s Fault. Logged StackTrace\n", (sig == SIGSEGV) ? "Segmentation" : ((sig == SIGBUS) ? "Bus" : "Unknown"));
                      }
                      if (sig == SIGQUIT) panic("QUIT signal ended program\n");
                      if (sig == SIGKILL) panic("KILL signal ended program\n");
                      if (sig == SIGINT) ;
                  }void panic(const char *fmt, ...) {
                      char buf[50];
                      va_list argptr;
                      va_start(argptr, fmt);
                      vsprintf(buf, fmt, argptr);
                      va_end(argptr);
                      fprintf(stderr, buf);
                      exit(-1);
                  }static void dumpstack(void) {
                      /* Got this routine from http://www.whitefang.com/unix/faq_toc.html
                      ** Section 6.5. Modified to redirect to file to prevent clutter
                      */
                      /* This needs to be changed... */
                      char dbx[160];    sprintf(dbx, "echo 'where\ndetach' | dbx -a %d > %s.dump", getpid(), progname);
                      /* Change the dbx to gdb */    system(dbx);
                      return;
                  }void cleanup(void) {
                      sigemptyset(&sigact.sa_mask);
                      /* Do any cleaning up chores here */
                  }

                  Возможно ,вам придется дополнительно добавить параметр, чтобы получить gdb для сброса ядра, как показано здесь в этом блоге.

                  t0mm13b   26 января 2010 в 13:46


                  16
                   

                  Есть еще много вещей, которые могут повлиять на генерацию дампа ядра. Я столкнулся с этим:

                  • каталог для дампа должен быть доступен для записи. По умолчанию это текущий каталог процесса, но его можно изменить, установив /proc/sys/kernel/core_pattern .
                  • в некоторых условиях значение kernel в /proc/sys/fs/suid_dumpable может препятствовать созданию ядра.

                  Есть и другие ситуации, которые могут помешать генерации, описанные на справочной странице-попробуйте man core .

                  mlutescu   08 февраля 2012 в 10:07


                  10
                   

                  Для Ubuntu 14.04

                  1. Проверьте, включен ли дамп ядра:

                    ulimit -a
                  2. Одна из линий должна быть :

                    core file size          (blocks, -c) unlimited
                  3. Если нет :

                    gedit ~/.bashrc и добавьте ulimit -c unlimited в конец файла и сохраните, повторно запустите terminal.

                  4. Создайте свое приложение с помощью отладочной информации :

                    В Makefile -O0 -g

                  5. Запустите приложение, создающее дамп ядра (файл дампа ядра с именем ' core’ должен быть создан рядом с файлом application_name):

                    ./application_name
                  6. Работать под gdb:

                    gdb application_name core
                  mrgloom   02 марта 2016 в 12:25


                  9
                   

                  Для того, чтобы активировать соответствующий дамп памяти, выполните следующие действия:

                  1. В /etc/profile прокомментируйте строку:

                    # ulimit -S -c 0 > /dev/null 2>&1
                  2. В /etc/security/limits.conf закомментируйте строку:

                    *               soft    core            0
                  3. выполните cmd limit coredumpsize unlimited и проверьте его с помощью cmd limit :

                    # limit coredumpsize unlimited
                    # limit
                    cputime      unlimited
                    filesize     unlimited
                    datasize     unlimited
                    stacksize    10240 kbytes
                    coredumpsize unlimited
                    memoryuse    unlimited
                    vmemoryuse   unlimited
                    descriptors  1024
                    memorylocked 32 kbytes
                    maxproc      528383
                    #
                  4. чтобы проверить, записан ли основной файл, вы можете убить связанный процесс с помощью cmd kill -s SEGV <PID> (не нужно, просто на случай, если основной файл не будет записан, это можно использовать в качестве проверки):

                    # kill -s SEGV <PID>

                  Как только corefile будет записан, убедитесь, что вы снова деактивировали настройки coredump в соответствующих файлах (1./2./3.)!

                  Edgar Jordi   19 октября 2012 в 06:34


                  4
                   

                  По умолчанию вы получите основной файл. Убедитесь, что текущий каталог процесса доступен для записи, иначе основной файл не будет создан.

                  Mark Harrison   20 августа 2008 в 14:38


                  2
                   

                  Лучше включить дамп ядра программно, используя системный вызов setrlimit .

                  пример:

                  #include <sys/resource.h>bool enable_core_dump(){    
                      struct rlimit corelim;    corelim.rlim_cur = RLIM_INFINITY;
                      corelim.rlim_max = RLIM_INFINITY;    return (0 == setrlimit(RLIMIT_CORE, &corelim));
                  }
                  kgbook   24 августа 2018 в 08:52


                  1
                   

                  Стоит отметить, что если у вас есть настроенный systemd , то все немного по-другому. Настройка, как правило, есть основные файлы могут передавать посредством core_pattern значение параметра, через systemd-coredump(8) . Базовый размер файла rlimit, как правило, настраивается как уже "unlimited".

                  Затем можно получить дампы ядра с помощью coredumpctl(1) .

                  Хранение дампов ядра и т. д. настраивается coredump.conf(5) . Есть примеры того, как получить основные файлы на man-странице coredumpctl, но вкратце это будет выглядеть так:

                  Найти системный файл:

                  [vps@phoenix]~$ coredumpctl list test_me | tail -1
                  Sun 2019-01-20 11:17:33 CET   16163  1224  1224  11 present /home/vps/test_me

                  Получить основной файл:

                  [vps@phoenix]~$ coredumpctl -o test_me.core dump 16163
                  Pawel Veselov   20 января 2019 в 10:59


                  1
                   

                  Ubuntu 19.04

                  Все остальные ответы сами по себе мне не помогли. Но следующий итог сделал свое дело

                  Создайте ~/.config/apport/settings со следующим содержимым:

                  [main]
                  unpackaged=true

                  (Это говорит apport также писать основные дампы для пользовательских приложений)

                  Регистрация: ulimit -c . Если он выводит 0, исправьте его с помощью

                  ulimit -c unlimited

                  Просто на всякий случай перезагрузите Аппорт:

                  sudo systemctl restart apport

                  Файлы сбоев теперь записываются в /var/crash/ . Но вы не можете использовать их с gdb. Чтобы использовать их с gdb, используйте

                  apport-unpack <location_of_report> <target_directory>

                  Дополнительная информация:

                  • Некоторые ответы предполагают изменение core_pattern . Имейте в виду, что этот файл может быть перезаписан службой apport при перезапуске.
                  • Просто остановка аппорта не сделала своей работы
                  • Значение ulimit -c может быть изменено автоматически, пока вы пытаетесь найти другие ответы в интернете. Обязательно регулярно проверяйте его во время настройки создания дампа ядра.

                  Рекомендации:

                  • https://stackoverflow.com/a/47481884/6702598