Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
kill(1)				 User Commands			       kill(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 arguments:

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

       2. The  sig argument is the value specified by the -s option, the -sig-
	  nal_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.

       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 op-
	     erand is given and	it is a	value of the ? shell special parameter
	     and wait corresponding to a process that was terminated by	a sig-
	     nal, 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 written.
	     Otherwise,	the results are	unspecified.

       -s signal_name
	     Specifies the signal to send, using one of	the symbolic names de-
	     fined  in	the <signal.h> description. Values of signal_name will
	     be	recognized in a	case-independent fashion, without the SIG pre-
	     fix.  In addition,	the symbolic name 0 will be recognized,	repre-
	     senting 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,	repre-
	     senting the signal	to be used instead of SIGTERM, as the sig  ar-
	     gument in	    the	effective 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, nega-
		tive  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 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  ap-
		plicable only for invocations of kill in the current shell ex-
		ecution	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 ei-
       ther 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

       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	character or a	space  charac-
       ter. For	the last signal	written, <separator> will be a newline charac-

       When both the -l	option and exit_status operand are specified, the sym-
       bolic name of the corresponding signal will be written in the following

       "%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 number

       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 following:

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

       See  environ(5) for descriptions	of the following environment variables
       that affect the execution of kill: LC_CTYPE, LC_MESSAGES, and NLSPATH.

       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 attributes:

       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       |Availability		     |SUNWcsu			   |
       |CSI			     |enabled			   |

       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)

       The  Bourne  shell,  sh,	 has a built-in	version	of kill	to provide the
       functionality of	the kill command for processes identified with	a  jo-
       bid. 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. 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.

       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  pre-
       fix).  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	listed.

SunOS 5.9			  2 Oct	2001			       kill(1)


Want to link to this manual page? Use this URL:

home | help