👤
Home Man
Search
Today's Posts
Register

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:
Select Section of Man Page:
Select Man Page Repository:

OpenSolaris 2009.06 - man page for kill (opensolaris section 1)

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 speci-
		  fied, 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 sig-
			 nal_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 sym-
			 bolic name 0 is recognized, representing the signal value zero. The cor-
			 responding 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,  nega-
				 tive  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  fol-
       lowing 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 -- -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 sig-
	     nal 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), sig-
       nal(3C), signal.h(3HEAD), attributes(5), environ(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 speci-
       fied, 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 spec-
       ified 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 (termi-
       nate) 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  pro-
       cesses 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 stan-
       dard 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  gen-
		     erates 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 sig-
	     nal was successfully sent to at least one matching process.

       >0    An error occurred.

SunOS 5.11				    2 Nov 2007					  kill(1)


All times are GMT -4. The time now is 11:14 PM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
×
UNIX.COM Login
Username:
Password:  
Show Password