Demystifying TTY – What Does TTY Stand For and How Is It Used in Linux?

For developers and engineers working on Linux systems, the concept of TTY comes up frequently. Yet its meaning and inner workings remain a mystery to many. As both a historical vestige and a key component of modern Linux, understanding TTY provides insight into the computer/user interplay that defines Linux usability and power.

The History Behind TTY

TTY stands for TeleTYpewriter, abbreviated Teletype. In early computing before interactive terminals and displays, computers connected via serial links to electromechanical typewriters called teleprinters or teletypes. These typing machines served as a medium for users to input data/commands and enabled the computer to print output onto paper.

The Teletype Model 33 ASR became standard equipment for early computer operation. It printed onto large yellow paper, using only uppercase letters and was extremely loud and slow compared to modern equipment – but revolutionary for its time!

Each teletype machine connected to a computer had an assigned device file, like /dev/ttyN where N designated that particular teletype. The computer would read and write to these device files to communicate with individual teletypes.

So even though today‘s Linux systems no longer use physical teletypes, the TTY concept persists. It now refers to emulated virtual terminals and pseudoterminals.

TTYs in The Linux Environment

There are several types of TTY devices used in Linux:

• Serial devices – For connections via serial links, modems etc.
• Virtual terminals – Consoles accessible via Ctrl+Alt+F1 through Ctrl+Alt+F6.
• Pseudoterminals – Used by terminal emulators like xterm and ssh sessions.

This naming can seem confusing because virtual terminals and pseudoterminals don‘t represent physical devices. However, they are still considered TTY devices because they provide interactive text streams matching the behavior of old physical serial terminals from an application perspective.

Let‘s take a closer look at how TTYs work in Linux systems and access some from the command line.

Listing TTY Devices

Run the following to see configured TTY devices on a Linux machine:

ls -l /dev | grep ‘tty‘

This will display familiar TTYs like tty1 through tty6 as well as others like ttyS0, ttyUSB0, ttyAMA0 etc.

The tty1-tty6 devices map to the virtual terminals accessible using Ctrl+Alt+F1 through Ctrl+Alt+F6 keystroke combinations. Switching between these terminals allows log in to independent shell sessions.

There are also special systemd-created device files like:

/dev/tty    63 
/dev/console 63
/dev/ptmx    5

These get set up dynamically to manage tty allocation rather than representing specific hardware.

To view information on actively registered TTY device drivers in the kernel, use:

cat /proc/tty/drivers

This provides insight into the different kinds of TTYs set up in the system. As an example, here‘s partial output from a Ubuntu 20.04 workstation:

/dev/tty                   /dev/tty        5       0 system:/dev/tty
/dev/console               /dev/console    5       1 system:console
/dev/ptmx                  /dev/ptmx       5       2 system
/dev/vc/0                  /dev/tty0       4       0 system:vtmaster
serio                      /dev/ttyS       4 64-67 serial
usbser                     /dev/ttyUSB     4 66-67 serial
usbser                     /dev/ttyACM     4 98-99 serial

With 50+ tty devices configured on many Linux distributions, the scale of TTY usage is quite large given virtual terminals, serial ports, printer/modem lines etc.

Accessing TTY Terminals

As mentioned earlier, Ctrl+Alt+F1 through Ctrl+Alt+F6 keys enable access to Linux virtual terminals. Here is how they map to TTY terminals:

• Ctrl+Alt+F1 – Get TTY 1
• Ctrl+Alt+F2 – Get TTY 2
• Ctrl+Alt+F3 – Get TTY 3
• Ctrl+Alt+F4 – Get TTY 4
• Ctrl+Alt+F5 – Get TTY 5
• Ctrl+Alt+F6 – Get TTY 6

Then to return to the graphical display manager, press Ctrl+Alt+F7 or sometimes Ctrl+Alt+F1.

Each TTY presents an independent text login prompt allowing you to access a shell like bash. For example, you could log in to TTY 2 and execute commands while remaining logged into the GNOME or KDE desktop on TTY 7.

Switching through these TTYs is most useful in scenarios like:

• Troubleshooting graphics interface issues
• Debugging system startup problems
• Recovering from display manager crashes
• Running administrative commands safely
• Accessing a shell when graphical login misbehaves

So don‘t be afraid to leverage these alt-F1 through alt-F6 consoles. They provide a backup route to access your Linux system!

Using the tty Command

The tty utility itself can print the file name of the terminal connected to standard input for the current session:

tty

This will output something like /dev/pts/3 indicating the pseudoterminal assigned by the operating system.

Some helpful command options are:

• tty -s – Print program exit code, 0 means success
• tty –help – Print help info for the tty program

Let‘s take a deeper look now on how Linux implements tty functionality behind the curtains…

TTY Implementation Internals

The TTY subsystem in Linux consists of several layers of functionality:

• TTY character devices – Driver level interfaces exposed in /dev
• Line disciplines – Processing done on raw input/output
• TTY core – Managing termios settings, buffers etc
• Pseudoterminal libraries – Implementing two-way terminal comms

At the lowest level, TTY character devices like /dev/ttyS0 represent physical serial port hardware to connect terminals. The kernel‘s serial driver registers these TTY devices dynamically on system startup.

Higher level pseudoterminals use the pts device filesystem to represent endpoints for terminal emulator programs. The posix_openpt() and related APIs help launch processes on newly created pseudoterminal instances.

Inside the TTY core, linewatch discipline handles processing of input and output buffers, reporting signal events, and passing data betweeen kernel and userspace. Modules like n_hdlc offer additional line disciplines for particular terminal protocols.

With data flowing across this multi-layer TTY infrastructure, Linux enables smooth interfacing to the diverse types of terminals and programs used on modern systems.

TTY Role in User Administration

From a security perspective, the ability to manage TTY assignments and terminal access controls who can log into a Linux system.

For a standard desktop Linux distribution, Systemd activates multiple virtual terminals on startup via systemd-logind. Each virtual terminal runs getty (like agetty) to prompt for username/password and then execute the user‘s shell.

Server environments will often disable the graphical virtual terminals and run headless without a monitor attached. Yet one can still connect over the network using ssh.

Here are some other considerations around TTY management:

• Restrict root logins to certain tty/pty devices only
• Disable unused tty/vcs devices with systemctl
• Configure authselect/pam modules for smartcard/2FA logins
• Limit sudo access to admin group members
• Use /etc/securetty to control root tty access
• Setup a login banner /etc/issue per security policy
• Configure user login timeouts

Hardening tty security helps prevent exploits like brute force attacks, while still permitting remote access for administration.

Auditing tty usage via auditd and journald logging provides further visibility into user sessions and terminal activity.

TTY vs Other Terminal Terminology

Since the domain around Linux terminals employs much overlapping terminology, it helps to define some other common words:

• Shell – The command line interpreter used to interface with the kernel like bash, zsh, csh.
• Terminal – A terminal emulator application used to interact with the shell by running commands, reading output etc. Common choices include xterm, gnome-terminal, konsole and others.
• Pseudoterminal – A software mechanism enabling terminal emulators to open bidirectional communication channels with their child process shell. The pts filesystem and openpt()/posix_openpt() APIs facilitate this terminal/process interplay behind the scenes.

In summary:

TTY = Emulated device file interfacing between programs/kernel
Shell = Command line program run within TTY container

Terminal = Applicationlaunching shell process via pseudoterminal

Conclusion

This guide covers what TTYs represent, how the concept traces back to physical teletypewriter equipment, and why TTY devices remain integral components in modern Linux. TTYs handle critical communication for physical serial ports, virtual consoles, terminal emulators, remote login programs, and other software.

Understanding the TTY‘s role in bridging computer and human through input/output provides key insight into the Linux user experience. TTY session management also relates closely to security policies around authentication, authorization and auditing. Mastering usage of the TTY subsystem is an important skill for any Linux system administrator or developer.

While learning Linux is always an ongoing journey, I hope this piece helps decode the critical TTY environment. Please reach out with any questions!