In this article, we learn about Linux's different kernel signals, explaining their purposes and how they work together to keep your system running smoothly.

Kernel signals are a crucial part of the Linux Operating System, and understanding how it works is essential if we want to delve deeper into Linux. In a nutshell Kernel Signals are a mechanism through which the kernel communicates with running processes.

Let's learn about Kernel Signals and how it works.

How Kernel Signals Work?

Kernel signals are software interrupts that are delivered to processes. These signals are triggered by various events like user input (pressing CTRL+C), hardware exceptions (memory saturation, divide by 0), and software events (timeouts). When a signal is generated, the kernel will interrupt the normal flow of execution of a particular process and handle the signal according to the signal disposition.

Signal Disposition: Signal disposition refers to how a process chooses to handle or respond to a particular signal when it is delivered by the kernel. There are three possible signal dispositions in Linux:

Types of Signal Dispositions

a. Ignore Signal: The process can ignore certain types of Signals.

b. Terminate the process: Signals like SIGKILL, SIGTERM will terminate the process.

c. Catch and Handle: The process can define a signal handler to catch and handle signals in a custom way. For example, in Python, using the code below will handle the CTRL+C signal (SIGINT) and provide a message as output.

except KeyboardInterrupt:
        print("\nInterrupted by user with SIGINT. Exiting...")

Signal Interrupt Handling in Python3

Different Types of Kernel Signals

There are several standard signals in Linux, each with a specific purpose and behaviour. If a signal suited for a hard kill is used to kill processes indiscriminately, there can be significant side effects, so it is always recommended to consider the issue before turning towards a certain signal.

Some of the most commonly used Kernel Signals are:

  1. SIGHUP (Signal Hang Up): The signal SIGHUP is sent when a controlling terminal or process is terminated. It's often used for restarting/reloading configuration files for long-running processes.
  2. SIGINT (Signal Interrupt): The signal SIGINT is sent when a user process CTRL+C to interrupt running processes.
  3. SIGQUIT (Signal Quit): The signal SIGQUIT is sent when a user presses CTRL+\ and is used to terminate a process and provide a core dump for debugging purposes.
  4. SIGKILL (Signal Kill): This is the signal for Hard Kill, a process that can be forcibly terminated by using this signal. It can neither be caught nor ignored.
  5. SIGTERM (Signal Terminate): This signal is sent to request a process to terminate itself gracefully. It's recommended to always use SIGTERM before resorting to SIGKILL. SIGTERM allows a process to close itself and handle temp files, etc, that it has created, SIGKILL will kill the process without giving it time to clean up.
  6. SIGSEV (Signal Segmentation Violation): This signal is raised when a process tries to access a memory location that is forbidden for access. It indicates a memory segmentation fault.
  7. SIGCHILD (Signal Child): This signal is sent to a parent process when one of its child processes terminates or stops.
  8. SIGALARM (Signal Alarm): The Signal SIGALARM can schedule timers to execute certain functions after a specified time interval.
  9. SIGTRAP (Signal Trap): The Signal SIGTRAP can be used to Trap running processes. It's useful for debugging a fault process.
  10. SIGSTOP (Signal Stop): The Signal SIGSTOP can be used to Stop running processes. It's useful for debugging a fault process.
Learn more about Kernel Signals here.

Kernel Signals Use Cases

Kernel Signals have various use cases. Some of the most common ones are listed below:

  1. Process Management: Signals are used to control the lifecycle of processes, such as terminating, stopping or resuming them.
  2. Interprocess Communication: Signals can be used to communicate between processes by sending signals directly or by using signaling mechanisms like Unix signal queues.
  3. Error Handling: Signals are used to handle errors and exceptional conditions, such as segmentation faults or illegal instructions.
  4. Job Control: In shell environments, signals are used to control the behaviour of foreground and background processes.
  5. Debugging: Signals like SIGTRAP and SIGSTOP are useful for debugging purposes, allowing developers to pause and inspect running processes.


In this blog article, we learned about Linux Kernel Signals, Signal Handling, Signal Disposition and many more concepts. Armed with this knowledge, we can now dive even deeper into Linux Kernels.

Thank You for reading, please comment below if you have any queries. I periodically try to update my articles to ensure legibility.