Foi o que aconteceu quando eu executei, sudo suseguido porexit

$ sudo su
# exit
exit
$ 

O comando exit não fecha meu emulador de terminal.

É um terminal infantil?

Depois de executar sudo suou um novo shell está sendo criado.su user

A execução exit(ou Ctrl+ D) sairá do novo shell de criação e retornará ao seu shell anterior.

1. Ponto de partida - o shell bash está sendo executado no PID 25050:

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

2. A execução sudo sucria um novo processo bash que está sendo executado no 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. Saindo sudo sue retornando ao ponto de partida - o bash shell está sendo executado no PID 25050:

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

Mesmo terminal, concha diferente.

Os processos filho executados a partir de um shell, incluindo as conchas filho, usam o mesmo terminal automaticamente. Isso não é específico de sudoforma alguma - geralmente é assim que funciona quando você executa qualquer programa do seu shell.

Conchas e terminais são coisas diferentes. Um shell é o que você usa para executar comandos em um terminal . Um shell pode operar interativamente - ele fornece um prompt, um comando, executa o comando ou mostra um erro sobre o motivo pelo qual não pode, e o processo se repete até que você saia do shell. Ou pode operar de maneira não interativa, executando um script .

Mesmo que o seu terminal seja (provavelmente!) Emulado , não sistemas operacionais físicos , como o Unix, como o Ubuntu, atribuem nós de dispositivo a cada um dos seus terminais, e você pode verificar qual terminal está usando com o ttycomando Normalmente, será /dev/pts/0, /dev/pts/1, /dev/pts/2, etc. , para uma janela de terminal ou conexão SSH , ou /dev/tty1, /dev/tty2, etc. , para consoles virtuais . Realmente, o que ttyfaz é dizer a você de qual terminal, se houver, a entrada está sendo retirada; veja abaixo para detalhes.

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:~$

Você pode ver que, apesar de sudo sucriar um novo shell como Yaron explica muito bem , o terminal que você está usando não muda.

Obviamente, há outra maneira de observar que o terminal é o mesmo: você continua escrevendo as entradas da mesma maneira e no mesmo lugar e lendo a saída da mesma maneira e no mesmo lugar.

Alguns detalhes técnicos

A maioria dos comandos é executado em um shell - como ls, cp, mv, rm, touch, wc, du, df, ssh, su, sudo, sh, bash, e muitos mais - causar um processo filho para ser criado. Esse processo filho tem seu shell como pai, mas é um programa separado. Por padrão, ele está conectado ao mesmo terminal que seu shell.

Seu shell ainda está em execução, mas aguarda em segundo plano o programa terminar (ou você suspendê-lo ). Quando o programa termina, o shell ainda está em execução e retoma a operação, solicitando seu próximo comando.

Estas são as principais exceções:

• Os componentes internos do shell, como cdnão criam um novo processo, a menos que sejam usados ​​em uma construção que emprega um subshell ( explicado aqui ), como ( )agrupamentos e pipelines .
• Você pode dizer ao shell para não esperar a conclusão de um comando executando o comando de forma assíncrona . Você faz isso finalizando o comando com &. ( your-command arguments... &)
• Você pode usar o controle de tarefas para alterar qual comando, se houver, o shell aguarda. Com o disownbuilt-in , você pode destacar trabalhos do seu terminal.

Embora eu realmente não considere isso uma exceção para os processos filhos serem conectados ao mesmo terminal que o pai, observe que um processo executado a partir de um shell em um terminal nem sempre estará recebendo entrada desse terminal ou enviando saída para esse terminal :

• Você pode redirecionar qualquer um dos fluxos padrão com as <, >e >>operadores.
• Você pode canalizar a saída de um comando para a entrada de outro com |.

Como o ttycomando verifica apenas qual terminal é sua entrada padrão, você pode "enganá-lo":

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

Ou, menos desonestamente:

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