Job control - Revision history

Christoph: /* Process state codes */

2023-04-21T04:42:20Z

‎Process state codes

Christoph: /* See also */

2009-01-19T16:10:39Z

‎See also

Christoph at 16:01, 19 January 2009

2009-01-19T16:01:46Z

Christoph at 15:54, 19 January 2009

2009-01-19T15:54:24Z

Christoph: /* Job Control Variables */

2006-08-19T22:53:44Z

‎Job Control Variables

Christoph at 22:50, 19 August 2006

2006-08-19T22:50:28Z

Show changes

Christoph at 07:10, 19 August 2006

2006-08-19T07:10:39Z

New page

When using [[Linux]] via a terminal, a user will initially only have a single process running, their login shell. Most tasks (directory listing, editing files, etc.) can easily be accomplished by letting the program take control of the terminal and returning control to the shell when the program exits; however, sometimes the user will wish to carry out a lengthy task in the background while using the terminal for another purpose. Job control is a facility developed to make this possible, by allowing the user to start programs in the '''background''', send programs into the background, bring background programs into the '''foreground''', and start and stop running programs. Programs under the influence of a job control facility are referred to as '''jobs'''.

== Implementation ==
* Typically, the shell keeps a list of jobs in a '''job table'''. A job consists of all the members of a [[pipeline (Unix)|pipeline]].
* A program can be started as a background task by appending <code>&</code><ref>This section uses [[Bash]] syntax; other shells offer similar functionality under other names.</ref> to the command line; its output is directed to the terminal (potentially interleaved with other programs' output) but it cannot read from the terminal input.
* A task running in the foreground can be stopped by typing the suspend character (Ctrl+Z); this sends [[SIGTSTP]] to the process and returns control to the shell.
* The process can be resumed as a background job with the <code>bg</code> [[shell builtin|builtin]] or as the foreground job with <code>fg</code>; in either case the shell redirects [[Input/output|I/O]] appropriately and sends [[SIGCONT]] to the process.
* <code>jobs</code> will list the background jobs existing in the job table, along with their job number and job state (stopped or running).
* The <code>kill</code> builtin (not <code>/bin/kill</code>) can signal processes by job number as well as by process ID.
* <code>disown</code> can be used to remove jobs from the job table, converting them from jobs into [[daemon (computer software)|daemon]]s so that they continue executing when the user [[logout|logs out]].

=== Job Control Basics ===

Job control refers to the ability to selectively stop (suspend) the execution of processes and continue (resume) their execution at a later point. A user typically employs this facility via an interactive interface supplied jointly by the system's terminal driver and Bash.

The shell associates a job with each pipeline. It keeps a table of currently executing jobs, which may be listed with the jobs command. When Bash starts a job asynchronously, it prints a line that looks like:

[1] 25647

indicating that this job is job number 1 and that the process ID of the last process in the pipeline associated with this job is 25647. All of the processes in a single pipeline are members of the same job. Bash uses the job abstraction as the basis for job control.

To facilitate the implementation of the user interface to job control, the operating system maintains the notion of a current terminal process group ID. Members of this process group (processes whose process group ID is equal to the current terminal process group ID) receive keyboard-generated signals such as SIGINT. These processes are said to be in the foreground. Background processes are those whose process group ID differs from the terminal's; such processes are immune to keyboard-generated signals. Only foreground processes are allowed to read from or write to the terminal. Background processes which attempt to read from (write to) the terminal are sent a SIGTTIN (SIGTTOU) signal by the terminal driver, which, unless caught, suspends the process.

If the operating system on which Bash is running supports job control, Bash contains facilities to use it. Typing the suspend character (typically '^Z', Control-Z) while a process is running causes that process to be stopped and returns control to Bash. Typing the delayed suspend character (typically '^Y', Control-Y) causes the process to be stopped when it attempts to read input from the terminal, and control to be returned to Bash. The user then manipulates the state of this job, using the bg command to continue it in the background, the fg command to continue it in the foreground, or the kill command to kill it. A '^Z' takes effect immediately, and has the additional side effect of causing pending output and typeahead to be discarded.

There are a number of ways to refer to a job in the shell. The character `%' introduces a job name.

Job number n may be referred to as '%n'. The symbols '%%' and '%+' refer to the shell's notion of the current job, which is the last job stopped while it was in the foreground or started in the background. The previous job may be referenced using '%-'. In output pertaining to jobs (e.g., the output of the jobs command), the current job is always flagged with a '+', and the previous job with a '-'.

A job may also be referred to using a prefix of the name used to start it, or using a substring that appears in its command line. For example, '%ce' refers to a stopped ce job. Using '%?ce', on the other hand, refers to any job containing the string 'ce' in its command line. If the prefix or substring matches more than one job, Bash reports an error.

Simply naming a job can be used to bring it into the foreground: '%1' is a synonym for 'fg %1', bringing job 1 from the background into the foreground. Similarly, '%1 &' resumes job 1 in the background, equivalent to 'bg %1'

The shell learns immediately whenever a job changes state. Normally, Bash waits until it is about to print a prompt before reporting changes in a job's status so as to not interrupt any other output. If the '-b' option to the set builtin is enabled, Bash reports such changes immediately (see section 4.3 The Set Builtin). Any trap on SIGCHLD is executed for each child process that exits.

If an attempt to exit Bash is while jobs are stopped, the shell prints a message warning that there are stopped jobs. The jobs command may then be used to inspect their status. If a second attempt to exit is made without an intervening command, Bash does not print another warning, and the stopped jobs are terminated.

=== Job Control Builtins ===

* '''bg'''
:: <tt>bg [jobspec]</tt>
:: Resume the suspended job jobspec in the background, as if it had been started with `&'. If jobspec is not supplied, the current job is used. The return status is zero unless it is run when job control is not enabled, or, when run with job control enabled, if jobspec was not found or jobspec specifies a job that was started without job control.

* '''fg'''
:: <tt>fg [jobspec]</tt>
:: Resume the job jobspec in the foreground and make it the current job. If jobspec is not supplied, the current job is used. The return status is that of the command placed into the foreground, or non-zero if run when job control is disabled or, when run with job control enabled, jobspec does not specify a valid job or jobspec specifies a job that was started without job control.

* '''jobs'''
:: <tt>jobs [-lnprs] [jobspec]</tt>
:: <tt>jobs -x command [arguments]</tt>
:: The first form lists the active jobs. The options have the following meanings:
::: <tt>-l</tt>
:::: List process IDs in addition to the normal information.
::: <tt>-n</tt>
:::: Display information only about jobs that have changed status since the user was last notified of their status.
::: <tt>-p</tt>
:::: List only the process ID of the job's process group leader.
::: <tt>-r</tt>
:::: Restrict output to running jobs.
::: <tt>-s</tt>
:::: Restrict output to stopped jobs.
:: If jobspec is given, output is restricted to information about that job. If jobspec is not supplied, the status of all jobs is listed.
:: If the `-x' option is supplied, jobs replaces any jobspec found in command or arguments with the corresponding process group ID, and executes command, passing it arguments, returning its exit status.

* '''kill'''
:: <tt>kill [-s sigspec] [-n signum] [-sigspec] jobspec or pid</tt>
:: <tt>kill -l [exit_status]</tt>
:: Send a signal specified by sigspec or signum to the process named by job specification jobspec or process ID pid. sigspec is either a signal name such as SIGINT (with or without the SIG prefix) or a signal number; signum is a signal number. If sigspec and signum are not present, SIGTERM is used. The `-l' option lists the signal names. If any arguments are supplied when `-l' is given, the names of the signals corresponding to the arguments are listed, and the return status is zero. exit_status is a number specifying a signal number or the exit status of a process terminated by a signal. The return status is zero if at least one signal was successfully sent, or non-zero if an error occurs or an invalid option is encountered.

* '''wait'''
:: <tt>wait [jobspec or pid]</tt>
:: Wait until the child process specified by process ID pid or job specification jobspec exits and return the exit status of the last command waited for. If a job spec is given, all processes in the job are waited for. If no arguments are given, all currently active child processes are waited for, and the return status is zero. If neither jobspec nor pid specifies an active child process of the shell, the return status is 127.

* '''disown'''
:: <tt>disown [-ar] [-h] [jobspec ...]</tt>
:: Without options, each jobspec is removed from the table of active jobs. If the `-h' option is given, the job is not removed from the table, but is marked so that SIGHUP is not sent to the job if the shell receives a SIGHUP. If jobspec is not present, and neither the `-a' nor `-r' option is supplied, the current job is used. If no jobspec is supplied, the `-a' option means to remove or mark all jobs; the `-r' option without a jobspec argument restricts operation to running jobs.

* '''suspend'''
:: <tt>suspend [-f]</tt>
:: Suspend the execution of this shell until it receives a SIGCONT signal. The `-f' option means to suspend even if the shell is a login shell.

When job control is not active, the kill and wait builtins do not accept jobspec arguments. They must be supplied process IDs.

=== Job Control Variables ===

; <tt>auto_resume</tt> : This variable controls how the shell interacts with the user and job control. If this variable exists then single word simple commands without redirections are treated as candidates for resumption of an existing job. There is no ambiguity allowed; if there is more than one job beginning with the string typed, then the most recently accessed job will be selected. The name of a stopped job, in this context, is the command line used to start it. If this variable is set to the value `exact', the string supplied must match the name of a stopped job exactly; if set to `substring', the string supplied needs to match a substring of the name of a stopped job. The `substring' value provides functionality analogous to the `%?' job ID (see section 7.1 Job Control Basics). If set to any other value, the supplied string must be a prefix of a stopped job's name; this provides functionality analogous to the `%' job ID.

== See also ==
* [http://cnswww.cns.cwru.edu/~chet/bash/bashref.html#SEC87 Job control in Bash]

[[Category:Linux Command Line Tools]]

@@ Line 93: / Line 93: @@
 ;R : runnable
 ;S : stopped (usually because it is waiting on input or doing something else that does not require processing time from the CPU)
-;D : uniterruptible IO wait (usually requires a reboot to clear)
+;D : uninterruptible IO wait (usually requires a reboot to clear)
 ;T : process is stopped (send a SIGCONT to start the process again)
-;Z : process is defunt (either kill the parent or reboot)
+;Z : process is defunct (either kill the parent or reboot)
 ==Signals==

@@ Line 108: / Line 108: @@
 == See also ==
-* [[Nohup (command)|nohup]]
+*[[nohup]]
 *[[ps]]

@@ Line 96: / Line 96: @@
 ;T : process is stopped (send a SIGCONT to start the process again)
 ;Z : process is defunt (either kill the parent or reboot)
 == See also ==

@@ Line 10: / Line 10: @@
 * <tt>disown</tt> can be used to remove jobs from the job table, converting them from jobs into daemons so that they continue executing when the user logs out.
-=== Job Control Basics ===
+=== Job control basics ===
 Job control refers to the ability to selectively stop (suspend) the execution of processes and continue (resume) their execution at a later point. A user typically employs this facility via an interactive interface supplied jointly by the system's terminal driver and Bash.
@@ Line 36: / Line 36: @@
 If an attempt to exit Bash is while jobs are stopped, the shell prints a message warning that there are stopped jobs. The jobs command may then be used to inspect their status. If a second attempt to exit is made without an intervening command, Bash does not print another warning, and the stopped jobs are terminated.
-=== Job Control Builtins ===
+=== Job control builtins ===
 * '''bg'''
@@ Line 85: / Line 85: @@
 When job control is not active, the <tt>kill</tt> and <tt>wait</tt> builtins do not accept <code>jobspec</code> arguments. They must be supplied process IDs.
-=== Job Control Variables ===
+=== Job control variables ===
 ; <tt>auto_resume</tt> : This variable controls how the shell interacts with the user and job control. If this variable exists then single word simple commands without redirections are treated as candidates for resumption of an existing job. There is no ambiguity allowed; if there is more than one job beginning with the string typed, then the most recently accessed job will be selected. The name of a stopped job, in this context, is the command line used to start it. If this variable is set to the value '<code>exact</code>', the string supplied must match the name of a stopped job exactly; if set to '<code>substring</code>', the string supplied needs to match a substring of the name of a stopped job. The '<code>substring</code>' value provides functionality analogous to the '<code>%?</code>' job ID (see [[Job control#Job Control Basics|Job Control Basics]]). If set to any other value, the supplied string must be a prefix of a stopped job's name; this provides functionality analogous to the '<code>%</code>' job ID.
 == See also ==
 * [[Nohup (command)|nohup]]
 == References and notes ==

@@ Line 87: / Line 87: @@
 === Job Control Variables ===
-; <tt>auto_resume</tt> : This variable controls how the shell interacts with the user and job control. If this variable exists then single word simple commands without redirections are treated as candidates for resumption of an existing job. There is no ambiguity allowed; if there is more than one job beginning with the string typed, then the most recently accessed job will be selected. The name of a stopped job, in this context, is the command line used to start it. If this variable is set to the value '<code>exact</code>', the string supplied must match the name of a stopped job exactly; if set to '<code>substring</code>', the string supplied needs to match a substring of the name of a stopped job. The '<code>substring</code>' value provides functionality analogous to the '<code>%?</code>' job ID (see section 7.1 Job Control Basics). If set to any other value, the supplied string must be a prefix of a stopped job's name; this provides functionality analogous to the '<code>%</code>' job ID.
+; <tt>auto_resume</tt> : This variable controls how the shell interacts with the user and job control. If this variable exists then single word simple commands without redirections are treated as candidates for resumption of an existing job. There is no ambiguity allowed; if there is more than one job beginning with the string typed, then the most recently accessed job will be selected. The name of a stopped job, in this context, is the command line used to start it. If this variable is set to the value '<code>exact</code>', the string supplied must match the name of a stopped job exactly; if set to '<code>substring</code>', the string supplied needs to match a substring of the name of a stopped job. The '<code>substring</code>' value provides functionality analogous to the '<code>%?</code>' job ID (see [[Job control#Job Control Basics|Job Control Basics]]). If set to any other value, the supplied string must be a prefix of a stopped job's name; this provides functionality analogous to the '<code>%</code>' job ID.
 == See also ==