Questo è quello che è successo quando ho eseguito sudo suseguito daexit

$ sudo su
# exit
exit
$ 

Il comando exit non chiude il mio emulatore di terminale.

È un terminale per bambini?

Una volta eseguito sudo suo viene creata una nuova shell.su user

L'esecuzione exit(o Ctrl+ D) uscirà dalla shell appena creata e tornerà alla shell precedente.

1. Punto di partenza: la shell bash è in esecuzione su PID 25050:

   $ ps
     PID TTY          TIME CMD
   25050 pts/17   00:00:00 bash
   25200 pts/17   00:00:00 ps
   

2. In esecuzione sudo sucrea un nuovo processo bash in esecuzione su PID 25203:

   $ sudo su
   # ps
     PID TTY          TIME CMD
   25201 pts/17   00:00:00 sudo
   25202 pts/17   00:00:00 su
   25203 pts/17   00:00:00 bash
   25213 pts/17   00:00:00 ps
   # exit
   

3. Uscita sudo sue ritorno al punto iniziale - la shell bash è in esecuzione su PID 25050:

   $ ps
     PID TTY          TIME CMD
   25050 pts/17   00:00:00 bash
   25214 pts/17   00:00:00 ps
   $
   

Stesso terminale, shell diversa.

I processi figlio eseguiti da una shell, incluse le shell secondarie, utilizzano automaticamente lo stesso terminale. Questo non è specifico sudoin alcun modo - questo è generalmente il modo in cui funziona quando si esegue qualsiasi programma dalla shell.

Conchiglie e terminali sono cose diverse. Una shell è ciò che usi per eseguire comandi in un terminale . Una shell può operare in modo interattivo: ti dà un prompt, gli dai un comando, esegue il comando o mostra un errore sul perché non è possibile e il processo si ripete fino a quando non esci dalla shell. Oppure può funzionare in modo non interattivo, eseguendo uno script .

Anche se il tuo terminale è (probabilmente!) Emulato , non fisico , tuttavia i sistemi operativi simili a Unix come Ubuntu assegnano nodi di dispositivo a ciascuno dei tuoi terminali e puoi controllare quale terminale stai usando con il ttycomando. Sarà di solito /dev/pts/0, /dev/pts/1, /dev/pts/2, ecc , per una finestra di terminale o connessione SSH , o /dev/tty1, /dev/tty2, ecc , per console virtuali . Davvero ciò che ttyfa è dirti da quale terminale, se presente, viene ricevuto l' input ; vedi sotto per i dettagli.

ek@Io:~$ tty
/dev/pts/1
ek@Io:~$ bash
ek@Io:~$ tty
/dev/pts/1
ek@Io:~$ exit
exit
ek@Io:~$ sudo su
[sudo] password for ek:
root@Io:/home/ek# tty
/dev/pts/1
root@Io:/home/ek# exit
exit
ek@Io:~$

Puoi vedere che, anche se sudo sucrea una nuova shell come spiega molto bene Yaron , il terminale che stai usando non cambia.

Naturalmente, c'è un altro modo per osservare che il terminale è lo stesso: stai ancora scrivendo input nello stesso modo e nello stesso posto, e leggendo l'output nello stesso modo e nello stesso posto.

Alcuni dettagli tecnici

La maggior parte dei comandi eseguiti in una shell - come ad esempio ls, cp, mv, rm, touch, wc, du, df, ssh, su, sudo, sh, bash, e molti di più - causa un processo figlio da creare. Questo processo figlio ha la shell come padre ma è un programma separato. Per default, è collegato al medesimo terminale come shell.

La shell è ancora in esecuzione, ma attende in background il termine del programma (o la sospensione da parte dell'utente ). Al termine del programma, la shell è ancora in esecuzione e riprende a funzionare, richiedendo il comando successivo.

Queste sono le principali eccezioni:

• I builtin della shell come cdnon creano affatto un nuovo processo, a meno che non vengano utilizzati in un costrutto che impiega una subshell ( spiegata qui ), come il ( )raggruppamento e le pipeline .
• Puoi dire alla shell di non attendere il completamento di un comando eseguendo il comando in modo asincrono . Puoi farlo terminando il comando con &. ( your-command arguments... &)
• È possibile utilizzare il controllo del lavoro per modificare il comando, se presente, la shell attende. Con la funzione disownintegrata , puoi staccare i lavori dal tuo terminale.

Anche se non considererei davvero questa un'eccezione ai processi figlio connessi allo stesso terminale del loro genitore, nota che un processo che esegui da una shell in un terminale non prenderà sempre input da quel terminale o invierà output a quel terminale :

• È possibile reindirizzare qualsiasi dei flussi standard con i <, >e >>gli operatori.
• È possibile reindirizzare l' output di un comando all'input di un altro con |.

Poiché il ttycomando controlla solo quale terminale è il suo input standard, puoi "ingannarlo":

ek@Io:~$ tty
/dev/pts/1
ek@Io:~$ tty </dev/pts/0
/dev/pts/0

O, meno subdolo:

ek@Io:~$ tty </dev/null  # not a terminal
not a tty
ek@Io:~$ tty <&-         # closes the input stream
not a tty