6.6.2. Handling Signals

● Signals are used to communicate events such as the completion of an I/O operation, timer expirations, or a request to terminate a process.

Signals are a form of communication that the Linux operating system uses to inform applications running in user space about certain occurrences. For instance, when an event happens—like a timer running out or a user wanting to terminate an application—the kernel sends a signal. This ensures that applications can respond rapidly to changes in their environment or execution state.

Think of signals like alerts on your phone. Each alert (or signal) represents a specific event, like receiving a message, an appointment reminder, or a call. Just like you need to respond to these notifications, applications need to handle signals to stay responsive to users or to manage their tasks effectively.

● A user-space process can handle signals by registering a signal handler using the signal() or sigaction() system calls. For example, when the user presses Ctrl+C, the kernel sends a SIGINT signal to the running process, which can either terminate the process or handle the signal in some other way.

To respond to signals, applications must define a 'signal handler', which is a function specifying what actions to perform when a specific signal is received. For instance, when a user presses Ctrl+C, the application receives a SIGINT signal. By setting up a signal handler, the application can choose to either terminate or execute a custom function, such as saving work before closing.

Imagine you’re in a classroom, and a fire alarm suddenly goes off (the signal). The teacher (the signal handler) has the option to either evacuate the class immediately (terminate the process) or instruct the students to gather their belongings (handle the signal). The teacher’s decision can vary based on the situation, similar to how an application can choose its response to signals.

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

void handle_signal(int signal) { printf("Signal received: %d\n", signal); }

int main() { signal(SIGINT, handle_signal); // Register signal handler for SIGINT (Ctrl+C) while (1) { sleep(1); // Simulate a running process } return 0; }

In this example, the C program registers a signal handler to handle the SIGINT signal. This means if the user presses Ctrl+C while the program is running, instead of terminating immediately, it will run the handle_signal() function. This function simply prints out the received signal number, giving feedback that a signal has been received.

Consider this like a waiter at a restaurant. If a customer raises their hand (sends a signal), the waiter (signal handler) comes over to check on them instead of just ignoring them. The waiter can then choose how to assist the customer based on their needs. Similarly, when the running program receives a signal, it can respond appropriately instead of just terminating.

--