本文共 8326 字，大约阅读时间需要 27 分钟。

Linux Signals —— Core Dump and Signal Handling

In this article, we'll explore the concept of core dump, which is a valuable tool for debugging and understanding program crashes. We'll also delve into signal handling, including signal delivery, pending signals, and signal blocking.

Core Dump

Core dump, literally translated as "core dump" or colloquially known as "spill core," is a term in computer science. It refers to a scenario where a program terminates abnormally due to errors, exceptions, or specific signals. In such cases, the operating system captures the program's memory state at the moment of termination and saves it into a file known as a core file. This core file is a precious resource for developers as it provides insights into why the program failed, especially in scenarios where the error is difficult to reproduce.

The core file typically includes:

• Memory contents: A snapshot of the program's memory at the moment of the crash.
• 寄存器状态: Details like the program counter, stack pointer, and other registers, which are crucial for reconstructing the execution flow.
• 内存管理信息: Insights into how the program allocated and managed its memory.
• 系统和处理器状态信息: Additional operational data related to the processor and OS.

These details are invaluable for debugging. Using tools like GDB (GNU Debugger), developers can load the core file and the corresponding executable file to analyze the crash state, identify the root cause, and fix the issue.

Enabling Core Dump

By default, core dump is usually disabled. This can be checked using the ulimit -a command. If we want core files to be generated, we can set the core file size temporarily with ulimit -c size in the current session. However, this setting is reset upon relogin.

Why Core Dump is Default Disabled

The reasons for core dump being disabled by default are as follows:

Despite these reasons, core files are a powerful debugging tool. Developers and system administrators often configure core files to be generated in development and test environments, setting appropriate limits and storage locations to balance debugging convenience with system management needs.

Handling Signals

What's signal handling?

Signal handling is a fundamental aspect of Unix-like systems like Linux. Signals are like intelligent interrupts that notify processes of specific events, such as hardware errors, software exceptions, or user actions (e.g., pressing Ctrl+C).

Key Concepts

• Signal delivery: The process of transferring a signal from the OS to the target process.
• Pending signals: A signal that has been generated but is awaiting processing due to blocking or other reasons.
• Signal blocking: A mechanism where a process can temporarily prevent certain signals from being delivered immediately.

Signal Delivery

Signal delivery consists of several key steps:

Pending Signals

Pending signals describe a scenario where one or more signals have been generated but are yet to be processed. This can occur due to:

• Signal blocking: A process may block certain signals, causing them to remain pending until the process unblocks them.
• Signal handling: If a process is handling another signal, new signals may remain pending until the current signal is processed.
• Specific timing: Signals may remain pending during certain system calls that cannot be interrupted, ensuring system stability and data consistency.

Signal Blocking

Signal blocking allows a process to prevent immediate delivery of specific signals. This is achieved by setting a signal mask, which lists the signals that are blocked. Blocked signals remain pending until the process explicitly unblocks them.

Understanding the Differences

Understanding the difference between signal blocking and pending signals is crucial:

• Blocking is active: It actively prevents signal delivery, keeping the signal in a pending state.
• Pending is a state: Signals may be pending even if not explicitly blocked, depending on other factors like signal handling or system timing.

Blocking and pending signals are complementary features that help manage how and when signals affect a process, ensuring both flexibility and stability in the system.

Signal Related Functions

In Linux system programming, the following functions are essential for managing and responding to received signals:

These functions provide fine-grained control over signal handling, making it easier to manage asynchronous events and exceptions in your applications.

A Simple Example of Signal Handling

Consider the following code snippet:

#include 
   
    
#include 
    
     
#include 
     
      
int main() {
    signal(2, signal_handler); // Set up a custom signal handler for signal 2
    sigset_t set; // Signal set for blocking signals
    sigprocmask(SIG_BLOCK, &set, 0); // Block signal 2
    while (true) {
        std::cout << "Process is running... PID: " << getpid() << std::endl;
        sleep(1);
    }
}
     
    
   

This code blocks signal 2, allowing the process to continue execution without interruption. Signal handling is crucial for responsive and stable programs, especially in multi-threaded environments.

Using Sigpending

The sigpending function is used to check for pending signals. Here's an example:

#include 
   
    
#include 
    
     
#include 
     
      
void PrintPendingsignals(const sigset_t &pending) {
    for (int i = 1; i <= 31; ++i) {
        if (sigismember(&pending, i)) {
            std::cout << "1";
        } else {
            std::cout << "0";
        }
    }
    std::cout << "\n";
}
int main() {
    // Block signal 2 and send it
    signal(2, signal_handler);
    sigset_t set;
    sigprocmask(SIG_BLOCK, &set, 0);
    int cnt = 0;
    while (true) {
        sigpending(&set);
        PrintPendingsignals(set);
        if (cnt == 5) {
            sigprocmask(SIG_UNBLOCK, &set, 0);
            kill(getpid(), 2);
        }
        cnt++;
        sleep(1);
    }
}
     
    
   

This code demonstrates how to use sigpending to check for pending signals and how to manage signal blocking and unblocking. By understanding and effectively handling signals, developers can create more robust and reliable applications.

转载地址：http://rswfk.baihongyu.com/