Unix‎ > ‎Solaris‎ > ‎Solaris man pages‎ > ‎1‎ > ‎


     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

     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 correspond-
                     ing  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 symbolic names defined in the <signal.h>
                     description. Values of signal_name  will  be
                     recognized  in  a  case-independent fashion,
                     without the SIG  prefix.  In  addition,  the
                     symbolic   name   0   will   be  recognized,
                     representing  the  signal  value  zero.  The
                     corresponding signal will be sent instead of

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

     The following operands are supported:

     pid             One of the following:

                         1.  A decimal integer specifying a  pro-
                             cess  or  process  group  to be sig-
                             naled.  The  process  or   processes
                             selected  by  positive, negative and
                             zero values of the pid operand  will
                             be  as  described for the kill func-
                             tion. If process number 0 is  speci-
                             fied,  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.

                     Note: 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.

     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 success-
              fully 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.h(3HEAD),  attri-
     butes(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.h(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 pages from Solaris 10 Update 8. See docs.sun.com and www.oracle.com for further documentation and Solaris information.