Table of Contents
This describes
a general terminal line discipline that is supported on tty asynchronous
communication ports. When a terminal file is opened, it normally causes
the process to wait until a connection is established. For most hardware,
the presence of a connection is indicated by the assertion of the hardware
If the termios structure associated with the terminal file has the flag
set in the cflag, or if the flag is set in the call, then the open will
succeed even without a connection being present. In practice, applications
seldom open these files; they are opened by special programs, such as
or and become an application’s standard input, output, and error files.
Every process is associated with a particular process group and session.
The grouping is hierarchical: every member of a particular process group
is a member of the same session. This structuring is used in managing groups
of related processes for purposes of that is, the ability from the keyboard
(or from program control) to simultaneously stop or restart a complex command
(a command composed of one or more related processes). The grouping into
process groups allows delivering of signals that stop or start the group
as a whole, along with arbitrating which process group has access to the
single controlling terminal. The grouping at a higher layer into sessions
is to restrict the job control related signals and system calls to within
processes resulting from a particular instance of a "login". Typically,
a session is created when a user logs in, and the login terminal is setup
to be the controlling terminal; all processes spawned from that login shell
are in the same session, and inherit the controlling terminal. A job control
shell operating interactively (that is, reading commands from a terminal)
normally groups related processes together by placing them into the same
process group. A set of processes in the same process group is collectively
referred to as a "job". When the foreground process group of the terminal
is the same as the process group of a particular job, that job is said
to be in the "foreground". When the process group of the terminal is different
than the process group of a job (but is still the controlling terminal),
that job is said to be in the "background". Normally the shell reads a
command and starts the job that implements that command. If the command
is to be started in the foreground (typical), it sets the process group
of the terminal to the process group of the started job, waits for the
job to complete, and then sets the process group of the terminal back to
its own process group (it puts itself into the foreground). If the job
is to be started in the background (as denoted by the shell operator "&"),
it never changes the process group of the terminal and doesn’t wait for
the job to complete (that is, it immediately attempts to read the next
command). If the job is started in the foreground, the user may type a
key (usually which generates the terminal stop signal and has the affect
of stopping the entire job. The shell will notice that the job stopped,
and will resume running after placing itself in the foreground. The shell
also has commands for placing stopped jobs in the background, and for placing
stopped or background jobs into the foreground. An orphaned process group
is a process group that has no process whose parent is in a different process
group, yet is in the same session. Conceptually it means a process group
that doesn’t have a parent that could do anything if it were to be stopped.
For example, the initial login shell is typically in an orphaned process
group. Orphaned process groups are immune to keyboard generated stop signals
and job control signals resulting from reads or writes to the controlling
terminal. A terminal may belong to a process as its controlling terminal.
Each process of a session that has a controlling terminal has the same
controlling terminal. A terminal may be the controlling terminal for at
most one session. The controlling terminal for a session is allocated by
the session leader by issuing the ioctl. A controlling terminal is never
acquired by merely opening a terminal device file. When a controlling terminal
becomes associated with a session, its foreground process group is set
to the process group of the session leader. The controlling terminal is
inherited by a child process during a function call. A process relinquishes
its controlling terminal when it creates a new session with the function;
other processes remaining in the old session that had this terminal as
their controlling terminal continue to have it. A process does not relinquish
its controlling terminal simply by closing all of its file descriptors
associated with the controlling terminal if other processes continue to
have it open. When a controlling process terminates, the controlling terminal
is disassociated from the current session, allowing it to be acquired by
a new session leader. Subsequent access to the terminal by other processes
in the earlier session will be denied, with attempts to access the terminal
treated as if modem disconnect had been sensed. If a process is in the
foreground process group of its controlling terminal, read operations are
allowed. Any attempts by a process in a background process group to read
from its controlling terminal causes a signal to be sent to the process’s
group unless one of the following special cases apply: If the reading
process is ignoring or blocking the process is orphaned, the returns
-1 with and no signal is sent. The default action of the signal is to
stop the process to which it is sent. If a process is in the foreground
process group of its controlling terminal, write operations are allowed.
Attempts by a process in a background process group to write to its controlling
terminal will cause the process group to be sent a signal unless one of
the following special cases apply: If is not set, or if is set and the
process is ignoring or blocking the signal, the process is allowed to
write to the terminal and the signal is not sent. If is set, and the
process group of the writing process is orphaned, and the writing process
is not ignoring or blocking the returns -1 with errno set to and no signal
is sent. Certain calls that set terminal parameters are treated in the
same fashion as write, except that is ignored; that is, the effect is
identical to that of terminal writes when is set. A terminal device associated
with a terminal device file may operate in full-duplex mode, so that data
may arrive even while output is occurring. Each terminal device file has
associated with it an input queue, into which incoming data is stored by
the system before being read by a process. The system imposes a limit,
on the number of bytes that may be stored in the input queue. The behavior
of the system when this limit is exceeded depends on the setting of the
flag in the termios If this flag is set, the terminal is sent an character
each time a character is received while the input queue is full. Otherwise,
the input queue is flushed upon receiving the character. Two general kinds
of input processing are available, determined by whether the terminal device
file is in canonical mode or noncanonical mode. Additionally, input characters
are processed according to the and fields. Such processing can include
echoing, which in general means transmitting input characters immediately
back to the terminal when they are received from the terminal. This is
useful for terminals that can operate in full-duplex mode. The manner in
which data is provided to a process reading from a terminal device file
is dependent on whether the terminal device file is in canonical or noncanonical
mode. Another dependency is whether the flag is set by or If the flag
is clear, then the read request is blocked until data is available or a
signal has been received. If the flag is set, then the read request is
completed, without blocking, in one of three ways: If there is enough
data available to satisfy the entire request, and the read completes successfully
the number of bytes read is returned. If there is not enough data available
to satisfy the entire request, and the read completes successfully, having
read as much data as possible, the number of bytes read is returned. If
there is no data available, the read returns -1, with errno set to When
data is available depends on whether the input processing mode is canonical
or noncanonical. In canonical mode input processing, terminal input is
processed in units of lines. A line is delimited by a newline character,
an end-of-file character, or an end-of-line character. See the section for
more information on and This means that a read request will not return
until an entire line has been typed, or a signal has been received. Also,
no matter how many bytes are requested in the read call, at most one line
is returned. It is not, however, necessary to read a whole line at once;
any number of bytes, even one, may be requested in a read without losing
information. is a limit on the number of bytes in a line. The behavior
of the system when this limit is exceeded is the same as when the input
queue limit is exceeded. Erase and kill processing occur when either of
two special characters, the and characters (see the is received. This
processing affects data in the input queue that has not yet been delimited
by a newline or character. This un-delimited data makes up the current
line. The character deletes the last character in the current line, if
there is any. The character deletes all data in the current line, if there
is any. The and characters have no effect if there is no data in the
current line. The and characters themselves are not placed in the input
queue. In noncanonical mode input processing, input bytes are not assembled
into lines, and erase and kill processing does not occur. The values of
the and members of the array are used to determine how to process the
bytes received. represents the minimum number of bytes that should be
received when the function successfully returns. is a timer of 0.1 second
granularity that is used to time out bursty and short term data transmissions.
If is greater than the response to the request is undefined. The four
possible values for and and their interactions are described below. In
this case serves as an inter-byte timer and is activated after the first
byte is received. Since it is an inter-byte timer, it is reset after a byte
is received. The interaction between and is as follows: as soon as one
byte is received, the inter-byte timer is started. If bytes are received
before the inter-byte timer expires (remember that the timer is reset upon
receipt of each byte), the read is satisfied. If the timer expires before
bytes are received, the characters received to that point are returned
to the user. Note that if expires at least one byte is returned because
the timer would not have been enabled unless a byte was received. In this
case > 0, > 0) the read blocks until the and mechanisms are activated
by the receipt of the first byte, or a signal is received. If data is in
the buffer at the time of the read(), the result is as if data had been
received immediately after the read(). In this case, since the value of
is zero, the timer plays no role and only is significant. A pending read
is not satisfied until bytes are received (i.e., the pending read blocks
until bytes are received), or a signal is received. A program that uses
this case to read record-based terminal may block indefinitely in the read
operation. In this case, since = 0, no longer represents an inter-byte
timer. It now serves as a read timer that is activated as soon as the read
function is processed. A read is satisfied as soon as a single byte is
received or the read timer expires. Note that in this case if the timer
expires, no bytes are returned. If the timer does not expire, the only
way the read can be satisfied is if a byte is received. In this case the
read will not block indefinitely waiting for a byte; if no byte is received
within seconds after the read is initiated, the read returns a value of
zero, having read no data. If data is in the buffer at the time of the
read, the timer is started as if data had been received immediately after
the read. The minimum of either the number of bytes requested or the number
of bytes currently available is returned without waiting for more bytes
to be input. If no characters are available, read returns a value of zero,
having read no data. When a process writes one or more bytes to a terminal
device file, they are processed according to the field (see the section).
The implementation may provide a buffering mechanism; as such, when a
call to write() completes, all of the bytes written have been scheduled
for transmission to the device, but the transmission will not necessarily
have been completed. Certain characters have special functions on input
or output or both. These functions are summarized as follows: Special
character on input and is recognized if the flag (see the section) is
enabled. Generates a signal which is sent to all processes in the foreground
process group for which the terminal is the controlling terminal. If is
set, the character is discarded when processed. Special character on input
and is recognized if the flag is enabled. Generates a signal which is
sent to all processes in the foreground process group for which the terminal
is the controlling terminal. If is set, the character is discarded when
processed. Special character on input and is recognized if the flag is
set. Erases the last character in the current line; see It does not erase
beyond the start of a line, as delimited by an or character. If is
set, the character is discarded when processed. Special character on input
and is recognized if the flag is set. Deletes the entire line, as delimited
by a or character. If is set, the character is discarded when processed.
Special character on input and is recognized if the flag is set. When
received, all the bytes waiting to be read are immediately passed to the
process, without waiting for a newline, and the is discarded. Thus, if
there are no bytes waiting (that is, the occurred at the beginning of
a line), a byte count of zero is returned from the read(), representing
an end-of-file indication. If is set, the character is discarded when processed.
Special character on input and is recognized if the flag is set. It is
the line delimiter Special character on input and is recognized if the
flag is set. Is an additional line delimiter, like If the flag is enabled,
receipt of the character causes a signal to be sent to all processes
in the foreground process group for which the terminal is the controlling
terminal, and the character is discarded when processed. Special character
on both input and output and is recognized if the (output control) or
(input control) flag is set. Can be used to temporarily suspend output.
It is useful with fast terminals to prevent output from disappearing before
it can be read. If is set, the character is discarded when processed.
Special character on both input and output and is recognized if the (output
control) or (input control) flag is set. Can be used to resume output
that has been suspended by a character. If is set, the character is
discarded when processed. Special character on input and is recognized
if the flag is set; it is the as denoted in the Standard {2}. When
and are set and is not set, this character is translated into a and
has the same effect as a character. The following special characters
are extensions defined by this system and are not a part of 1003.1 termios.
Secondary character. Same function as Special character on input and
is recognized if the flag is set. Erases the last word in the current
line according to one of two algorithms. If the flag is not set, first
any preceding whitespace is erased, and then the maximal sequence of non-whitespace
characters. If is set, first any preceding whitespace is erased, and then
the maximal sequence of alphabetic/underscores or non alphabetic/underscores.
As a special case in this second algorithm, the first previous non-whitespace
character is skipped in determining whether the preceding word is a sequence
of alphabetic/undercores. This sounds confusing but turns out to be quite
practical. Special character on input and is recognized if the flag is
set. Causes the current input edit line to be retyped. Has similar actions
to the character, except that the signal is delivered when one of the
processes in the foreground process group issues a read() to the controlling
terminal. Special character on input and is recognized if the flag is
set. Receipt of this character causes the next character to be taken literally.
Special character on input and is recognized if the flag is set. Receipt
of this character toggles the flushing of terminal output. Special character
on input and is recognized if the flag is set. Receipt of this character
causes a signal to be sent to the foreground process group of the terminal.
Also, if the flag is not set, it causes the kernel to write a status
message to the terminal that displays the current load average, the name
of the command in the foreground, its process ID, the symbolic wait channel,
the number of user and system seconds used, the percentage of cpu the process
is getting, and the resident set size of the process. The and characters
cannot be changed. The values for all the remaining characters can be set
and are described later in the document under Special Control Characters.
Special character functions associated with changeable special control
characters can be disabled individually by setting their value to see
If two or more special characters have the same value, the function performed
when that character is received is undefined. If a modem disconnect is
detected by the terminal interface for a controlling terminal, and if
is not set in the field for the terminal, the signal is sent to the controlling
process associated with the terminal. Unless other arrangements have been
made, this causes the controlling process to terminate. Any subsequent call
to the read() function returns the value zero, indicating end of file.
Thus, processes that read a terminal file and test for end-of-file can terminate
appropriately after a disconnect. Any subsequent write() to the
terminal device returns -1, with set to until the device is closed.
The last process to close a terminal device file causes
any output to be sent to the device and any input to be discarded. Then,
if is set in the control modes, and the communications port supports a
disconnect function, the terminal device performs a disconnect. Routines
that need to control certain terminal characteristics do so by using the
termios structure as defined in the header This structure contains minimally
four scalar elements of bit flags and one array of special characters.
The scalar flag elements are named: and The character array is named
and its maximum index is Values of the field describe the basic terminal
input control, and are composed of following masks: /* ignore BREAK
condition */ /* map BREAK to SIGINTR */ /* ignore (discard) parity errors
*/ /* mark parity and framing errors */ /* enable checking of parity
errors */ /* strip 8th bit off chars */ /* map NL into CR */ /* ignore
CR */ /* map CR to NL (ala CRMOD) */ /* enable output flow control */
/* enable input flow control */ /* any char will restart after stop */
/* ring bell on input queue full */ In the context of asynchronous serial
data transmission, a break condition is defined as a sequence of zero-valued
bits that continues for more than the time to send one byte. The entire
sequence of zero-valued bits is interpreted as a single break condition,
even if it continues for a time equivalent to more than one byte. In contexts
other than asynchronous serial data transmission the definition of a break
condition is implementation defined. If is set, a break condition detected
on input is ignored, that is, not put on the input queue and therefore
not read by any process. If is not set and is set, the break condition
flushes the input and output queues and if the terminal is the controlling
terminal of a foreground process group, the break condition generates a
single signal to that foreground process group. If neither nor is set,
a break condition is read as a single or if is set, as If is set,
a byte with a framing or parity error (other than break) is ignored. If
is set, and is not set, a byte with a framing or parity error (other
than break) is given to the application as the three-character sequence
X, where is a two-character flag preceding each sequence and X is the
data of the character received in error. To avoid ambiguity in this case,
if is not set, a valid character of is given to the application as
If neither nor is set, a framing or parity error (other than break) is
given to the application as a single character If is set, input parity
checking is enabled. If is not set, input parity checking is disabled,
allowing output parity generation without input parity errors. Note that
whether input parity checking is enabled or disabled is independent of
whether parity detection is enabled or disabled (see If parity detection
is enabled but input parity checking is disabled, the hardware to which
the terminal is connected recognizes the parity bit, but the terminal special
file does not check whether this bit is set correctly or not. If is set,
valid input bytes are first stripped to seven bits, otherwise all eight
bits are processed. If is set, a received character is translated into
a character. If is set, a received character is ignored (not read).
If is not set and is set, a received character is translated into a
character. If is set, start/stop output control is enabled. A received
character suspends output and a received character restarts output. If
is also set, then any character may restart output. When is set, and
characters are not read, but merely perform flow control functions. When
is not set, the and characters are read. If is set, start/stop input
control is enabled. The system shall transmit one or more characters,
which are intended to cause the terminal device to stop transmitting data,
as needed to prevent the input queue from overflowing and causing the undefined
behavior described in and shall transmit one or more characters, which
are intended to cause the terminal device to resume transmitting data,
as soon as the device can continue transmitting data without risk of overflowing
the input queue. The precise conditions under which and START characters
are transmitted are implementation defined. If is set and the input queue
is full, subsequent input shall cause an character to be transmitted
to the the output queue. The initial input control value after open() is
implementation defined. Values of the field describe the basic terminal
output control, and are composed of the following masks: /* enable following
output processing */ /* map NL to CR-NL (ala */ /* expand tabs to spaces
*/ /* discard on output) */ If is set, the remaining flag masks are
interpreted as follows; otherwise characters are transmitted without change.
If is set, newlines are translated to carriage return, linefeeds. If
is set, tabs are expanded to the appropriate number of spaces (assuming
8 column tab stops). If is set, are discarded on output. Values of the
field describe the basic terminal hardware control, and are composed of
the following masks. Not all values specified are supported by all hardware.
/* character size mask */ /* 5 bits (pseudo) */ /* 6 bits */ /* 7
bits */ /* 8 bits */ /* send 2 stop bits */ /* enable receiver */ /*
parity enable */ /* odd parity, else even */ /* hang up on last close
*/ /* ignore modem status lines */ /* flow control of output */ /*
same as */ /* RTS flow control of input */ /* flow control output via
Carrier */ The bits specify the byte size in bits for both transmission
and reception. The is masked with and compared with the values or
This size does not include the parity bit, if any. If is set, two stop
bits are used, otherwise one stop bit. For example, at 110 baud, two stop
bits are normally used. If is set, the receiver is enabled. Otherwise,
no character is received. Not all hardware supports this bit. In fact,
this flag is pretty silly and if it were not part of the specification
it would be omitted. If is set, parity generation and detection are enabled
and a parity bit is added to each character. If parity is enabled, specifies
odd parity if set, otherwise even parity is used. If is set, the modem
control lines for the port are lowered when the last process with the port
open closes the port or the process terminates. The modem connection is
broken. If is set, a connection does not depend on the state of the modem
status lines. If is clear, the modem status lines are monitored. Under
normal circumstances, a call to the open() function waits for the modem
connection to complete. However, if the flag is set or if has been set,
the open() function returns immediately without waiting for the connection.
The flag is currently unused. If is set then output flow control is
controlled by the state of Carrier Detect. If the object for which the
control modes are set is not an asynchronous serial connection, some of
the modes may be ignored; for example, if an attempt is made to set the
baud rate on a network connection to a terminal on another host, the baud
rate may or may not be set on the connection between that terminal and
the machine it is directly connected to. Values of the field describe
the control of various functions, and are composed of the following masks.
/* visual erase for line kill */ /* visually erase chars */ /* enable
echoing */ /* echo even if is off */ /* visual erase mode for hardcopy
*/ /* echo control chars as ^(Char) */ /* enable signals */ /* canonicalize
input lines */ /* use alternate algorithm */ /* enable and */ /*
external processing */ /* stop background jobs from output */ /* output
being flushed (state) */ /* no kernel output from */ /* XXX retype pending
input (state) */ /* don’t flush after interrupt */ If is set, input
characters are echoed back to the terminal. If is not set, input characters
are not echoed. If and are set, the character causes the terminal to
erase the last character in the current line from the display, if possible.
If there is no character to erase, an implementation may echo an indication
that this was the case or do nothing. If and are set, the character
causes the current line to be discarded and the system echoes the character
after the character. If and are set, the character causes the current
line to be discarded and the system causes the terminal to erase the line
from the display. If and are set, the system assumes that the display
is a printing device and prints a backslash and the erased characters when
processing characters, followed by a forward slash. If is set, the system
echoes control characters in a visible fashion using a caret followed by
the control character. If is set, the system uses an alternative algorithm
for determining what constitutes a word when processing characters (see
If and are set, the character echoes even if is not set. If is set,
canonical processing is enabled. This enables the erase and kill edit functions,
and the assembly of input characters into lines delimited by and as
described in If is not set, read requests are satisfied directly from
the input queue. A read is not satisfied until at least bytes have been
received or the timeout value expired between bytes. The time value represents
tenths of seconds. See for more details. If is set, each input character
is checked against the special control characters and (job control only).
If an input character matches one of these control characters, the function
associated with that character is performed. If is not set, no checking
is done. Thus these special input functions are possible only if is set.
If is set, implementation-defined functions are recognized from the input
data. How being set interacts with or is implementation defined. If
is not set, then implementation-defined functions are not recognized, and
the corresponding input characters are not processed as described for
and If is set, the normal flush of the input and output queues associated
with the and characters are not be done. If is set, the signal is
sent to the process group of a process that tries to write to its controlling
terminal if it is not in the foreground process group for that terminal.
This signal, by default, stops the members of the process group. Otherwise,
the output generated by that process is output to the current output stream.
Processes that are blocking or ignoring signals are excepted and allowed
to produce output and the signal is not sent. If is set, the kernel does
not produce a status message when processing characters (see The special
control characters values are defined by the array This table lists the
array index, the corresponding special character, and the system default
value. For an accurate list of the system defaults, consult the header
file If the value of one of the changeable special
control characters (see is that function is disabled; that is, no input
data is recognized as the disabled special character. If is not set, the
value of has no special meaning for the and entries of the array. The
initial values of the flags and control characters after open() is set
according to the values in the header
Table of Contents