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 cor-
			 responding 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  sig-
			 nal_name  is recognized in a case-independent fashion, without the SIG prefix. In addition, the symbolic name 0 is recog-
			 nized, 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 pos-
				 itive, 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
", <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_MES-
       SAGES, 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 attributes:

   /usr/bin/kill, csh, ksh, sh
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWcsu			   |
       +-----------------------------+-----------------------------+
       |CSI			     |Enabled			   |
       +-----------------------------+-----------------------------+
       |Interface Stability	     |Committed 		   |
       +-----------------------------+-----------------------------+
       |Standard		     |See standards(5). 	   |
       +-----------------------------+-----------------------------+

   ksh93
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWcsu			   |
       +-----------------------------+-----------------------------+
       |CSI			     |Enabled			   |
       +-----------------------------+-----------------------------+
       |Interface Stability	     |Uncommitted		   |
       +-----------------------------+-----------------------------+

SEE ALSO

       csh(1),	jobs(1),  ksh(1),  ksh93(1),  ps(1), sh(1), shell_builtins(1), wait(1), kill(2), signal(3C), signal.h(3HEAD), attributes(5), envi-
       ron(5), standards(5)

NOTES

   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 indi-
       cated, 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 speci-
       fied  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 speci-
       fied  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 speci-
		     fied.

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

SunOS 5.11							    2 Nov 2007								   kill(1)