How does SIGINT relate to the other termination signals such as SIGTERM, SIGQUIT and SIGKILL?

SIGTERM and SIGKILL are intended for general purpose "terminate this process" requests. SIGTERM (by default) and SIGKILL (always) will cause process termination. SIGTERM may be caught by the process (e.g. so that it can do its own cleanup if it wants to), or even ignored completely; but SIGKILL cannot be caught or ignored.

SIGINT and SIGQUIT are intended specifically for requests from the terminal: particular input characters can be assigned to generate these signals (depending on the terminal control settings). The default action for SIGINT is the same sort of process termination as the default action for SIGTERM and the unchangeable action for SIGKILL; the default action for SIGQUIT is also process termination, but additional implementation-defined actions may occur, such as the generation of a core dump. Either can be caught or ignored by the process if required.

SIGHUP, as you say, is intended to indicate that the terminal connection has been lost, rather than to be a termination signal as such. But, again, the default action for SIGHUP (if the process does not catch or ignore it) is to terminate the process in the same way as SIGTERM etc. .

There is a table in the POSIX definitions for signal.h which lists the various signals and their default actions and purposes, and the General Terminal Interface chapter includes a lot more detail on the terminal-related signals.

man 7 signal

This is the convenient non-normative manpage of the Linux man-pages project that you often want to look at for Linux signal information.

Version 3.22 mentions interesting things such as:

The signals SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.

and contains the table:

Signal     Value     Action   Comment----------------------------------------------------------------------SIGHUP        1       Term    Hangup detected on controlling terminal                              or death of controlling processSIGINT        2       Term    Interrupt from keyboardSIGQUIT       3       Core    Quit from keyboardSIGILL        4       Core    Illegal InstructionSIGABRT       6       Core    Abort signal from abort(3)SIGFPE        8       Core    Floating point exceptionSIGKILL       9       Term    Kill signalSIGSEGV      11       Core    Invalid memory referenceSIGPIPE      13       Term    Broken pipe: write to pipe with no                              readersSIGALRM      14       Term    Timer signal from alarm(2)SIGTERM      15       Term    Termination signalSIGUSR1   30,10,16    Term    User-defined signal 1SIGUSR2   31,12,17    Term    User-defined signal 2SIGCHLD   20,17,18    Ign     Child stopped or terminatedSIGCONT   19,18,25    Cont    Continue if stoppedSIGSTOP   17,19,23    Stop    Stop processSIGTSTP   18,20,24    Stop    Stop typed at ttySIGTTIN   21,21,26    Stop    tty input for background processSIGTTOU   22,22,27    Stop    tty output for background process

which summarizes signal Action that distinguishes e.g. SIGQUIT from SIGQUIT, since SIGQUIT has action Core and SIGINT Term.

The actions are documented in the same document:

The entries in the "Action" column of the tables below specify the default disposition for each signal, as follows:Term   Default action is to terminate the process.Ign    Default action is to ignore the signal.Core   Default action is to terminate the process and dump core (see core(5)).Stop   Default action is to stop the process.Cont   Default action is to continue the process if it is currently stopped.

I cannot see any difference between SIGTERM and SIGINT from the point of view of the kernel since both have action Term and both can be caught. It seems that is just a "common usage convention distinction":

• SIGINT is what happens when you do CTRL-C from the terminal
• SIGTERM is the default signal sent by kill

Some signals are ANSI C and others not

A considerable difference is that:

• SIGINT and SIGTERM are ANSI C, thus more portable
• SIGQUIT and SIGKILL are not

They are described on section "7.14 Signal handling " of the C99 draft N1256:

• SIGINT receipt of an interactive attention signal
• SIGTERM a termination request sent to the program

which makes SIGINT a good candidate for an interactive Ctrl + C.

POSIX 7

POSIX 7 documents the signals with the signal.h header: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/signal.h.html

This page also has the following table of interest which mentions some of the things we had already seen in man 7 signal:

Signal    Default Action   DescriptionSIGABRT   A                Process abort signal.SIGALRM   T                Alarm clock.SIGBUS    A                Access to an undefined portion of a memory object.SIGCHLD   I                Child process terminated, stopped,SIGCONT   C                Continue executing, if stopped.SIGFPE    A                Erroneous arithmetic operation.SIGHUP    T                Hangup.SIGILL    A                Illegal instruction.SIGINT    T                Terminal interrupt signal.SIGKILL   T                Kill (cannot be caught or ignored).SIGPIPE   T                Write on a pipe with no one to read it.SIGQUIT   A                Terminal quit signal.SIGSEGV   A                Invalid memory reference.SIGSTOP   S                Stop executing (cannot be caught or ignored).SIGTERM   T                Termination signal.SIGTSTP   S                Terminal stop signal.SIGTTIN   S                Background process attempting read.SIGTTOU   S                Background process attempting write.SIGUSR1   T                User-defined signal 1.SIGUSR2   T                User-defined signal 2.SIGTRAP   A                Trace/breakpoint trap.SIGURG    I                High bandwidth data is available at a socket.SIGXCPU   A                CPU time limit exceeded.SIGXFSZ   A                File size limit exceeded.

BusyBox init

BusyBox's 1.29.2 default reboot command sends a SIGTERM to processes, sleeps for a second, and then sends SIGKILL. This seems to be a common convention across different distros.

When you shutdown a BusyBox system with:

reboot

it sends a signal to the init process.

Then, the init signal handler ends up calling:

static void run_shutdown_and_kill_processes(void){    /* Run everything to be run at "shutdown".  This is done _prior_     * to killing everything, in case people wish to use scripts to     * shut things down gracefully... */    run_actions(SHUTDOWN);    message(L_CONSOLE | L_LOG, "The system is going down NOW!");    /* Send signals to every process _except_ pid 1 */    kill(-1, SIGTERM);    message(L_CONSOLE, "Sent SIG%s to all processes", "TERM");    sync();    sleep(1);    kill(-1, SIGKILL);    message(L_CONSOLE, "Sent SIG%s to all processes", "KILL");    sync();    /*sleep(1); - callers take care about making a pause */}

which prints to the terminal:

The system is going down NOW!Sent SIGTERM to all processesSent SIGKILL to all processes

Here is a minimal concrete example of that.

Signals sent by the kernel

• SIGKILL:
  • OOM killer: What is RSS and VSZ in Linux memory management

As DarkDust noted many signals have the same results, but processes can attach different actions to them by distinguishing how each signal is generated. Looking at the FreeBSD kernel source code (kern_sig.c) I see that the two signals are handled in the same way, they terminate the process and are delivered to any thread.

SA_KILL|SA_PROC,             /* SIGINT */SA_KILL|SA_PROC,             /* SIGTERM */