kill(1) 맨 페이지 - 윈디하나의 솔라나라

개요

섹션
맨페이지이름
검색(S)

kill

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 implementa-
                       tion, 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 correspond-
                       ing 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  pre-
                       fix.  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  pro-
                             cess  or  process  group  to be sig-
                             naled.  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  inter-
                             preted 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  avail-
                    able  only on systems supporting the job con-
                    trol 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  speci-
     fied, the symbolic name of the corresponding signal is writ-
     ten 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 -- -123

Environment Variables
     See environ(5) 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(5) for descriptions of the  following  attri-
     butes:

  /usr/bin/kill, csh, ksh88, sh
     tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i)  ATTRI-
     BUTE  TYPEATTRIBUTE  VALUE  _  Availabilitysystem/core-os  _
     CSIEnabled  _  Interface  StabilityCommitted  _  StandardSee
     standards(5).


  ksh
     tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i)  ATTRI-
     BUTE  TYPEATTRIBUTE  VALUE  _  Availabilitysystem/core-os  _
     CSIEnabled _ Interface StabilityUncommitted

See Also
     csh(1), getconf(1), jobs(1), ksh(1), ksh88(1), ps(1), sh(1),
     shell_builtins(1),     wait(1),     kill(2),     signal(3C),
     signal.h(3HEAD), attributes(5), environ(5), standards(5)

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 pro-
     vide  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.


  ksh88
     The syntax of the ksh88 kill is:

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




     The ksh88 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.

  ksh
     The syntax of the ksh 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 ksh 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.
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.
RSS ATOM XHTML 1.0 CSS3