KILL(1) User Commands KILL(1)
NAME
kill - terminate or signal processes
SYNOPSIS
/usr/bin/kill -s signal_name pid...
/usr/bin/kill -l [
exit_status]
/usr/bin/kill [
-signal_name]
pid...
/usr/bin/kill [
-signal_number]
pid...
DESCRIPTION
The
kill utility sends a signal to the process or processes specified by
each
pid operand.
For each
pid operand, the
kill utility performs actions equivalent to the
kill(2) function called with the following arguments:
1. The value of the
pid operand is used as the
pid argument.
2. The
sig argument is the value specified by the
-s option, the
-signal_name option, or the
-signal_number option, or, if none
of these options is specified, by
SIGTERM.
The signaled process must belong to the current user unless the user is
the super-user.
See NOTES for descriptions of the shell built-in versions of
kill.
OPTIONS
The following options are supported:
-l (The letter ell.) Writes all values of
signal_name supported by the implementation, if no operand is
specified. If an
exit_status operand is specified and
it is a value of the
? shell special parameter and
wait corresponding to a process that was terminated by a
signal, the
signal_name corresponding to the signal
that terminated the process is written. If an
exit_status operand is specified and it is the unsigned
decimal integer value of a signal number, the
signal_name corresponding to that signal is written.
Otherwise, the results are unspecified.
-s signal_name Specifies the signal to send, using one of the symbolic
names defined in the
<signal.h> description. Values of
signal_name is recognized in a case-independent
fashion, without the
SIG prefix. In addition, the
symbolic name
0 is recognized, representing the signal
value zero. The corresponding signal is sent instead of
SIGTERM.
-signal_name Equivalent to
-s signal_name.
-signal_number Specifies a non-negative decimal integer,
signal_number, representing the signal to be used
instead of
SIGTERM, as the
sig argument in the
effective call to
kill(2).
OPERANDS
The following operands are supported:
pid One of the following:
1. A decimal integer specifying a process or
process group to be signaled. The process or
processes selected by positive, negative and
zero values of the
pid operand is as described
for the kill function. If process number 0 is
specified, all processes in the process group
are signaled. If the first
pid operand is
negative, it should be preceded by
-- to keep
it from being interpreted as an option.
2. A job control job
ID that identifies a
background process group to be signaled. The
job control job
ID notation is applicable only
for invocations of
kill in the current shell
execution environment.
The job control job
ID type of
pid is available only on
systems supporting the job control option.
exit_status A decimal integer specifying a signal number or the exit
status of a process terminated by a signal.
USAGE
Process numbers can be found by using
ps(1).
The job control job
ID notation is not required to work as expected when
kill is operating in its own utility execution environment. In either of
the following examples:
example%
nohup kill %1 & example%
system( "kill %1"); kill operates in a different environment and does not share the shell's
understanding of job numbers.
OUTPUT
When the
-l option is not specified, the standard output is not be used.
When the
-l option is specified, the symbolic name of each signal is
written in the following format:
"%s%c", <
signal_name>, <
separator>
where the
<signal_name> is in upper-case, without the
SIG prefix, and the
<separator> is either a newline character or a space character. For the
last signal written,
<separator> is a newline character.
When both the
-l option and
exit_status operand are specified, the
symbolic name of the corresponding signal is written in the following
format:
"%s\n", <
signal_name>
EXAMPLES
Example 1: Sending the kill signal
Any of the commands:
example%
kill -9 100 -165 example%
kill -s kill 100 -165 example%
kill -s KILL 100 -165 sends the
SIGKILL signal to the process whose process
ID is
100 and to
all processes whose process group
ID is
165, assuming the sending process
has permission to send that signal to the specified processes, and that
they exist.
Example 2: Avoiding ambiguity with an initial negative number
To avoid an ambiguity of an initial negative number argument specifying
either a signal number or a process group, the former is always be the
case. Therefore, to send the default signal to a process group (for
example,
123), an application should use a command similar to one of the
following:
example%
kill -TERM -123 example%
kill -- -123ENVIRONMENT VARIABLES
See
environ(7) for descriptions of the following environment variables
that affect the execution of
kill:
LANG,
LC_ALL,
LC_CTYPE,
LC_MESSAGES,
and
NLSPATH.
EXIT STATUS
The following exit values are returned:
0 At least one matching process was found for each
pid operand, and
the specified signal was successfully processed for at least one
matching process.
>0 An error occurred.
ATTRIBUTES
See
attributes(7) for descriptions of the following attributes:
/usr/bin/kill, csh, ksh, sh +--------------------+-------------------+
| ATTRIBUTE TYPE | ATTRIBUTE VALUE |
+--------------------+-------------------+
|CSI | Enabled |
+--------------------+-------------------+
|Interface Stability | Committed |
+--------------------+-------------------+
|Standard | See
standards(7). |
+--------------------+-------------------+
ksh93 +--------------------+-----------------+
| ATTRIBUTE TYPE | ATTRIBUTE VALUE |
+--------------------+-----------------+
|CSI | Enabled |
+--------------------+-----------------+
|Interface Stability | Uncommitted |
+--------------------+-----------------+
SEE ALSO
csh(1),
getconf(1),
jobs(1),
ksh(1),
ksh93(1),
ps(1),
sh(1),
shell_builtins(1),
wait(1),
kill(2),
signal(3C),
signal.h(3HEAD),
attributes(7),
environ(7),
standards(7)NOTES
/usr/bin/kill The number of realtime signals supported is defined by the
getconf(1) value
_POSIX_RTSIG_MAX.
sh The Bourne shell,
sh, has a built-in version of
kill to provide the
functionality of the
kill command for processes identified with a
jobid.
The
sh syntax is:
kill [ -sig ] [ pid ] [ %job ]...
kill -l
csh The C-shell,
csh, also has a built-in
kill command, whose syntax is:
kill [-sig][pid][%job]...
kill -l
The
csh kill built-in sends the
TERM (terminate) signal, by default, or
the signal specified, to the specified process
ID, the
job indicated, or
the current
job. Signals are either specified by number or by name. There
is no default. Typing
kill does not send a signal to the current job. If
the signal being sent is
TERM (terminate) or
HUP (hangup), then the job
or process is sent a
CONT (continue) signal as well.
-l Lists the signal names that can be sent.
ksh The syntax of the
ksh kill is:
kill [-sig][pid][%job]...
kill -l
The
ksh kill sends either the
TERM (terminate) signal or the specified
signal to the specified jobs or processes. Signals are either specified
by number or by names (as specified in
signal.h(3HEAD) stripped of the
SIG prefix). If the signal being sent is
TERM (terminate) or
HUP (hangup), then the job or process is sent a
CONT (continue) signal if it
is stopped. The argument
job can be the process id of a process that is
not a member of one of the active jobs. In the second form,
kill -l, the
signal numbers and names are listed.
ksh93 The syntax of the
ksh93 kill is:
kill [-n signum] [-s signame] job ...
kill [-n signum] [-s signame] -l [arg ...]
With the first form in which
-l is not specified,
kill sends a signal to
one or more processes specified by
job. This normally terminates the
processes unless the signal is being caught or ignored.
Specify
job as one of the following:
number The process id of
job.
-number The process group id of
job.
%number The job number.
%string The job whose name begins with
string.
%?string The job whose name contains
string.
%+ %% The current job.
%- The previous job.
If the signal is not specified with either the
-n or the
-s option, the
SIGTERM signal is used.
If
-l is specified, and no
arg is specified, then
kill writes the list of
signals to standard output. Otherwise,
arg can be either a signal name,
or a number representing either a signal number or exit status for a
process that was terminated due to a signal. If a name is specified the
corresponding signal number is written to standard output. If a number is
specified the corresponding signal name is written to standard output.
-l List signal names or signal numbers rather than sending
signals as described above. The
-n and
-s options cannot be
specified.
-n signum Specify a signal number to send. Signal numbers are not
portable across platforms, except for the following:
0 No signal.
1 HUP 2 INT 3 QUIT 6 ABRT 9 KILL 14 ALRM 15 TERM -s signame Specify a signal name to send. The signal names are derived
from their names in
<signal.h> without the
SIG prefix and
are case insensitive.
kill -l generates the list of
signals on the current platform.
kill in
ksh93 exits with one of the following values:
0 At least one matching process was found for each job operand, and
the specified signal was successfully sent to at least one matching
process.
>0 An error occurred.
August 11, 2009
KILL(1)