How to send different signals to a process in Linux?

Sending Different Signals to a Process in Linux

In the Linux operating system, processes can receive various signals that allow you to control their behavior and execution. Signals are a form of inter-process communication (IPC) that enable you to send notifications or instructions to a running process.

Understanding Signals in Linux

Signals are software-generated interrupts that are sent to a process to notify it of a specific event or condition. When a process receives a signal, it can choose to handle the signal, ignore it, or allow the default behavior to occur. Linux provides a wide range of predefined signals that serve different purposes, such as:

1. Termination Signals: These signals are used to terminate a process, such as SIGINT (Interrupt), SIGTERM (Terminate), and SIGKILL (Kill).
2. Suspension Signals: These signals are used to suspend or pause a process, such as SIGSTOP (Stop) and SIGTSTP (Terminal Stop).
3. Continuation Signals: These signals are used to resume a suspended process, such as SIGCONT (Continue).
4. Error Signals: These signals are used to notify a process of an error condition, such as SIGSEGV (Segmentation Fault) and SIGFPE (Floating-Point Exception).
5. User-Defined Signals: Linux also allows you to define your own custom signals, which can be used for specific application-level needs.

Sending Signals to a Process

To send a signal to a process in Linux, you can use the kill command or the kill() system call from within your program. The kill command takes the process ID (PID) of the target process and the signal to be sent as arguments.

Here's an example of using the kill command to send the SIGTERM signal to a process with PID 1234:

kill -SIGTERM 1234

Alternatively, you can use the kill() system call from within your C program to send a signal to a process. Here's an example:

#include <signal.h>
#include <unistd.h>

int main() {
    pid_t pid = 1234; // Target process ID
    int signal = SIGTERM; // Signal to be sent

    if (kill(pid, signal) == -1) {
        perror("kill");
        return 1;
    }

    return 0;
}

In this example, the kill() function is used to send the SIGTERM signal to the process with PID 1234. If the signal is successfully sent, the function returns 0; otherwise, it returns -1 and sets the errno variable to indicate the error.

Handling Signals in a Process

When a process receives a signal, it can choose to handle the signal, ignore it, or allow the default behavior to occur. To handle a signal, a process can register a signal handler function using the signal() or sigaction() system calls.

Here's an example of using signal() to register a signal handler for the SIGINT (Interrupt) signal:

#include <signal.h>
#include <stdio.h>
#include <unistd.h>

void signal_handler(int signum) {
    printf("Received signal: %d\n", signum);
    // Perform custom signal handling logic here
}

int main() {
    // Register the signal handler for SIGINT
    signal(SIGINT, signal_handler);

    printf("Process running. Press Ctrl+C to interrupt.\n");

    // Keep the process running until it receives a signal
    while (1) {
        pause();
    }

    return 0;
}

In this example, the signal_handler() function is registered to handle the SIGINT signal. When the process receives the SIGINT signal (e.g., by pressing Ctrl+C), the signal_handler() function is called, and the process can perform custom signal handling logic.

By understanding how to send and handle signals in Linux, you can create more robust and responsive applications that can react to various events and conditions during their execution.