Comment fonctionne un terminal Linux?

Si vous lancez un terminal et appelez un exécutable (en supposant que celui-ci soit orienté ligne pour plus de simplicité), vous obtenez une réponse à la commande à partir de l'exécutable. Comment cela est-il imprimé pour vous (l'utilisateur)? Est-ce que le terminal fait quelque chose comme pexpect? (sondage en attente de sortie) ou quoi? Comment est-il informé de la sortie à imprimer? Et comment un terminal démarre-t-il un programme? (Cela ressemble-t-il à os.fork ()?) De python? Je suis intrigué par le fonctionnement d'un terminal, je joue avec un émulateur de terminal et je ne comprends toujours pas comment fonctionne toute cette magie. Je regarde la source de konsole (kde) et de yakuake (utilise éventuellement konsole) et je ne peux pas en arriver là où toute cette magie se produit.

À l’origine, vous ne disposiez que de terminaux stupides - au début, en fait, des téléscripteurs (semblables à une machine à écrire électrique, mais avec un rouleau de papier) (d’où / dev / tty - TeleTYpers), mais plus tard l’écran + les combos clavier - qui viennent d’envoyer un code clé à l'ordinateur et l'ordinateur a renvoyé une commande qui a écrit la lettre sur le terminal (c'est-à-dire que le terminal était sans écho local, l'ordinateur a dû ordonner au terminal d'écrire ce que l'utilisateur a tapé sur le terminal) - c'est l'une des raisons pourquoi autant de commandes Unix importantes sont si courtes. La plupart des terminaux étaient connectés par des lignes série, mais au moins un était directement connecté à l'ordinateur (souvent la même pièce): il s'agissait de la console. Seuls quelques utilisateurs sélectionnés ont été autorisés à travailler sur "la console" (il s'agissait souvent du seul "terminal" disponible en mode mono-utilisateur).

Plus tard, il y eut aussi quelques terminaux graphiques (appelés "terminaux", à ne pas confondre avec le xtermprogramme) avec carte écran & graphique, clavier, souris et un processeur simple; qui pourrait simplement exécuter un serveur X. Ils n'ont effectué aucun calcul eux-mêmes et les clients X ont donc été exécutés sur l'ordinateur auquel ils étaient connectés. Certains avaient des disques durs, mais ils pouvaient aussi démarrer sur le réseau. Ils étaient populaires au début des années 90, avant que les PC ne deviennent si puissants et si économiques.

Un "émulateur de terminal" - la "fenêtre de terminal" que vous ouvrez avec des programmes tels que xtermou konsole- tente de reproduire la fonctionnalité de tels terminaux stupides. Des programmes tels que PuTTY(Windows) émulent des terminaux.

Avec le PC, où "la console" (clavier + écran) et "l'ordinateur" constituent plutôt une seule unité, vous disposez de "terminaux virtuels" (sous Linux, les touches Alt + F1 à Alt + F6), mais aussi imiter les terminaux de style ancien. Bien sûr, avec Unix / Linux qui devient de plus en plus un système d’exploitation de bureau souvent utilisé par un seul utilisateur, vous effectuez maintenant la majeure partie de votre travail "sur la console", où les utilisateurs utilisaient avant les terminaux connectés par des lignes série.

C'est bien sûr le shell qui lance les programmes. Et il utilise le fork-systemcall (langage C) pour se copier avec des paramètres d'environnement, puis exec-systemcall est utilisé pour transformer cette copie en commande que vous voulez exécuter. Le shell suspend (sauf si la commande est exécutée en arrière-plan) jusqu'à ce que la commande soit terminée. Comme la commande hérite des paramètres stdin, stdout et stderr du shell, la commande écrit sur l'écran du terminal et reçoit les entrées du clavier du terminal.

Lorsque vous «ouvrez un terminal», vous démarrez un programme d'émulateur de terminal, tel que xterm, gnome-terminal, lxterm, konsole,…

L’une des premières choses que fait l’émulateur de terminal consiste à allouer un pseudo-terminal (souvent appelé pseudo- terminal , ou pty). Le pty est une paire de fichiers de périphérique de caractères : le maître pty, qui est le côté ouvert par l'émulateur de terminal, et l'esclave pty, qui est le côté ouvert par les programmes s'exécutant à l'intérieur du terminal. Sur la plupart des ordinateurs modernes, le maître est /dev/ptmx(ce que chaque émulateur de terminal a ouvert) et l'esclave /dev/pts/NUMBER. Le pilote de noyau pour les pseudo-terminaux garde la trace du processus qui contrôle le maître pour chaque périphérique esclave. L'émulateur de terminal peut récupérer le chemin d'accès à l'esclave correspondant via un ioctl sur le périphérique maître.

Une fois que l'émulateur de terminal a ouvert le périphérique maître, il lance un sous-processus (généralement un shell, mais c'est l'utilisateur qui a appelé l'émulateur de terminal pour décider). L'émulateur fait cela de la manière habituelle pour invoquer un programme:

• créer un processus fils,
• ouvrez le périphérique pty esclave sur les descripteurs de fichier 0, 1 et 2 (entrée standard, sortie standard et flux d'erreur),
• exécuter le shell ou un autre programme dans le processus enfant.

Lorsque l'enfant (ou tout autre processus) écrit sur l'esclave pty, l'émulateur voit l'entrée sur le maître pty.

À l'inverse, lorsque l'émulateur écrit sur le périphérique maître, il est considéré comme une entrée sur l'esclave.

Attends fonctionne exactement de la même manière. La différence entre Expect et un émulateur de terminal tel que xterm réside dans le fait qu’ils obtiennent l’entrée qu’ils alimentent le programme (entrée script / clavier) et ce qu’ils font avec la sortie (fichier journal ou analyseur vs texte dessiné dans une fenêtre).