Sessão tmux interrompida ao desconectar do ssh

Resumo : Estou tentando descobrir por que minha sessão tmux morre quando eu me desconecto do ssh

Detalhes :

Eu tenho o tmux instalado em um sistema Arch Linux. Quando inicio uma sessão tmux, posso desanexá-la e, em seguida, conectar novamente enquanto a sessão ssh está ativa. Mas se eu terminar minha sessão ssh, a sessão tmux será encerrada.

Sei que esse não é o comportamento normal, porque tenho outro sistema em que a sessão tmux continua em execução, mesmo que a sessão ssh termine e posso anexar à sessão tmux após estabelecer uma nova conexão ssh. O sistema que tem um problema e o que funciona corretamente têm configurações muito semelhantes, então não tenho certeza do que verificar.

Estou executando o tmux versão 1.9a. O sistema que tem um problema (para o qual eu tenho acesso root) possui uma versão do kernel Linux 3.17.4-1 e o sistema que funciona corretamente possui a versão 3.16.4-1-ARCH do kernel (não tenho raiz nesse sistema). Duvido que a versão do kernel seja a fonte do problema, essa é apenas uma diferença que notei.

Eu pensei em pedir para ver se alguém viu um problema semelhante e sabe de uma possível solução.

As etapas precisas que levam ao problema são:

1. ssh para maquinar
2. corra tmuxpara iniciar o tmux
3. ctrl-B D para desconectar (nesse ponto eu poderia reconectar com tmux attach
4. close ssh session (neste ponto a sessão do tmux está encerrada, eu pude observar isso quando estou logado como root em um terminal diferente)
5. reconectar com ssh e executar tmux attache eu recebo a mensagem no sessionse executando tmux lsretornos failed to connect to server: Connection refused. Isso faz sentido porque o serviço não está sendo executado. O que não faz sentido para mim é o motivo pelo qual ele é morto na etapa 4 quando eu me desconecto da sessão ssh.

dados de rastreamento:

Em resposta a um dos comentários, usei o strace para ver o que os sistemas chamam o processo do servidor tmux. Parece que, quando saio da minha sessão ssh (digitando exitou com ctrl-d), o processo tmux está sendo morto. Aqui está um trecho da parte final da saída do strace.

poll([{fd=4, events=POLLIN}, {fd=11, events=POLLIN}, {fd=6, events=POLLIN}], 3, 424) = ? ERESTART_RESTARTBLOCK (Interrupted by signal)
--- SIGTERM {si_signo=SIGTERM, si_code=SI_USER, si_pid=1, si_uid=0} ---
sendto(3, "\17", 1, 0, NULL, 0)         = 1
+++ killed by SIGKILL +++

Comparei isso com um sistema diferente, onde o tmux funciona corretamente e, nesse sistema, o processo do tmux continua em execução, mesmo depois que eu saio. Portanto, a causa raiz parece ser que o processo tmux está sendo finalizado quando eu fecho a sessão ssh. Precisarei dedicar algum tempo para solucionar isso para descobrir o porquê, mas pensei em atualizar minha pergunta, pois a sugestão do strace era útil.

Teoria

Alguns sistemas init, incluindo systemd, fornecem um recurso para eliminar todos os processos pertencentes ao serviço. O serviço normalmente inicia um único processo que cria mais processos de bifurcação e esses processos também podem fazer isso. Todos esses processos são geralmente considerados parte do serviço. No systemd, isso é feito usando cgroups .

No systemd, todos os processos pertencentes a um serviço são interrompidos quando o serviço é parado por padrão. O servidor SSH obviamente faz parte do serviço. Quando você se conecta ao servidor, o servidor SSH normalmente se bifurca e o novo processo manipula sua sessão SSH. Bifurcando-se no processo da sessão SSH ou em seus filhos, outros processos do lado do servidor são iniciados, incluindo sua tela ou tmux .

Ativação do modo Kill e soquete

O comportamento padrão pode ser alterado usando a KillModediretiva. O projeto upstream não inclui nenhum .servicearquivo do AFAIK e, portanto, esses variam de acordo com a distribuição. Normalmente, existem duas maneiras de ativar o SSH no seu sistema. Um é o clássico ssh.serviceque mantém um daemon SSH de execução longa escutando na rede. A outra é através da ativação do soquete manipulada pelo ssh.socketque, por sua vez, inicia, [email protected]que é executado apenas para uma única sessão SSH.

Soluções

Se seus processos forem interrompidos no final da sessão, é possível que você esteja usando a ativação do soquete e ela será interrompida pelo systemd quando perceber que o processo da sessão SSH terminou. Nesse caso, existem duas soluções. Uma é evitar usar a ativação do soquete usando em ssh.servicevez de ssh.socket. O outro é para definir KillMode=processna Serviceseção de [email protected].

A KillMode=processconfiguração também pode ser útil com o clássico ssh.service, pois evita a interrupção do processo da sessão SSH ou da tela ou do tmux quando o servidor é parado ou reiniciado.

Notas futuras

Aparentemente, essa resposta ganhou um nível de popularidade. Enquanto funcionava para o OP, pode acontecer que não funcione para alguém no futuro devido ao desenvolvimento ou configuração do systemd-logind . Por favor, verifique a documentação nas sessões de logind se você tiver um comportamento diferente da descrição nesta resposta.

Você usa systemd com ativação de soquete para SSH?

Nesse caso, há um problema conhecido com isso . De acordo com os proponentes do systemd, esse é realmente um recurso - o systemd mata todos os processos gerados por uma sessão quando ela termina. (Percebo que isso é útil, mas no GNU screen, ou tmux, no caso, você definitivamente não quer isso, nem na maioria dos outros casos em que os usuários podem executar processos em segundo plano, é claro).

Nesse caso, tente alternar de sshd.socketparasshd.service .

Eu estava tendo o mesmo problema com o tmux e a tela no Ubuntu 16.04 (kde neon). Quando a sessão ssh foi desconectada, o / tmux foi encerrado.

Para encurtar a história, systemd alterou sua configuração padrão para killuserprocess = yes, portanto, após sair de uma sessão ssh, todos os processos criados por ela serão encerrados.

Correção fácil (após horas de tentativa) execute screen / tmux usando este comando

Para tela

systemd-run --scope --user screen

para Tmux

systemd-run --scope --user tmux

Você pode criar um alias para facilitar

alias tmux= "systemd-run --scope --user tmux"

Outra solução para isso, que não requer mudança de sshd.socketpara sshd.service, é iniciar o tmuxservidor como um serviço systemd [0]. Dessa forma, o tmuxservidor já estará em execução quando você fizer o SSH no servidor, em vez de gerar o tmuxcomando no SSH, portanto, não será eliminado.

[0] https://wiki.archlinux.org/index.php/tmux#Autostart_with_systemd

A melhor resposta que encontrei, IMO, é dada em Prevent Logoff from Killing tmux Session :

Esse "recurso" já existia systemdanteriormente, mas os systemddesenvolvedores decidiram efetuar uma alteração no padrão , para habilitar a configuração para o término dos processos filhos ao sair de uma sessão.

Você pode reverter essa configuração em seu logind.conf( /etc/systemd/logind.conf):

KillUserProcesses=no