O método e configuração do Linux para gerar despejo de núcleo

Endereço original: https://www.cnblogs.com/flyinggod/p/13415862.html

Artigos relacionados

1. Função, configuração e uso do arquivo principal ---- https://www.cnblogs.com/xiaodoujiaohome/p/6222895.html

2. Configurações do sistema Linux ulimit e geração do arquivo Core- https://blog.csdn.net/zjb9605025/article/details/6553184

 

core dump 定义
A core dump is the recorded state of the working memory of a computer program at a specific time, generally when the
program has terminated abnormally (crashed). In practice, other key pieces of program state are usually dumped at
the same time, including the processor registers, which may include the program counter and stack pointer, memory
management information, and other processor and operating system flags and information. The name comes from the
once-standard memory technology core memory. Core dumps are often used to diagnose or debug errors in computer programs.

On many operating systems, a fatal error in a program automatically triggers a core dump, and by extension the phrase
"to dump core" has come to mean, in many cases, any fatal error, regardless of whether a record of the program memory
is created.

Método de geração de despejo de núcleo

No ambiente Linux, um processo trava devido a uma exceção e geralmente é difícil encontrar a causa.No entanto, o arquivo principal fornecido pelo kernel do Linux geralmente registra as informações do processo quando ele trava. No entanto, uma opção precisa ser definida para gerar um arquivo principal. As etapas específicas são as seguintes:

1. Verifique se a chave para gerar o arquivo principal está ligada e digite o comando

ulimit -a

O tamanho do arquivo principal na primeira linha é 0 e não está habilitado.

2. Use ulimit -c [kbytes] para definir o tamanho do arquivo principal permitido pelo sistema.

ulimit -c 0              #不产生core文件
ulimit -c 100            #设置core文件最大为100k
ulimit -c unlimited      #不限制core文件大小

Execute o comando ulimit -c unlimited e, em seguida, ulimit -a para visualizar o núcleo

 Desta forma, o arquivo principal pode ser gerado quando o processo travar. Este método só pode ter efeito no shell. Se esta configuração for sempre eficaz, você precisa fazer as seguintes configurações

vim /etc/profile                                   #然后进入编辑模式，在profile文件中加入
ulimit -c unlimited

 Salve e saia, reinicie o servidor, o arquivo alterado terá efeito por um longo tempo, ou

fonte / etc / perfil

Não reinicie o servidor, use o código-fonte para tornar o arquivo efetivo imediatamente.

3. Especifique o caminho e o nome do arquivo gerado

Por padrão, o nome do arquivo gerado pelo core dump é core e está localizado no diretório atual do programa. O novo núcleo sobrescreverá o núcleo existente. Ao modificar o arquivo / proc / sys / kernel / core_uses_pid, você pode controlar o local de armazenamento e o formato do arquivo do núcleo.

vim /etc/sysctl.conf 

#Entre no modo de edição e adicione as seguintes linhas kernel.core_pattern = / tmp / corefile / core_% t_% e_% p 
kernel.core_uses_pid = 0

Crie um diretório principal em var, use

sysctl –p /etc/sysctl.conf

A modificação entrará em vigor imediatamente.

Os parâmetros nomeados de core_pattern são os seguintes:

% c O limite superior do tamanho do arquivo de despejo 
% e O nome do arquivo despejado 
% g O ID do grupo real do processo despejado 
% h O nome do host 
% p O processo despejado PID 
% s O sinal que causou este coredump 
% t tempo de despejo ( O número de segundos desde 1º de janeiro de 1970) 
% u O ID de usuário real do processo despejado

4. Execute o comando no terminal: kill -s SIGSEGV $$, você pode ver que um arquivo principal é gerado em / tmp / corefile, indicando que a configuração foi bem-sucedida.

O arquivo principal não é gerado nas seguintes condições:

进程是设置- 用户-ID ，而且当前用户并非程序文件的所有者；
进程是设置- 组-ID ，而且当前用户并非该程序文件的组所有者；
用户没有写当前工作目录的许可权；
文件太大。core 文件的许可权( 假定该文件在此之前并不存在) 通常是用户读/ 写，组读和其他读。

Princípio de geração de core dump

O coredump geralmente ocorre quando o processo recebe um certo sinal. Atualmente, existem mais de 60 sinais no Linux. Você pode usar o comando kill -l para listar todos eles.

Para um sinal específico, o aplicativo pode escrever a função de processamento de sinal correspondente. Se não for especificado, o método de processamento padrão é adotado. O processamento padrão é o sinal de coredump da seguinte forma:

3)SIGQUIT   4)SIGILL    6)SIGABRT   8)SIGFPE    11)SIGSEGV    7)SIGBUS    31)SIGSYS
5)SIGTRAP   24)SIGXCPU  25)SIGXFSZ  29)SIGIOT

Vemos que SIGSEGV está nele.Geralmente, este sinal é gerado quando um array está fora dos limites ou quando um ponteiro nulo é acessado. Além disso, embora este seja o padrão, você também pode escrever sua própria função de processamento de sinal para alterar o comportamento padrão. Você pode pesquisar no Google para obter mais informações relacionadas a sinais.

depuração de arquivo de despejo de núcleo

#include <stdio.h>

int func(int *p)
{
        *p = 0;
}

int main()
{
        func(NULL);
        return 0;
}

O código acima é um exemplo de código que irá gerar coredump

 Neste momento, um novo arquivo principal é gerado neste programa executável

Veja onde o processo travou

Localize a linha do acidente

Você pode ativar a opção de depuração -g ao compilar

gcc main.c -g -o a.c

Se você não quiser definir o modo global coredum, você só precisa gerar um arquivo principal que possa localizar o local da falha para o processo atual. Apenas 4 operações são necessárias.

ulimit -c unlimited
echo "/tmp/core-%e-%p" > /proc/sys/kernel/core_pattern
gcc -o main -g a.c
gdb main /tmp/core-main-10815

Uma coisa a se notar ao compilar o programa acima, você precisa trazer o parâmetro -g, para que o programa executável gerado traga informações de depuração suficientes. Depois de compilar e executar, você deve ser capaz de ver as esperadas palavras "Falha de segmento (despejo de núcleo)" ou "Falha de segmento (despejo de núcleo)". Verifique se há um arquivo core ou core.xxx no diretório atual. Use o depurador clássico GDB no Linux, primeiro carregue o programa com o arquivo principal: gdb exefile core, aqui você precisa prestar atenção ao arquivo principal deve ser gerado pelo exefile, caso contrário, a tabela de símbolos não será carregada. Parece assim depois de carregar

sagi@sagi-laptop:~$ gdb coredump core
Core was generated by ./coredump'.
    Program terminated with signal 11, Segmentation fault.
#0  0x080483a7 in crash () at coredump.c:8
    8       xxx[1] = 'D';
(gdb)

Podemos ver que podemos localizar diretamente o núcleo e escrever uma área de memória somente leitura na linha 8 que faz com que o sinal de falha de segmento seja acionado. Há um pequeno truque ao carregar o núcleo. Se você não sabe qual programa gerou o arquivo do núcleo com antecedência, você pode encontrar um para substituí-lo. Por exemplo, / usr / bin / w é uma boa escolha. Por exemplo, se usarmos este método para carregar o núcleo gerado acima, o gdb terá uma saída semelhante

sagi@sagi-laptop:~$ gdb /usr/bin/w core
Core was generated by ./coredump'.
    Program terminated with signal 11, Segmentation fault.
#0  0x080483a7 in ?? ()
    (gdb)

Você pode ver que o GDB já o lembrou de qual programa gerou esse núcleo.

Operações comuns GDB

O programa acima é relativamente simples e o problema pode ser encontrado diretamente, sem operações adicionais. Na realidade, este não é o caso. Freqüentemente, é necessário realizar o rastreamento de uma única etapa, definindo pontos de interrupção e outras operações para localizar o problema sem problemas. Algumas operações comuns do GDB estão listadas abaixo.

启动程序：run
设置断点：b 行号|函数名
删除断点：delete 断点编号
禁用断点：disable 断点编号
启用断点：enable 断点编号
单步跟踪：next 也可以简写 n
单步跟踪：step 也可以简写 s
打印变量：print 变量名字
设置变量：set var=value
查看变量类型：ptype var
顺序执行到结束：cont
顺序执行到某一行： util lineno
打印堆栈信息：bt