Übersicht über die Unterschiede zwischen Linux TTY/PTS

Wenn wir einen Buchstaben auf der Tastatur eingeben, wie wird er an den entsprechenden Prozess gesendet? Welche Funktionen und Unterschiede haben die Ausgaben wie tty1 und pts/0, die wir durch Befehle wie ps und who sehen?

TTY-Geschichte

Vor Multitasking-Computern

Bevor es Computer gab, benutzten die Menschen ein Gerät namens Fernschreiber, um Nachrichten untereinander zu verschicken. Es sah so aus:

+----------+ Physische Linie +----------+
| Fernschreiber |<--------------------->| Fernschreiber |
+----------+ +----------+

Die beiden Fernschreiber sind durch ein Kabel verbunden, und an beiden Enden des Kabels können sich modemähnliche Geräte befinden (sie werden hier ignoriert). Wenn Sie an einem Ende auf dem Fernschreiber tippen, werden die entsprechenden Daten an den Fernschreiber am anderen Ende gesendet. Ich weiß nicht, was die spezifischen Funktionen sind. (Das Bild in meinem Kopf ist, dass ich an einem Ende tippe und am anderen Ende ausdrucke.)

Es handelt sich um Antiquitäten, die mir noch nie begegnet sind, daher kann ich nur einfache Vermutungen anstellen.

Nach dem Aufkommen von Computern, die Multitasking unterstützen

Als Computer Multitasking unterstützten, dachte man daran, diese Fernschreiber an Computer anzuschließen und sie als Computerterminals zur Bedienung der Computer zu verwenden.

Es gibt zwei Hauptgründe für die Verwendung von Fernschreiber (persönliche Meinung):

• In Wirklichkeit gibt es bereits eine große Anzahl von Fernschreibern verschiedener Hersteller, und wir können die vorhandenen Ressourcen voll ausnutzen
• Das zugehörige Netzwerk von Teletype ist bereits recht ausgereift und einfach zu verbinden

Die Verbindung entwickelt sich also folgendermaßen:

                                   +----------+ 
+----------+ +-------+ Physische Linie +-------+ +------+ | |
| Terminal |<->| Modem |<--------------------->| Modem |<->| UART |<->| Computer |
+----------+ +-------+ +-------+ +------+ | |
                                   +----------+

• Das Terminal auf der linken Seite ist eine Vielzahl von Fernschreibern
• Modems, die wir oft „Katzen“ nennen, werden auf beiden Seiten der physischen Leitung verwendet. Dies liegt daran, dass das Internet allmählich weiterentwickelt wurde und jeder die Verbindung gemeinsam nutzen kann. (Grobe Schätzung, kann falsch sein)
• Unter UART versteht man ein Gerät, das Fernschreibsignale in für Computer erkennbare Signale umwandelt.

Kernel-TTY-Subsystem

Zur Unterstützung dieser Fernschreiber wurde für Computer ein Subsystem namens TTY entwickelt, dessen interne Struktur wie folgt aussieht:

  +--------------------------------------------------+
  | Kernel |
  | +--------+ |
  | +--------+ +------------+ | | | +----------------+
  | | UART | | Leitung | | TTY |<---------->| Benutzerprozess A |
<------>| |<->| |<->| | | +----------------+
  | | Treiber | | Disziplin | | Treiber |<---------->| Benutzerprozess B |
  | +--------+ +------------+ | | | +----------------+
  | +--------+ |
  | |
  +--------------------------------------------------+

• UART-Treiber stellt eine Verbindung zu externen UART-Geräten her
• Die Leitungsdisziplin ist hauptsächlich für die Verarbeitung von Ein- und Ausgaben verantwortlich. Es ist klar, dass sie Teil des TTY-Treibers ist.
• Der TTY-Treiber wird zur Steuerung verschiedener Endgeräte verwendet
• Userspace-Prozesse interagieren mit dem Terminal über den TTY-Treiber

Der Einfachheit halber werden UART-Treiber und Line-Disziplin in der folgenden Einführung nicht gesondert aufgeführt. Sie können als Teil des TTY-Treibers betrachtet werden.

TTY-Geräte

Für jedes Terminal erstellt der TTY-Treiber ein entsprechendes TTY-Gerät. Wenn mehrere Terminals angeschlossen sind, sieht das folgendermaßen aus:

           +----------------+
           |TTY-Treiber |
           | |
           | +-------+ | +----------------+
 +------------+ | | |<---------->| Benutzerprozess A |
 | Endgerät A |<--------->| ttyS0 | | +----------------+
 +------------+ | | |<---------->| Benutzerprozess B |
           | +-------+ | +----------------+
           | |
           | +-------+ | +----------------+
 +------------+ | | |<---------->| Benutzerprozess C |
 | Terminal B |<--------->| ttyS1 | | +----------------+
 +------------+ | | |<---------->| Benutzerprozess D |
           | +-------+ | +----------------+
           | |
           +----------------+

Wenn der Treiber eine Terminalverbindung empfängt, erstellt er basierend auf dem Terminalmodell und den Parametern ein entsprechendes TTY-Gerät (der Gerätename in der obigen Abbildung lautet ttyS0, da die meisten Terminals über serielle Verbindungen verbunden sind). Da jedes Terminal anders sein und seine eigenen speziellen Befehle und Nutzungsgewohnheiten haben kann, kann die Konfiguration jedes TTY-Geräts unterschiedlich sein. Wenn Sie beispielsweise die Entf-Taste drücken, löschen manche möglicherweise das vorherige Zeichen, während andere das folgende Zeichen löschen. Wenn sie nicht richtig konfiguriert ist, verhalten sich manche Tasten nicht wie gewünscht. Wenn wir also ein analoges Terminal verwenden und die Standardkonfiguration nicht unseren Gewohnheiten entspricht, müssen wir einige personalisierte Konfigurationen vornehmen.

Später, mit der kontinuierlichen Entwicklung von Computern, verschwanden die Fernschreiber allmählich. Wir brauchten keine speziellen Terminalgeräte mehr. Jede Maschine hatte ihre eigene Tastatur und ihren eigenen Monitor und jede Maschine konnte das Terminal anderer Maschinen sein. Remote-Operationen wurden über SSH durchgeführt, aber die Kernel-TTY-Treiberarchitektur änderte sich nicht. Wenn wir E/A-Interaktionen mit Prozessen im System durchführen wollten, mussten wir weiterhin TTY-Geräte verwenden. Infolgedessen erschienen verschiedene Terminalemulationssoftwares, und sie simulierten auch mehrere gängige Terminals wie VT100, VT220, XTerm usw.

• Mit dem Befehl toe -a können Sie alle vom System unterstützten Terminaltypen auflisten.
• Mit dem Befehl infocmp können Sie die Unterschiede zwischen zwei Terminals vergleichen. Beispielsweise gibt infocmp vt100 vt220 die Unterschiede zwischen vt100 und vt220 aus.

Wie Programme mit TTYs interagieren

Bevor wir besprechen, wie TTY-Geräte erstellt und konfiguriert werden, schauen wir uns zunächst an, wie TTY von einem Prozess verwendet wird:

#Verwenden Sie zuerst den tty-Befehl, um zu sehen, mit welchem ​​tty die aktuelle Bash verknüpft ist
dev@debian:~$ tty
/dev/pts/1

#Sehen Sie, welche Prozesse ttys dev@debian geöffnet haben:~$ lsof /dev/pts/1
BEFEHL PID BENUTZER FD TYP GERÄTEGRÖSSE/AUS KNOTENNAME
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

#Das direkte Schreiben von Daten in tty hat den gleichen Effekt wie das Schreiben in die Standardausgabe dev@dev:~$ echo aaa > /dev/pts/2
aaa

PTS ist auch ein TTY-Gerät. Ihre Beziehung wird später vorgestellt.

Aus dem obigen lsof können wir erkennen, dass stdin(0u), stdout(1u) und stderr(2u) der aktuell laufenden Bash- und lsof-Prozesse alle an dieses TTY gebunden sind.

Das Folgende ist ein Diagramm der Interaktion zwischen TTY, Prozessen und E/A-Geräten:

  Eingabe +--------------------------+ R/W +------+
----------->| |<---------->| bash |
      | Punkte/1 | +-----+
<-----------| |<---------->| lsof |
  Ausgabe | Vordergrundprozessgruppe | R/W +------+
      +--------------------------+                

• Sie können sich tty als eine Art Pipe vorstellen. Was an einem Ende geschrieben wird, kann am anderen Ende gelesen werden und umgekehrt.
• Unter Eingabe und Ausgabe kann man hier einfach Tastatur und Display verstehen. Später werden wir erklären, womit Eingabe/Ausgabe in verschiedenen Situationen verbunden sind.
• Es gibt ein sehr wichtiges Attribut in tty namens „Vordergrundprozessgruppe“, das aufzeichnet, welche die aktuelle Front-End-Prozessgruppe ist. Das Konzept der Prozessgruppe wird im nächsten Artikel vorgestellt. Hier können wir einfach davon ausgehen, dass es in der Prozessgruppe nur einen Prozess gibt.
• Wenn pts/1 die Eingabe empfängt, prüft es, welche die aktuelle Front-End-Prozessgruppe ist, und fügt die Eingabe dann in den Eingabepuffer des Leiters der Prozessgruppe ein, sodass der entsprechende Leiterprozess die Eingabe des Benutzers über die Lesefunktion abrufen kann.
• Wenn der Prozess in der Front-End-Prozessgruppe Daten auf das TTY-Gerät schreibt, gibt das TTY die Daten auf dem Ausgabegerät aus.
• Beim Ausführen verschiedener Befehle in der Shell ändert sich die Front-End-Prozessgruppe ständig und die Shell ist dafür verantwortlich, diese Änderung auf das TTY-Gerät zu übertragen.

Wie aus dem Obigen ersichtlich ist, ist der Umgang mit Prozessen und tty sehr einfach. Stellen Sie einfach sicher, dass der Hintergrundprozess tty nicht liest oder schreibt. Das heißt, beim Schreiben von Hintergrundprogrammen sollten stdin/stdout/stderr an andere Stellen umgeleitet werden (natürlich muss das Daemon-Programm auch viele andere Verarbeitungsvorgänge ausführen).

Lassen Sie mich zunächst zwei Fragen stellen (die Antworten folgen später):

• Was passiert, wenn ein Prozess in einer Nicht-Frontend-Prozessgruppe (Hintergrundprozess) Daten auf ein TTY-Gerät schreibt? Wird es an outpu ausgegeben?
• Was passiert, wenn ein Prozess in einer nicht im Vordergrund stehenden Prozessgruppe (Hintergrundprozess) Daten von einem TTY-Gerät liest? Wird der Vorgang blockiert?

Wie TTY entstand

Im Folgenden wird beschrieben, wie TTY-Geräte in verschiedenen gängigen Situationen erstellt werden und was Eingabe- und Ausgabegeräte sind.

Direktanschluss für Tastatur und Display (Terminal)

Schauen Sie sich das Bild an, bevor Sie sprechen:

          +-----------------------------------------+
          | Kernel |
          | +--------+ | +----------------+ 
 +----------+ | +-------------------+ | tty1 |<---------->| Benutzerprozesse |
 | Tastatur |--------->| | +--------+ | +----------------+
 +----------+ | | Terminalemulator |<->| tty2 |<---------->| Benutzerprozesse |
 | Überwachen |<---------| | +--------+ | +----------------+
 +----------+ | +-------------------+ | tty3 |<---------->| Benutzerprozesse |
          | +--------+ | +----------------+
          | |
          +-----------------------------------------+

Tastatur und Monitor sind mit dem Terminalemulator im Kernel verbunden. Der Emulator entscheidet, wie viele TTYs erstellt werden. Wenn Sie beispielsweise Strg+Alt+F1 auf der Tastatur eingeben, erfasst der Emulator zuerst die Eingabe und aktiviert dann TTY1. Die Tastatureingabe wird an TTY1 weitergeleitet und die Ausgabe von TTY1 wird an den Monitor weitergeleitet. Wenn Sie Strg+Alt+F2 eingeben, wechseln Sie entsprechend zu TTY2.

Wenn der Simulator beim Aktivieren des TTY feststellt, dass kein Prozess damit verknüpft ist, bedeutet dies, dass das TTY zum ersten Mal geöffnet wird. Daher startet er den konfigurierten Prozess und bindet ihn an das TTY. Im Allgemeinen ist dieser Prozess der Prozess, der für die Anmeldung verantwortlich ist.

Wohin wird die Ausgabe in tty1 ausgegeben, wenn zu tty2 gewechselt wird? Die Ausgabe von tty1 wird weiterhin an den Emulator ausgegeben und es wird für jedes tty im Emulator einen Cache geben. Aufgrund des begrenzten Cache-Speicherplatzes des Emulators können Sie jedoch beim nächsten Wechsel zurück zu tty1 nur die neueste Ausgabe sehen und die vorherige Ausgabe ist nicht mehr vorhanden.

Ich bin nicht sicher, welchem ​​Modul im Kernel der Terminalemulator entspricht, aber er existiert definitiv.

SSH-Fernzugriff

 +----------+ +------------+
 | Tastatur |------>| |
 +----------+ |
 | Überwachen |<------| |
 +----------+ +------------+
             |
             | SSH-Protokoll
             |
             ↓
          +------------+
          | |
          | SSH-Server |--------------------------+
          | | Gabel |
          +------------+ |
            | ↑ |
            | | |
         schreiben | | lesen |
            | | |
         +-----|---|--------------------+ |
         | | | | ↓
         | ↓ | +-------+ | +-------+
         | +--------+ | Punkte/0 |<---------->| Schale |
         | | | +-------+ | +-------+
         | | ptmx |<->| pts/1 |<---------->| Schale |
         | | | +-------+ | +-------+
         | +--------+ | Punkte/2 |<---------->| Schale |
         | +-------+ | +-------+
         | Kernel |
         +-----------------------------+

Das Terminal kann hier ein beliebiges Programm sein, beispielsweise Putty unter Windows. Daher werden wir nicht diskutieren, wie das Terminalprogramm des Clients mit der Tastatur und dem Display interagiert. Da Terminal mit dem SSH-Server interagieren muss, muss die SSH-Client-Funktion implementiert werden.

Hier erklären wir in zwei Zeilen den Verbindungsaufbau sowie das Senden und Empfangen von Daten. Der Einfachheit halber wird sshd anstelle des SSH-Serverprogramms verwendet:

Herstellen einer Verbindung

1.Terminal fordert zum Herstellen einer Verbindung mit sshd auf

2. Wenn die Überprüfung erfolgreich ist, erstellt sshd eine neue Sitzung

3. Rufen Sie die API (posix_openpt()) auf, um ptmx zum Erstellen eines pts aufzufordern. Nach erfolgreicher Erstellung ruft sshd das mit ptmx verknüpfte FD ab und verknüpft das FD mit der Sitzung.

#pty (Pseudo-Terminalgerät) besteht aus zwei Teilen, ptmx ist das Master-Ende, pts ist das Slave-Ende,
#Der Prozess kann ptmx durch Aufrufen der API auffordern, einen Punkt zu erstellen. Anschließend erhält er den mit ptmx verbundenen Lese-/Schreib-FD und einen neu erstellten Punkt.
#ptmx verwaltet intern die Korrespondenz zwischen fd und pts. Anschließend werden die Lese- und Schreibvorgänge für dieses fd von ptmx an die entsprechenden pts weitergeleitet.

#Hier können Sie sehen, dass sshd /dev/ptmx geöffnet hat
dev@debian:~$ sudo lsof /dev/ptmx
BEFEHL PID BENUTZER FD TYP GERÄTEGRÖSSE/AUS KNOTENNAME
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. Gleichzeitig erstellt sshd einen Shell-Prozess und bindet die neu erstellten Punkte an die Shell

Senden und Empfangen von Nachrichten

1.Terminal empfängt Tastatureingaben und sendet die Daten über das SSH-Protokoll an sshd

2. Nachdem sshd die Daten vom Client empfangen hat, findet es den mit ptmx verknüpften fd, der dem Client entsprechend der von ihm verwalteten Sitzung entspricht

3. Schreiben Sie die vom Client gesendeten Daten in das gefundene fd

4. Nachdem ptmx die Daten empfangen hat, findet es die entsprechenden Punkte gemäß fd (die entsprechende Beziehung wird von ptmx automatisch aufrechterhalten) und leitet das Datenpaket an die entsprechenden Punkte weiter

5. Nach dem Empfang des Datenpakets überprüft pts die aktuell daran gebundene Front-End-Prozessgruppe und sendet das Datenpaket an den Leiter der Prozessgruppe

6. Da es auf pts nur eine Shell gibt, empfängt die Lesefunktion der Shell das Datenpaket

7. Die Shell verarbeitet die empfangenen Datenpakete und gibt dann die Verarbeitungsergebnisse aus (oder es erfolgt möglicherweise keine Ausgabe).

8. Shell schreibt das Ergebnis über die Schreibfunktion in pts

9.pts leitet die Ergebnisse an ptmx weiter

10.ptmx findet das entsprechende fd gemäß pts und schreibt das Ergebnis in das fd

11. Nachdem sshd das Ergebnis des fd empfangen hat, findet es die entsprechende Sitzung und sendet das Ergebnis an den entsprechenden Client

Direktanschluss für Tastatur und Display (grafische Oberfläche)

 +----------+ +------------+
 | Tastatur |------>| |
 +----------+ | Terminal |--------------------------+
 | Monitor |<------| | Gabel |
 +----------+ +------------+ |
            | ↑ |
            | | |
         schreiben | | lesen |
            | | |
         +-----|---|--------------------+ |
         | | | | ↓
         | ↓ | +-------+ | +-------+
         | +--------+ | Punkte/0 |<---------->| Schale |
         | | | +-------+ | +-------+
         | | ptmx |<->| pts/1 |<---------->| Schale |
         | | | +-------+ | +-------+
         | +--------+ | Punkte/2 |<---------->| Schale |
         | +-------+ | +-------+
         | Kernel |
         +-----------------------------+

Der Einfachheit halber wird in diesem Artikel nicht darauf eingegangen, wie das Terminalprogramm in der grafischen Oberfläche unter Linux mit Tastatur und Display interagiert.

Der Unterschied zwischen hier und oben besteht darin, dass das Terminal hier den SSH-Client nicht implementieren muss, aber die Arbeit erledigen muss, die der SSH-Server erledigen muss (außer natürlich der Arbeit im Zusammenhang mit der SSH-Kommunikation).

SSH + Bildschirm/Tmux

Studenten, die häufig Linux verwenden, sollten mit screen und tmux vertraut sein. Die von ihnen gestarteten Prozesse werden auch dann weiter ausgeführt, wenn die Netzwerkverbindung getrennt wird. Wenn Sie das nächste Mal eine Verbindung herstellen, können Sie immer noch die gesamte Ausgabe des Prozesses sehen und weiterarbeiten.

Hier nehmen wir tmux als Beispiel, um sein Prinzip vorzustellen:

 +----------+ +------------+
 | Tastatur |------>| |
 +----------+ |
 | Überwachen |<------| |
 +----------+ +------------+
             |
             | SSH-Protokoll
             |
             ↓
          +------------+
          | |
          | SSH-Server |--------------------------+
          | | Gabel |
          +------------+ |
            | ↑ |
            | | |
         schreiben | | lesen |
            | | |
         +-----|---|--------------------+ |
         | ↓ | | ↓
         | +--------+ +-------+ | +-------+ Gabel +-------------+
         | | ptmx |<->| pts/0 |<---------->| Shell |-------->| tmux-Client |
         | +--------+ +-------+ | +-------+ +-------------+
         | | | | ↑
         | +--------+ +-------+ | +-------+ |
         | | ptmx |<->| pts/2 |<---------->| Schale | |
         | +--------+ +-------+ | +-------+ |
         | ↑ | Kernel | ↑ |
         +-----|---|--------------------+ | |
            | | | |
            |w/r| +---------------------------+ |
            | | | Gabel |
            | ↓ | |
          +-------------+ |
          | | |
          | tmux-Server |<--------------------------------------------+
          | |
          +-------------+

Es gibt nur einen ptmx im System, aber in der Abbildung oben sind zwei eingezeichnet, um zu zeigen, dass sowohl der tmux-Server als auch sshd ptmx verwenden, sich jedoch nicht gegenseitig stören.

Diese Situation ist etwas komplizierter, aber das Prinzip ist dasselbe. Die erste Hälfte ist dieselbe wie bei der normalen SSH-Methode, außer dass der mit pts/0 verknüpfte Front-End-Prozess keine Shell, sondern ein tmux-Client ist. Daher werden die vom SSH-Client gesendeten Datenpakete vom tmux-Client empfangen und dann vom tmux-Client an den tmux-Server weitergeleitet. Die vom tmux-Server ausgeführte Arbeit ähnelt der von SSH. Er verwaltet auch eine Reihe von Sitzungen, erstellt für jede Sitzung einen pts und leitet dann die vom tmux-Client gesendeten Daten an die entsprechenden pts weiter.

Da der tmux-Server nur mit dem tmux-Client arbeitet und nichts mit sshd zu tun hat, wird beim Trennen der Verbindung zwischen Terminal und sshd zwar pts/0 geschlossen und die damit verbundene Shell und der tmux-Client werden ebenfalls beendet, aber der tmux-Server wird dadurch nicht beeinträchtigt. Wenn Sie das nächste Mal den tmux-Client verwenden, um eine Verbindung zum tmux-Server herzustellen, wird immer noch der letzte Inhalt angezeigt.

Unterschied zwischen TTY und PTS

Aus dem obigen Prozess sollte klar hervorgehen, dass es bei User-Space-Programmen keinen Unterschied zwischen ihnen gibt, sie sind alle gleich; aus Sicht des Kernels ist das andere Ende von pts mit ptmx verbunden und das andere Ende von tty ist mit dem Terminalemulator des Kernels verbunden, und sowohl ptmx als auch der Terminalemulator sind nur für die Aufrechterhaltung von Sitzungen und die Weiterleitung von Datenpaketen verantwortlich; betrachtet man das andere Ende von ptmx und den Kernel-Terminalemulator, ist das andere Ende von ptmx mit User-Space-Anwendungen wie sshd, tmux usw. verbunden und das andere Ende des Kernel-Terminalemulators ist mit bestimmter Hardware wie Tastaturen und Monitoren verbunden.

Gängige TTY-Konfigurationen

Schauen wir uns zunächst alle Konfigurationen des aktuellen TTY an:

dev@dev:~$ stty -a
Geschwindigkeit 38400 Baud; Zeilen 51; Spalten 204; Zeile = 0;
intr = ^C; beenden = ^\; löschen = ^?; töten = ^U; eof = ^D; eol = M-^?; eol2 = M-^?; swtch = <undef>; starten = ^Q; stoppen = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V; verwerfen = ^O; min = 1; Zeit = 0;
-parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts
-ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc ixany imaxbel -iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke -flusho -extproc

stty kann auch zum Ändern von TTY-Parametern verwendet werden. Informationen zur Verwendung finden Sie unter man stty

Jedes Programm mit entsprechenden Berechtigungen kann die TTY-Konfiguration über die von Linux bereitgestellte API ändern. Im Folgenden sind einige allgemeine Konfigurationselemente aufgeführt.

Zeilen 51; Spalten 204;

Diese Konfiguration wird im Allgemeinen vom Terminal gesteuert. Wenn sich die Fenstergröße des Terminals ändert, muss die Konfiguration auf bestimmte Weise geändert werden. Beispielsweise gibt es Parameter zum Ändern der Fenstergröße im SSH-Protokoll. Nachdem SSHD die Anforderung des Clients empfangen hat, ändert es diesen Parameter von TTY über die API, und dann benachrichtigt TTY das Front-End-Programm (wie Shell oder Vim) über das Signal SIGWINCH. Nach dem Empfang des Signals liest das Front-End-Programm diesen Parameter von TTY und weiß, wie es seine Ausgabeformatierung anpassen muss.

intr = ^C

Neben der Datenweiterleitung zwischen dem Terminal und dem Front-End-Prozess unterstützt tty auch viele Steuerbefehle. Wenn beispielsweise STRG+C im Terminal eingegeben wird, leitet tty die Eingabezeichenfolge nicht an den Front-End-Prozess weiter, sondern konvertiert sie in ein Signal SIGINT und sendet sie an den Front-End-Prozess. Damit wird die dem Steuerbefehl entsprechende Eingabekombination konfiguriert. Beispielsweise können wir „intr = ^E“ konfigurieren, um STRG+C durch STRG+E zu ersetzen.

Start = ^Q; Stopp = ^S;

Dabei handelt es sich um zwei spezielle Steuerbefehle, die vielen Leuten wahrscheinlich häufig begegnen. Nach der versehentlichen Eingabe von STRG+S auf der Tastatur reagiert das Terminal nicht mehr, d. h. es erfolgt keine Ausgabe und keine Reaktion auf Eingaben. Dies liegt daran, dass dieser Befehl TTY anweist, alle Lese- und Schreibvorgänge anzuhalten und zu blockieren, d. h. es werden keine Daten weitergeleitet und der Vorgang wird erst nach dem Drücken von STRG+Q fortgesetzt. Diese Funktion sollte ein historisches Erbe sein. In der Vergangenheit gab es keine Flusskontrollfunktion zwischen dem Terminal und dem Server, sodass es möglich war, dass der Server Daten zu schnell schickte, was dazu führte, dass das Terminal sie nicht verarbeiten konnte. Daher war ein solcher Befehl erforderlich, um dem Server mitzuteilen, dass er keine weiteren Daten senden soll, und um den Server zu benachrichtigen, dass er fortfahren soll, nachdem das Terminal sie verarbeitet hat.

Ein häufiges Szenario für diesen Befehl ist die Verwendung des Befehls tail -f zum Überwachen des Inhalts einer Protokolldatei. Sie können jederzeit STRG+S drücken, um die Bildschirmaktualisierung zu stoppen, und dann STRG+Q drücken, um die Aktualisierung nach dem Lesen fortzusetzen. Andernfalls müssen Sie zuerst STRG+C drücken, um zu beenden, und dann den Befehl tail -f nach dem Lesen erneut ausführen.

Echo

Der Grund, warum wir bei der Eingabe von Zeichen in das Terminal die eingegebenen Zeichen rechtzeitig sehen können, liegt darin, dass TTY, nachdem es die vom Terminal gesendeten Zeichen empfangen hat, zunächst eine Kopie der Zeichen über den ursprünglichen Pfad zurückgibt und sie dann zur Verarbeitung an den Front-End-Prozess übergibt, damit das Terminal die eingegebenen Zeichen rechtzeitig anzeigen kann. echo ist das Konfigurationselement, das zur Steuerung dieser Funktion verwendet wird. Wenn es -echo ist, bedeutet dies, dass die Echo-Funktion deaktiviert ist.

-zustoppen

Wenn Sie beim Ausführen eines Programms in der Shell am Ende ein „&“ hinzufügen, z. B. ./myapp &, wird der „myapp“-Prozess im Hintergrund ausgeführt. Was passiert jedoch, wenn der Prozess weiterhin Daten auf das TTY schreibt? Mit diesem Parameter wird gesteuert, ob die Ausgabe an das Terminal weitergeleitet wird, d. h. ob das Ergebnis im Terminal angezeigt wird. Dabei bedeutet „-tostop“, dass die Ausgabe an das Terminal gesendet wird. Wenn es als „tostop“ konfiguriert ist, wird es nicht an das Terminal ausgegeben und tty sendet ein Signal SIGTTOU an myapp. Das Standardverhalten dieses Signals besteht darin, die Ausführung von myapp anzuhalten.

TTY-bezogene Signale

Zusätzlich zu den in der obigen Konfiguration erwähnten Signalen SIGINT, SIGTTOU und SIGWINCHU gibt es mehrere andere TTY-bezogene Signale.

SIGTTIN

Wenn der Hintergrundprozess das TTY liest, sendet das TTY dieses Signal an die entsprechende Prozessgruppe. Das Standardverhalten besteht darin, die Ausführung des Prozesses in der Prozessgruppe anzuhalten. Wie kann der unterbrochene Prozess fortgesetzt werden? Bitte beziehen Sie sich im nächsten Artikel auf SIGCONT.

ANMELDEN

Wenn beispielsweise das andere Ende des TTY auflegt, wird die SSH-Sitzung getrennt, SSHD schließt das mit ptmx verknüpfte FD und der Kernel sendet ein SIGHUP-Signal an alle mit dem TTY verbundenen Prozesse. Das Standardverhalten des Prozesses nach dem Empfang des Signals besteht darin, den Prozess zu beenden.

SIGTSTP

Wenn STRG+Z im Terminal eingegeben wird, sendet das TTY nach dem Empfang SIGTSTP an die Front-End-Prozessgruppe. Sein Standardverhalten besteht darin, die Front-End-Prozessgruppe in das Back-End zu verschieben und die Ausführung aller Prozesse in der Prozessgruppe anzuhalten.

Alle TTY-bezogenen Signale können erfasst und ihr Standardverhalten geändert werden

Abschluss

Dieser Artikel stellt die allgemeinen Funktionen und Merkmale von tty vor. Der nächste Artikel stellt die Prozesssitzungs-ID, die Prozessgruppe, den Job, das Hintergrundprogramm usw., die eng mit tty zusammenhängen, ausführlich vor. Bleiben Sie dran.

siehe

Das TTY entmystifiziert

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.