Come funziona un terminale Linux?

Se si accende un terminale e si chiama un eseguibile (supponendo che sia orientato alla linea per semplicità) si ottiene una risposta al comando dall'eseguibile. Come viene stampato (l'utente)? Il terminale fa qualcosa del genere pexpect? (sondaggio in attesa di output) o cosa? Come viene notificato l'output da stampare? E come fa un terminale ad avviare un programma? (È qualcosa di simile a os.fork di python ()?) Sono perplesso su come funzioni un terminale, sto giocando con un emulatore di terminale e non riesco ancora a capire come funziona tutta questa magia. Sto guardando la fonte di konsole (kde) e yakuake (possibilmente usa konsole) e non riesco ad arrivare dove accade tutta quella magia.

Inizialmente avevi solo terminali stupidi - inizialmente in realtà teletypewriter (simile a una macchina da scrivere elettrica, ma con un rotolo di carta) (quindi / dev / tty - TeleTYpers), ma più tardi schermo + combinazioni di tastiera - che hanno appena inviato un codice-chiave al computer e il computer ha inviato un comando che ha scritto la lettera sul terminale (cioè il terminale era senza eco locale, il computer ha dovuto ordinare al terminale di scrivere ciò che l'utente ha digitato sul terminale) - questo è uno dei motivi perché così tanti importanti comandi Unix sono così brevi. La maggior parte dei terminali erano collegati tramite linee seriali, ma (almeno) uno era direttamente collegato al computer (spesso nella stessa stanza) - questa era la console. Solo pochi utenti selezionati potevano lavorare sulla "console" (questo era spesso l'unico "terminale" disponibile in modalità utente singolo).

Più tardi c'erano anche alcuni terminali grafici (i cosiddetti "xterminali", da non confondere con il xtermprogramma) con schermo e scheda grafica, tastiera, mouse e un semplice processore; che potrebbe semplicemente eseguire un X-server. Non hanno eseguito alcun calcolo da soli, quindi gli X-client hanno funzionato sul computer a cui erano collegati. Alcuni avevano hard disk, ma potevano anche avviarsi in rete. Erano popolari all'inizio degli anni '90, prima che i PC diventassero così economici e potenti.

Un "emulatore di terminale" - la "finestra del terminale" che si apre con programmi come xtermo konsole- cerca di imitare la funzionalità di tali terminali stupidi. Anche programmi come PuTTY(Windows) emulano terminali.

Con il PC, dove "la console" (tastiera + schermo) e "il computer" sono più di una singola unità, si ottengono "terminali virtuali" (su Linux, tasti da Alt + F1 a Alt + F6), ma anche questi imitare terminali vecchio stile. Naturalmente, con Unix / Linux che diventa più un sistema operativo desktop spesso usato da un singolo utente, ora fai gran parte del tuo lavoro "alla console", dove gli utenti prima utilizzavano terminali collegati da linee seriali.

Ovviamente è la shell che avvia i programmi. E usa il fork-systemcall (linguaggio C) per fare una copia di se stesso con un ambiente-settings, quindi il exec-systemcall viene usato per trasformare questa copia nel comando che si desidera eseguire. La shell sospende (a meno che il comando non venga eseguito in background) fino al completamento del comando. Poiché il comando eredita le impostazioni di stdin, stdout e stderr dalla shell, il comando scriverà sullo schermo del terminale e riceverà l'input dalla tastiera del terminale.

Quando "apri un terminale", stai avviando un programma di emulazione di terminale, come xterm, gnome-terminal, lxterm, konsole, ...

Una delle prime cose che fa l'emulatore di terminale è allocare uno pseudo terminale (spesso chiamato pseudo-tty, o pty in breve). Il pty è una coppia di file di dispositivi a caratteri : il master pty, che è il lato aperto dall'emulatore di terminale, e lo slave pty, che è il lato aperto dai programmi in esecuzione all'interno del terminale. Sulla maggior parte dei moderni unices, il master è /dev/ptmx(che ogni emulatore di terminale ha aperto) e lo slave è /dev/pts/NUMBER. Il driver del kernel per gli pseudo-terminali tiene traccia di quale processo controlla il master per ogni dispositivo slave. L'emulatore di terminale può recuperare il percorso dello slave corrispondente attraverso uno ioctl sul dispositivo master.

Una volta che l'emulatore di terminale ha aperto il dispositivo principale, avvia un sottoprocesso (in genere una shell, ma spetta all'utente che ha invocato l'emulatore di terminale decidere). L'emulatore lo fa nel solito modo per invocare un programma:

• fork un processo figlio,
• aprire il dispositivo slave pty sui descrittori di file 0, 1 e 2 (input standard, output standard e flusso di errori),
• eseguire la shell o altri programmi nel processo figlio.

Quando il bambino (o qualsiasi altro processo) scrive sullo slave pty, l'emulatore vede l'input sul master pty.

Al contrario, quando l'emulatore scrive sul dispositivo master, viene visto come input sullo slave.

Expect funziona esattamente allo stesso modo. La differenza tra Expect e un emulatore di terminale come xterm è dove ottengono l'input che alimentano il programma (script vs input da tastiera) e cosa fanno con l'output (file di registro o parser vs disegno di testo in una finestra).