O sudo su cria um terminal filho?

Question

Foi o que aconteceu quando executei sudo su seguido por exit

$ sudo su
# exit
exit
$ 

O comando de saída não fecha meu emulador de terminal.

É um terminal infantil?

    

Answer 1

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

Executar exit (ou Ctrl + D ) sairá do shell recém-criado e retornará ao seu shell anterior.

1. Ponto de partida - o bash shell 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 de sudo su cria 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 de sudo su e retornando ao ponto inicial - 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
   $
   

Answer 2

Mesmo terminal, shell diferente.

Processos filho executados a partir de um shell, incluindo shells filho, usam o mesmo terminal automaticamente. Isso não é específico para sudo de qualquer forma - geralmente é assim que funciona quando você executa qualquer programa do seu shell.

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

Mesmo que seu terminal seja (provavelmente!) emulado , não físico , no entanto sistemas operacionais semelhantes ao Unix como o Ubuntu atribui nós de dispositivos para cada um dos seus terminais, e você pode verificar qual terminal está usando com o comando tty . Geralmente, serão /dev/pts/0 , /dev/pts/1 , /dev/pts/2 , etc. , para uma janela do terminal ou conexão SSH , ou /dev/tty1 , /dev/tty2 , etc. , para consoles virtuais . Realmente o que o tty faz é informar qual terminal, se houver, entrada está sendo tirado de; 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 isso, mesmo que sudo su crie um novo shell como o Yaron explica muito bem , o terminal que você está usando não muda.

Claro, há outra maneira de observar que o terminal é o mesmo: você ainda está escrevendo a entrada 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 executados em um shell - como ls , cp , mv , rm , touch , wc , du , df , ssh , su , sudo , sh , bash e muitos mais - causa um child process a ser criado. Este processo filho tem seu shell como pai, mas é um programa separado. Por padrão, ele está conectado ao terminal same como seu shell.

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

Estas são as principais exceções:

• Construções de shell como cd não criam um novo processo em todos, a menos que sejam usados em um constructo que empregue um subshell ( explicado aqui ), como ( ) grouping e oleodutos .
• Você pode dizer ao shell para não esperar que um comando seja completado por executando o comando de forma assíncrona . Você faz isso finalizando o comando com & . ( your-command arguments... & )
• Você pode usar o controle de trabalho para alterar o comando, se houver, o shell aguarda. Com o o disown builtin , você pode separar os trabalhos do seu terminal .

Embora eu realmente não considere isso uma exceção a processos filhos conectados ao mesmo terminal que seus pais, note que um processo que você executa a partir de um shell em um terminal não sempre estará entrada desse terminal ou envio de saída para esse terminal:

• Você pode redirecionar qualquer um dos transformações padrão com os operadores < , > e >> .
• Você pode canalizar um comando output para a entrada de outra pessoa com | .

Como o comando tty só verifica 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 deviously:

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