本文转载自：Linux TTY/PTS概述
你想知道当在terminal上输入指令时，系统发生了什么么？你想知道ssh的实现原理么？本文将全部覆盖。

当我们在键盘上敲下一个字母的时候，到底是怎么发送到相应的进程的呢？我们通过ps、who等命令看到的类似tty1、pts/0这样的输出，它们的作用和区别是什么呢？

1. tty历史

1.1 支持多任务的计算机出现之前

在计算机出来以前，人们就已经在使用一种叫teletype的设备，用来相互之间传递信息，看起来像下面这样：

1
2
3
+----------+     Physical Line     +----------+
| teletype |<--------------------->| teletype |
+----------+                       +----------+

两个teletype之间用线连接起来，线两端可能也有类似于调制解调器之类的设备（这里将它们忽略），在一端的teletype上敲键盘时，相应的数据会发送到另一端的teletype。

1.2 支持多任务的计算机出现之后

等到计算机支持多任务后，人们想到把这些teletype连到计算机上，作为计算机的终端，从而可以操作计算机。

于是连接就发展成这样：

1
2
3
4
5
                                                                      +----------+ 
+----------+   +-------+     Physical Line     +-------+   +------+   |          |
| Terminal |<->| Modem |<--------------------->| Modem |<->| UART |<->| Computer |
+----------+   +-------+                       +-------+   +------+   |          |
                                                                      +----------+
  • 左边的Terminal就是各种各样的teletype
  • 物理线路两边用上了Modem，就是我们常说的“猫”
  • UART可以理解为将teletype信号转换成计算机能识别的信号的设备

1.3 内核TTY子系统

计算机为了支持这些teletype，于是设计了名字叫做TTY的子系统，内部结构如下：

1
2
3
4
5
6
7
8
9
10
11
    +-----------------------------------------------+
    |                    Kernel                     |
    |                                 +--------+    |
    |   +--------+   +------------+   |        |    |       +----------------+
    |   |  UART  |   |    Line    |   |  TTY   |<---------->| User process A |
<------>|        |<->|            |<->|        |    |       +----------------+
    |   | driver |   | discipline |   | driver |<---------->| User process B |
    |   +--------+   +------------+   |        |    |       +----------------+
    |                                 +--------+    |
    |                                               |
    +-----------------------------------------------+

  • UART driver对接外面的UART设备
  • Line discipline主要是对输入和输出做一些处理，可以理解它是TTY driver的一部分
  • TTY driver用来处理各种终端设备
  • 用户空间的进程通过TTY driver来和终端打交道

为了简单起见，后面的介绍中不再单独列出UART driver和Line discipline，可以认为它们是TTY driver的一部分

1.4 TTY设备

对于每一个终端，TTY driver都会创建一个TTY设备与它对应，如果有多个终端连接过来，那么看起来就是这个样子的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
                     +----------------+
                     |   TTY Driver   |
                     |                |
                     |   +-------+    |       +----------------+
+------------+       |   |       |<---------->| User process A |
| Terminal A |<--------->| ttyS0 |    |       +----------------+
+------------+       |   |       |<---------->| User process B |
                     |   +-------+    |       +----------------+
                     |                |
                     |   +-------+    |       +----------------+
+------------+       |   |       |<---------->| User process C |
| Terminal B |<--------->| ttyS1 |    |       +----------------+
+------------+       |   |       |<---------->| User process D |
                     |   +-------+    |       +----------------+
                     |                |
                     +----------------+

当驱动收到一个终端的连接时，就会根据终端的型号和参数创建相应的tty设备（上图中设备名称叫ttyS0是因为大部分终端的连接都是串行连接），由于每个终端可能都不一样，有自己的特殊命令和使用习惯，于是每个tty设备的配置可能都不一样。比如按delete键的时候，有些可能是要删前面的字符，而有些可能是删后面的，如果没配置对，就会导致某些按键不是自己想要的行为，这也是我们在使用模拟终端时，如果默认的配置跟我们的习惯不符，需要做一些个性化配置的原因。

后来随着计算机的不断发展，teletype这些设备逐渐消失，我们不再需要专门的终端设备了，每个机器都有自己的键盘和显示器，每台机器都可以是其它机器的终端，远程的操作通过ssh来实现。但是内核TTY驱动这一架构没有发生变化，我们想要和系统中的进程进行I/O交互，还是需要通过TTY设备，于是出现了各种终端模拟软件，并且模拟的也是常见的几种终端，如VT100、VT220、XTerm等。

2. 程序如何和TTY打交道

在讨论TTY设备是如何被创建及配置之前，我们先来看看TTY是如何被进程使用的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#先用tty命令看看当前bash关联到了哪个tty
dev@debian:~$ tty
/dev/pts/1

#看tty都被哪些进程打开了
dev@debian:~$ lsof /dev/pts/1
COMMAND  PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
bash     907  dev    0u   CHR  136,1      0t0    4 /dev/pts/1
bash     907  dev    1u   CHR  136,1      0t0    4 /dev/pts/1
bash     907  dev    2u   CHR  136,1      0t0    4 /dev/pts/1
bash     907  dev  255u   CHR  136,1      0t0    4 /dev/pts/1
lsof    1118  dev    0u   CHR  136,1      0t0    4 /dev/pts/1
lsof    1118  dev    1u   CHR  136,1      0t0    4 /dev/pts/1
lsof    1118  dev    2u   CHR  136,1      0t0    4 /dev/pts/1

#往tty里面直接写数据跟写标准输出是一样的效果
dev@dev:~$ echo aaa > /dev/pts/2
aaa

pts也是tty设备，它们的关系后面会介绍到。
通过上面的lsof可以看出，当前运行的bash和lsof进程的stdin(0u)、stdout(1u)、stderr(2u)都绑定到了这个TTY上。

下面是tty和进程以及I/O设备交互的结构图：

1
2
3
4
5
6
   Input    +--------------------------+    R/W     +------+
----------->|                          |<---------->| bash |
            |          pts/1           |            +------+
<-----------|                          |<---------->| lsof |
   Output   | Foreground process group |    R/W     +------+
            +--------------------------+

  • 可以把tty理解成一个管道（pipe），在一端写的内容可以从另一端读取出来，反之亦然。
  • 这里input和output可以简单的理解为键盘和显示器，后面会介绍在各种情况下input/ouput都连接的什么东西。
  • tty里面有一个很重要的属性，叫Foreground process group，记录了当前前端的进程组是哪一个。这里可以简单的认为process group里面只有一个进程。
  • 当pts/1收到input的输入后，会检查当前前端进程组是哪一个，然后将输入放到进程组的leader的输入缓存中，这样相应的leader进程就可以通过read函数得到用户的输入
  • 当前端进程组里面的进程往tty设备上写数据时，tty就会将数据输出到output设备上
  • 当在shell中执行不同的命令时，前端进程组在不断的变化，而这种变化会由shell负责更新到tty设备中

从上面可以看出，进程和tty打交道很简单，只要保证后台进程不要读写tty就可以了。

先抛出两个问题(后面有答案)：

  • 当非前端进程组里面的进程（后台进程）往tty设备上写数据时，会发生什么？会输出到outpu上吗？
  • 当非前端进程组里面的进程（后台进程）从tty设备上读数据时，会发生什么？进程会阻塞吗？

3. TTY是如何被创建的

下面介绍几种常见的情况下tty设备是如何创建的，以及input和output设备都是啥。

3.1 键盘显示器直连（终端）

先看图再说话：

1
2
3
4
5
6
7
8
9
10
11
                  +-----------------------------------------+
                  |          Kernel                         |
                  |                           +--------+    |       +----------------+ 
+----------+      |   +-------------------+   |  tty1  |<---------->| User processes |
| Keyboard |--------->|                   |   +--------+    |       +----------------+
+----------+      |   | Terminal Emulator |<->|  tty2  |<---------->| User processes |
| Monitor  |<---------|                   |   +--------+    |       +----------------+
+----------+      |   +-------------------+   |  tty3  |<---------->| User processes |
                  |                           +--------+    |       +----------------+
                  |                                         |
                  +-----------------------------------------+

键盘、显示器都和内核中的终端模拟器相连，由模拟器决定创建多少tty，比如你在键盘上输入ctrl+alt+F1时，模拟器首先捕获到该输入，然后激活tty1，这样键盘的输入会转发到tty1，而tty1的输出会转发到显示器，同理用输入ctrl+alt+F2，就会切换到tty2。

当模拟器激活tty时，如果发现没有进程与之关联，意味着这是第一次打开该tty，于是会启动配置好的进程并和该tty绑定。

当切换到tty2后，tty1里面的输出会输出到哪里呢？tty1的输出还是会输出给模拟器，模拟器里会有每个tty的缓存，不过由于模拟器的缓存空间有限，所以下次切回tty1的时候，只能看到最新的输出，以前的输出已经不在了。

3.2 SSH远程访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
+----------+       +------------+
| Keyboard |------>|            |
+----------+       |  Terminal  |
| Monitor  |<------|            |
+----------+       +------------+
                         |
                         |  ssh protocol
                         |
                         ↓
                   +------------+
                   |            |
                   | ssh server |--------------------------+
                   |            |           fork           |
                   +------------+                          |
                       |   ↑                               |
                       |   |                               |
                 write |   | read                          |
                       |   |                               |
                 +-----|---|-------------------+           |
                 |     |   |                   |           ↓
                 |     ↓   |      +-------+    |       +-------+
                 |   +--------+   | pts/0 |<---------->| shell |
                 |   |        |   +-------+    |       +-------+
                 |   |  ptmx  |<->| pts/1 |<---------->| shell |
                 |   |        |   +-------+    |       +-------+
                 |   +--------+   | pts/2 |<---------->| shell |
                 |                +-------+    |       +-------+
                 |    Kernel                   |
                 +-----------------------------+

这里的Terminal可能是任何地方的程序，比如windows上的putty，所以不讨论客户端的Terminal程序是怎么和键盘、显示器交互的。由于Terminal要和ssh服务器打交道，所以肯定要实现ssh的客户端功能。

为了描述简洁，这里以sshd代替ssh服务器程序。

建立连接：

  1. Terminal请求和sshd建立连接
  2. 如果验证通过，sshd将创建一个新的session

  3. 调用API请求ptmx创建一个pts，创建成功后，sshd将得到和ptmx关联的fd，并将该fd和session关联起来。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #pty（pseudo terminal device）由两部分构成，ptmx是master端，pts是slave端，
    #进程可以通过调用API请求ptmx创建一个pts，然后将会得到连接到ptmx的读写fd和一个新创建的pts，
    #ptmx在内部会维护该fd和pts的对应关系，随后往这个fd的读写会被ptmx转发到对应的pts。

    #这里可以看到sshd已经打开了/dev/ptmx
    dev@debian:~$ sudo lsof /dev/ptmx
    COMMAND  PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
    sshd    1191  dev    8u   CHR    5,2      0t0 6531 /dev/ptmx
    sshd    1191  dev   10u   CHR    5,2      0t0 6531 /dev/ptmx
    sshd    1191  dev   11u   CHR    5,2      0t0 6531 /dev/ptmx

  4. 同时sshd创建shell进程，将新创建的pts和shell绑定

收发消息：

  1. Terminal收到键盘的输入，Terminal通过ssh协议将数据发往sshd
  2. sshd收到客户端的数据后，根据它自己管理的session，找到该客户端对应的关联到ptmx上的fd
  3. 往找到的fd上写入客户端发过来的数据
  4. ptmx收到数据后，根据fd找到对应的pts（该对应关系由ptmx自动维护），将数据包转发给对应的pts
  5. pts收到数据包后，检查绑定到自己上面的当前前端进程组，将数据包发给该进程组的leader
  6. 由于pts上只有shell，所以shell的read函数就收到了该数据包
  7. shell对收到的数据包进行处理，然后输出处理结果（也可能没有输出）
  8. shell通过write函数将结果写入pts
  9. pts将结果转发给ptmx
  10. ptmx根据pts找到对应的fd，往该fd写入结果
  11. sshd收到该fd的结果后，找到对应的session，然后将结果发给对应的客户端

3.3 键盘显示器直连（图形界面）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
+----------+       +------------+
| Keyboard |------>|            |
+----------+       |  Terminal  |--------------------------+
| Monitor  |<------|            |           fork           |
+----------+       +------------+                          |
                       |   ↑                               |
                       |   |                               |
                 write |   | read                          |
                       |   |                               |
                 +-----|---|-------------------+           |
                 |     |   |                   |           ↓
                 |     ↓   |      +-------+    |       +-------+
                 |   +--------+   | pts/0 |<---------->| shell |
                 |   |        |   +-------+    |       +-------+
                 |   |  ptmx  |<->| pts/1 |<---------->| shell |
                 |   |        |   +-------+    |       +-------+
                 |   +--------+   | pts/2 |<---------->| shell |
                 |                +-------+    |       +-------+
                 |    Kernel                   |
                 +-----------------------------+

为了简化起见，本篇不讨论Linux下图形界面里Terminal程序是怎么和键盘、显示器交互的。

这里和上面的不同点就是，这里的Terminal不需要实现ssh客户端，但需要把ssh服务器要干的活也干了（当然ssh通信相关的除外）。

4. TTY和PTS的区别

从上面的流程中应该可以看出来了，对用户空间的程序来说，他们没有区别，都是一样的；从内核里面来看，pts的另一端连接的是ptmx，而tty的另一端连接的是内核的终端模拟器，ptmx和终端模拟器都只是负责维护会话和转发数据包；再看看ptmx和内核终端模拟器的另一端，ptmx的另一端连接的是用户空间的应用程序，如sshd、tmux等，而内核终端模拟器的另一端连接的是具体的硬件，如键盘和显示器。

参考资料：

  1. The TTY demystified
  2. Linux session和进程组概述