6.6. Signals and Interrupts

● 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 used within the operating system, particularly in Unix-like systems. They act as notifications for user-space processes, letting them know when certain events occur. For example, if you save your work but the system needs to shut down for updates, a signal can inform your application to save its state before closing. Signals are standard ways for the system to notify processes about events they need to be aware of.

Think of signals like notifications on your smartphone. When you receive a message, your phone sends you a notification, alerting you about it. Similarly, signals alert a program that something important has happened, allowing it to react accordingly.

● 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.

When a process is running, it can set up special routines called signal handlers to manage how it responds to different signals. For instance, if the user wants to interrupt a running program using Ctrl+C, the operating system sends a SIGINT signal. The program can decide whether to stop completely or to execute a specific piece of code to handle the interruption gracefully, such as saving data before closing.

Imagine a waiter at a restaurant who can react to various customer requests. If a customer waves their hand (like sending a signal), the waiter could either come over to take an order (handle the signal directly) or ignore it if they are currently busy serving someone else. In programming, signals are similar; a process can choose how to react each time it receives one.

#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, a simple C program registers a signal handler for the SIGINT signal, which is triggered when the user presses Ctrl+C. The formal registration is done through the signal() function, telling the program to execute the handle_signal() function whenever it receives the SIGINT signal. The program then enters an infinite loop, simulating ongoing work. Each time it receives the SIGINT signal, it will print a message indicating that it received the signal.

Consider a fire alarm system in a building. The system is always 'listening' for a fire signal (like the SIGINT from Ctrl+C). When the fire signal is received, the alarm sounds, and the staff respond according to the procedures in place. Similarly, this program continuously runs and only stops to execute the specific signal handler when a SIGINT signal arrives.

--