kill - terminate or signal processes


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


     The kill utility sends a signal to the process or  processes
     specified by each pid operand.

     For each pid operand, the kill utility will perform  actions
     equivalent to the kill(2) function called with the following

     1. The value of the pid operand will  be  used  as  the  pid

     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


     The following options are supported:

     -l    (The letter ell.) Writes  all  values  of  signal_name
           supported  by  the  implementation,  if  no operand is
           given. If an exit_status operand is given 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 will  be  written.  If  an
           exit_status  operand  is  given and it is the unsigned
           decimal  integer  value  of  a  signal   number,   the
           signal_name corresponding to that signal will be writ-
           ten. Otherwise, the results are unspecified.

     -s signal_name
           Specifies the signal to send, using one  of  the  sym-
           bolic  names  defined  in  the <signal.h> description.
           Values of signal_name will be recognized  in  a  case-
           independent  fashion, without the SIG prefix. In addi-
           tion,  the  symbolic  name  0  will   be   recognized,
           representing  the signal value zero. The corresponding
           signal will be sent instead of SIGTERM.

           Equivalent to -s signal_name.

           Specifies    a    non-negative    decimal     integer,
           signal_number,  representing  the  signal  to  be used
           instead of SIGTERM, as the sig argument in the  effec-
           tive call to kill(2).


     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 will be 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  pre-
              ceded by -- to keep it from being interpreted as an

           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.

           Note: The job control job ID type of pid is  available
           only on systems supporting the job control option.

           A decimal integer specifying a signal  number  or  the
           exit status of a process terminated by a signal.


     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 will not  share
     the shell's understanding of job numbers.


     When the -l option is not  specified,  the  standard  output
     will not be used.

     When the -l option is specified, the symbolic name  of  each
     signal will be 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> will be either a newline charac-
     ter or a space  character.  For  the  last  signal  written,
     <separator> will be a newline character.

     When both the -l option and exit_status operand  are  speci-
     fied,  the symbolic name of the corresponding signal will be
     written in the following format:

     "%s\n", <signal_name>


     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

     To avoid an ambiguity of an initial negative number argument
     specifying  either  a  signal number or a process group, the
     former will 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  fol-

     example% kill -TERM -123
     example% kill -- -123


     See environ(5) for descriptions of the following environment
     variables  that  affect the execution of kill: LANG, LC_ALL,


     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.


     See attributes(5) for descriptions of the  following  attri-

    |       ATTRIBUTE TYPE        |       ATTRIBUTE VALUE       |
    | Availability                | SUNWcsu                     |
    | CSI                         | enabled                     |
    | Interface Stability         | Standard                    |


     csh(1), jobs(1), ksh(1),  ps(1),  sh(1),  shell_builtins(1),
     wait(1),  kill(2), signal(3C), signal(3HEAD), attributes(5),
     environ(5), standards(5)


     The Bourne shell, sh, has a built-in version of kill to pro-
     vide  the  functionality  of  the kill command for processes
     identified with a jobid. The sh  syntax is:

     kill [ -sig ] [ pid ] [ %job ]...
     kill -l

     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 given by number or by name. There is no default. Typ-
     ing 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.

     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  given  by  number  or  by  names  (as  given  in
     signal(3HEAD)  stripped  of  the  SIG prefix). If the signal
     being sent is TERM (terminate) or HUP (hangup), then the job
     or  process  will  be 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

Man(1) output converted with man2html