To be specific, let's speak in pseudo-terminal terms. Suppose we have file descriptors master
and slave
for a pseudo-terminal pair (suppose it is a controlling tty). Disabling IXON
on master
(or slave
, which works the same) means that when we do write(master, &control_s_code, 1)
, read(slave, &byte, 1)
will get this code. The same concerns control_q_code
. The question is: what does disabling IXOFF
do?
TTY – Difference Between IXON and IXOFF TTY Attributes
ptytty
Related Solutions
A terminal is at the end of an electric wire, a shell is the home of a turtle, tty is a strange abbreviation and a console is a kind of cabinet.
Well, etymologically speaking, anyway.
In unix terminology, the short answer is that
- terminal = tty = text input/output environment
- console = physical terminal
- shell = command line interpreter
Console, terminal and tty are closely related. Originally, they meant a piece of equipment through which you could interact with a computer: in the early days of unix, that meant a teleprinter-style device resembling a typewriter, sometimes called a teletypewriter, or “tty” in shorthand. The name “terminal” came from the electronic point of view, and the name “console” from the furniture point of view. Very early in unix history, electronic keyboards and displays became the norm for terminals.
In unix terminology, a tty is a particular kind of device file which implements a number of additional commands (ioctls) beyond read and write. In its most common meaning, terminal is synonymous with tty. Some ttys are provided by the kernel on behalf of a hardware device, for example with the input coming from the keyboard and the output going to a text mode screen, or with the input and output transmitted over a serial line. Other ttys, sometimes called pseudo-ttys, are provided (through a thin kernel layer) by programs called terminal emulators, such as Xterm (running in the X Window System), Screen (which provides a layer of isolation between a program and another terminal), Ssh (which connects a terminal on one machine with programs on another machine), Expect (for scripting terminal interactions), etc.
The word terminal can also have a more traditional meaning of a device through which one interacts with a computer, typically with a keyboard and display. For example an X terminal is a kind of thin client, a special-purpose computer whose only purpose is to drive a keyboard, display, mouse and occasionally other human interaction peripherals, with the actual applications running on another, more powerful computer.
A console is generally a terminal in the physical sense that is by some definition the primary terminal directly connected to a machine. The console appears to the operating system as a (kernel-implemented) tty. On some systems, such as Linux and FreeBSD, the console appears as several ttys (special key combinations switch between these ttys); just to confuse matters, the name given to each particular tty can be “console”, ”virtual console”, ”virtual terminal”, and other variations.
See also Why is a Virtual Terminal “virtual”, and what/why/where is the “real” Terminal?.
A shell is the primary interface that users see when they log in, whose primary purpose is to start other programs. (I don't know whether the original metaphor is that the shell is the home environment for the user, or that the shell is what other programs are running in.)
In unix circles, shell has specialized to mean a command-line shell, centered around entering the name of the application one wants to start, followed by the names of files or other objects that the application should act on, and pressing the Enter key. Other types of environments don't use the word “shell”; for example, window systems involve “window managers” and “desktop environments”, not a “shell”.
There are many different unix shells. Popular shells for interactive use include Bash (the default on most Linux installations), zsh (which emphasizes power and customizability) and fish (which emphasizes simplicity).
Command-line shells include flow control constructs to combine commands. In addition to typing commands at an interactive prompt, users can write scripts. The most common shells have a common syntax based on the Bourne_shell. When discussing “shell programming”, the shell is almost always implied to be a Bourne-style shell. Some shells that are often used for scripting but lack advanced interactive features include the Korn shell (ksh) and many ash variants. Pretty much any Unix-like system has a Bourne-style shell installed as /bin/sh
, usually ash, ksh or bash.
In unix system administration, a user's shell is the program that is invoked when they log in. Normal user accounts have a command-line shell, but users with restricted access may have a restricted shell or some other specific command (e.g. for file-transfer-only accounts).
The division of labor between the terminal and the shell is not completely obvious. Here are their main tasks.
- Input: the terminal converts keys into control sequences (e.g. Left →
\e[D
). The shell converts control sequences into commands (e.g.\e[D
→backward-char
). - Line editing, input history and completion are provided by the shell.
- The terminal may provide its own line editing, history and completion instead, and only send a line to the shell when it's ready to be executed. The only common terminal that operates in this way is
M-x shell
in Emacs.
- The terminal may provide its own line editing, history and completion instead, and only send a line to the shell when it's ready to be executed. The only common terminal that operates in this way is
- Output: the shell emits instructions such as “display
foo
”, “switch the foreground color to green”, “move the cursor to the next line”, etc. The terminal acts on these instructions. - The prompt is purely a shell concept.
- The shell never sees the output of the commands it runs (unless redirected). Output history (scrollback) is purely a terminal concept.
- Inter-application copy-paste is provided by the terminal (usually with the mouse or key sequences such as Ctrl+Shift+V or Shift+Insert). The shell may have its own internal copy-paste mechanism as well (e.g. Meta+W and Ctrl+Y).
- Job control (launching programs in the background and managing them) is mostly performed by the shell. However, it's the terminal that handles key combinations like Ctrl+C to kill the foreground job and Ctrl+Z to suspend it.
A tty is a native terminal device, the backend is either hardware or kernel emulated.
A pty (pseudo terminal device) is a terminal device which is emulated by an other program (example: xterm
, screen
, or ssh
are such programs). A pts is the slave part of a pty.
(More info can be found in man pty
.)
Short summary:
A pty is created by a process through posix_openpt()
(which usually opens the special device /dev/ptmx
), and is constituted by a pair of bidirectional character devices:
The master part, which is the file descriptor obtained by this process through this call, is used to emulate a terminal. After some initialization, the second part can be unlocked with
unlockpt()
, and the master is used to receive or send characters to this second part (slave).The slave part, which is anchored in the filesystem as
/dev/pts/x
(the real name can be obtained by the master throughptsname()
) behaves like a native terminal device (/dev/ttyx
). In most cases, a shell is started that uses it as a controlling terminal.
Related Question
- Difference between the terminal file and the terminal screen
- Linux – Difference Between /dev/console, /dev/tty, and /dev/tty0
- terminal – Responsibilities of Each Pseudo-Terminal (PTY) Component
- TTY vs PTS – Difference Between PTS, TTY, and :0
- TTY Command – Do ‘tty’ Command and ‘/dev/tty’ File Refer to the Controlling Terminal?
Best Answer
IXOFF
is not implemented on pseudo-ttys, and settingIXOFF
on a pseudo-tty has no effect whatsoever.IXOFF
should cause the tty driver to send aVSTOP
character to the other side when its input queue is full (which should prevent it from sending in more data), and aVSTART
character when it has processed it and there's place for more data.This is different from
IXON
, which will cause the tty driver to respect theVSTART
/VSTOP
characters sent from the other side, and upon receiving aVSTOP
(^S
) character, stop any transmission until aVSTART
(^Q
) character is received.In the case of a pseudo-tty, the "other side" is the master pty, eg. your terminal emulator; when you press
^S
, it's theIXON
, not theIXOFF
setting which will cause the slave tty to stop echoing back the entered characters and displaying the data written to it (which will be queued until the output queue is full, when anywrite(2)
to the slave tty will either block or returnEAGAIN
).Implementing flow control on pseudo-ttys is not needed, because the kernel always knows (by checking a struct field or similar) whether the input queue of the slave has filled up, and can just block the process writing to the master pty.
The software flow control is only useful when using a real serial connection without out-of-band signals like RTS/CTS: unlike any Unix, TCP or other "pipe" abstraction, a wire is not buffering and will not fill up and block until the receiver has read all the state changes off it.