Command Line TTY Devices

If you’re just joining us, this is the second article is a series of introductory articles to the command line. The beginning of the series starts with the article “The Command Line”.

This might seem like an odd place to start. Most articles would probably start with the shell, but the shell is a large subject with a lot of features that we’ll tackle later. Understanding TTY devices and how they are used will make a lot of these features easier to understand later down the line.

To understand how TTY devices are used lets look how they are used by programs. One of the jobs of the Unix operating system is to make everything look like a file. This includes all the computer hardware including TTY devices. From the command line we can find the actual file of the TTY device associated with the shell using the command tty.

$ tty
/dev/pts/0

tty shows in this example that the TTY device file is /dev/pts/0. The who command will show you all the TTY devices being used on the system.

To see how these TTY files are being used, lets look at a minimal program written in the C programming language.

int main(int argc, char *argv[]) {
  return EXIT_SUCCESS; // Return success
}

Although this program doesn’t do anything, there are a few things that are happening behind the scenes. First of all, the operating system opens three files automatically called standard in (STDIN), standard out (STDOUT) and standard error (STDERR). These three files are the entire interface to the terminal. Writing to STDOUT displays on the terminal, reading from STDIN reads from the keyboard and STDERR is usually the same file as STDOUT but not always. These files are the TTY device.

To put all this together, lets have a look at what happens when we open a terminal window like xterm.

1. A terminal window is created.
2. A new pseudo TTY device is asked to be created by the system, for example /dev/pts/0. Note that the terminal keeps one side, the master side, of the device.
3. The shell is started, like bash, with its STDIN, STDOUT and STDERR set to the new TTY device.

The terminal and shell communicate through the TTY device. Anything written to the TTY device file from the shell will display in the terminal window and the terminal window will write keyboard events to the TTY to be later read by the shell. When the shell executes commands it also shares the TTY device file with all its child processes. To show this at work, let’s expand on our previous C program example by making it display “Hello World” and waiting for a key to be pressed using the open files STDIN and STDOUT.

Note, this isn’t how you’d typically write a program. There are a lot more convenient ways of doing this, but I wanted to show the raw writes and reads to and from the standard output and input.

#include <stdlib.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
  char in;

  // Write "Hello World" to STDOUT. This will display in the terminal.
  write(STDOUT_FILENO, "Hello World\n", 12);

  // Wait and read any key from STDIN when the terminal writes a key event
  // to the TTY device.
  read(STDIN_FILENO, &in, 1);

  return EXIT_SUCCESS; // Return success
}

If you’re feeling savvy, save the above example in a file called hello.c. It can then be compiled it into the program hello and run it as follows:

$ gcc hello.c -o hello
$ ./hello
Hello World

At this point, take a pause for a moment to digest how TTYs work. If things aren’t clear then I’d suggest re-reading this article from the beginning. The TTY is the glue between the shell and the terminal and from here on out it only gets more involved.

/dev/console
/dev/tty0
/dev/ttyS0
/dev/ttyUSB0

$ agetty /dev/ttyS0 38600 vt100