# kill

## NAME



           kill - terminate a process
    


## SYNOPSIS



           **kill**[**-**_signal_ |**-s** _signal_ |**-p**]  [**-q** _value_] [**-a**] [**--timeout**
           _milliseconds signal_] [**--**] _pid_ |_name_...
    
           **kill -l**[_number_ |0x _sigmask_] | **-L**
    
           **kill -d** _pid_
    


## DESCRIPTION



           The command **kill** sends the specified _signal_ to the specified
           processes or process groups.
    
           If no signal is specified, the **TERM** signal is sent. The default
           action for this signal is to terminate the process. This signal
           should be used in preference to the **KILL** signal (number 9), since
           a process may install a handler for the TERM signal in order to
           perform clean-up steps before terminating in an orderly fashion.
           If a process does not terminate after a **TERM** signal has been sent,
           then the **KILL** signal may be used; be aware that the latter signal
           cannot be caught, and so does not give the target process the
           opportunity to perform any clean-up before terminating.
    
           Most modern shells have a builtin **kill** command, with a usage
           rather similar to that of the command described here. The **--all** ,
           **--pid** , and **--queue** options, and the possibility to specify
           processes by command name, are local extensions.
    
           If _signal_ is 0, then no actual signal is sent, but error checking
           is still performed.
    


## ARGUMENTS



           The list of processes to be signaled can be a mixture of names and
           PIDs.
    
           _pid_
               Each _pid_ can be expressed in one of the following ways:
    
               _n_
                   where _n_ is larger than 0. The process with PID _n_ is
                   signaled.
    
               **0**
                   All processes in the current process group are signaled.
    
               **-1**
                   All processes with a PID larger than 1 are signaled.
    
               **-**_n_
                   where _n_ is larger than 1. All processes in process group _n_
                   are signaled. When an argument of the form '-n' is given,
                   and it is meant to denote a process group, either a signal
                   must be specified first, or the argument must be preceded
                   by a '--' option, otherwise it will be taken as the signal
                   to send.
    
           _name_
               All processes invoked using this _name_ will be signaled.
    


## OPTIONS



           **-s** , **--signal** _signal_
               The signal to send. It may be given as a name or a number.
    
           **-l** , **--list**[_number_ |0x _sigmask_]
               Print a list of signal names, convert the given signal number
               to a name, or convert the given signal mask to names. The
               signals can be found in _/usr/include/linux/signal.h_.
    
                   $ ps s $$
                     UID     PID          PENDING          BLOCKED          IGNORED           CAUGHT STAT TTY        TIME COMMAND
                    1000 1608069 0000000000000000 0000000000000002 0000000000384000 0000000008013003 Ss   pts/44     0:02 zsh
                   $ kill -l 0x0000000000384000
                   TERM
                   TSTP
                   TTIN
                   TTOU
    
           **-L** , **--table**
               Similar to **-l** , but it will print signal names and their
               corresponding numbers.
    
           **-a** , **--all**
               Do not restrict the command-name-to-PID conversion to
               processes with the same UID as the present process.
    
           **-p** , **--pid**
               Only print the process ID (PID) of the named processes, do not
               send any signals.
    
           **-r** , **--require-handler**
               Do not send the signal if it is not caught in userspace by the
               signalled process.
    
           **--verbose**
               Print PID(s) that will be signaled with **kill** along with the
               signal.
    
           **-q** , **--queue** _value_
               Send the signal using sigqueue(3) rather than kill(2). The
               _value_ argument is an integer that is sent along with the
               signal. If the receiving process has installed a handler for
               this signal using the **SA_SIGINFO** flag to sigaction(2), then it
               can obtain this data via the _si_sigval_ field of the _siginfo_t_
               structure.
    
           **--timeout** _milliseconds signal_
               Send a signal defined in the usual way to a process, followed
               by an additional signal after a specified delay. The **--timeout**
               option causes **kill** to wait for a period defined in
               _milliseconds_ before sending a follow-up _signal_ to the process.
               This feature is implemented using the Linux kernel PID file
               descriptor feature in order to guarantee that the follow-up
               signal is sent to the same process or not sent if the process
               no longer exists.
    
               Note that the operating system may re-use PIDs and
               implementing an equivalent feature in a shell using **kill** and
               **sleep** would be subject to races whereby the follow-up signal
               might be sent to a different process that used a recycled PID.
    
               The **--timeout** option can be specified multiple times: the
               signals are sent sequentially with the specified timeouts. The
               **--timeout** option can be combined with the **--queue** option.
    
               As an example, the following command sends the signals **QUIT** ,
               **TERM** and **KILL** in sequence and waits for 1000 milliseconds
               between sending the signals:
    
                   kill --verbose --timeout 1000 TERM --timeout 1000 KILL \
                           --signal QUIT 12345
    
           **-d** , **--show-process-state** _pid_
               Decode signal related fields in /proc/_pid_ /status.
    
                   $ kill -d $$
                   Blocked: INT
                   Ignored: TERM TSTP TTIN TTOU
                   Caught: HUP INT PIPE ALRM CHLD WINCH
    
           **-h** , **--help**
               Display help text and exit.
    
           **-V** , **--version**
               Display version and exit.
    


## EXIT STATUS



           **kill** has the following exit status values:
    
           **0**
               success
    
           **1**
               failure
    
           **64**
               partial success (when more than one process specified)
    


## NOTES



           Although it is possible to specify the TID (thread ID, see
           gettid(2)) of one of the threads in a multithreaded process as the
           argument of **kill** , the signal is nevertheless directed to the
           process (i.e., the entire thread group). In other words, it is not
           possible to send a signal to an explicitly selected thread in a
           multithreaded process. The signal will be delivered to an
           arbitrarily selected thread in the target process that is not
           blocking the signal. For more details, see signal(7) and the
           description of **CLONE_THREAD** in clone(2).
    
           Various shells provide a builtin **kill** command that is preferred in
           relation to the kill(1) executable described by this manual. The
           easiest way to ensure one is executing the command described in
           this page is to use the full path when calling the command, for
           example: **/bin/kill --version**
    


## AVAILABILITY



           The **kill** command is part of the util-linux package which can be
           downloaded from Linux Kernel Archive
           <https://www.kernel.org/pub/linux/utils/util-linux/>. This page is
           part of the _util-linux_ (a random collection of Linux utilities)
           project. Information about the project can be found at 
           ⟨https://www.kernel.org/pub/linux/utils/util-linux/⟩. If you have a
           bug report for this manual page, send it to
           util-linux@vger.kernel.org. This page was obtained from the
           project's upstream Git repository
           ⟨git://git.kernel.org/pub/scm/utils/util-linux/util-linux.git⟩ on
           2025-08-11. (At that time, the date of the most recent commit that
           was found in the repository was 2025-08-05.) If you discover any
           rendering problems in this HTML version of the page, or you
           believe there is a better or more up-to-date source for the page,
           or you have corrections or improvements to the information in this
           COLOPHON (which is _not_ part of the original manual page), send a
           mail to man-pages@man7.org
    
    util-linux 2.42-start-521-ec46  2025-08-09                        _KILL_(1)
    


* * *