sessione tmux interrotta durante la disconnessione da ssh

Riepilogo : sto cercando di capire perché la mia sessione di tmux muore quando mi disconnetto da ssh

Dettagli :

Ho tmux installato su un sistema Arch Linux. Quando inizio una sessione di tmux posso staccarmi da essa e quindi ricollegarmi mentre la sessione ssh è attiva. Ma se finisco la mia sessione ssh, la sessione tmux viene uccisa.

So che questo non è il comportamento normale perché ho un altro sistema in cui la sessione tmux continua a funzionare anche se la sessione ssh è terminata e posso collegarmi alla sessione tmux dopo aver stabilito una nuova connessione ssh. Il sistema che presenta un problema e quello che funziona correttamente hanno configurazioni molto simili, quindi non sono sicuro di cosa controllare.

Sto eseguendo tmux versione 1.9a. Il sistema che ha un problema (per il quale ho accesso root) ha una versione del kernel Linux 3.17.4-1 e il sistema che funziona correttamente ha la versione 3.16.4-1-ARCH del kernel (non ho root su quello sistema). Dubito che la versione del kernel sia la fonte del problema, questa è solo una differenza che ho notato.

Ho pensato di chiedere se qualcuno avesse riscontrato un problema simile e fosse a conoscenza di una possibile soluzione.

I passaggi precisi che portano al problema sono:

1. ssh alla macchina
2. corri tmuxper avviare tmux
3. ctrl-B D per staccare (a questo punto potrei ricollegarmi con tmux attach
4. chiudi sessione ssh (a questo punto la sessione tmux viene interrotta, sono stato in grado di osservarlo quando ho effettuato l'accesso come root in un altro terminale)
5. riconnettersi con ssh ed eseguire tmux attache ottengo il messaggio no sessionse tmux lsritorna in esecuzione failed to connect to server: Connection refused. Questo ha senso perché il servizio non è in esecuzione. Ciò che non ha senso per me è il motivo per cui viene ucciso nel passaggio 4 quando mi disconnetto dalla sessione SSH.

dati strace:

In risposta a uno dei commenti ho usato strace per vedere quali sistemi chiama il processo del server tmux. Quando esco dalla mia sessione ssh (digitando exito con ctrl-d) sembra che il processo tmux venga interrotto. Ecco uno snippet della parte finale dell'output di 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 +++

Ho confrontato questo con un sistema diverso in cui tmux funziona correttamente e su quel sistema il processo tmux continua a funzionare anche dopo l'uscita. Quindi la causa principale sembra essere che il processo tmux si sta chiudendo quando chiudo la sessione ssh. Dovrò dedicare un po 'di tempo alla risoluzione dei problemi per capire perché, ma ho pensato di aggiornare la mia domanda poiché il suggerimento per lo strace era utile.

Teoria

Alcuni sistemi init, incluso systemd, forniscono una funzionalità per interrompere tutti i processi appartenenti al servizio. Il servizio in genere avvia un singolo processo che crea più processi mediante il fork e anche quei processi possono farlo. Tutti questi processi sono generalmente considerati parte del servizio. In systemd questo viene fatto usando cgroups .

In systemd, tutti i processi appartenenti a un servizio vengono interrotti quando il servizio viene arrestato per impostazione predefinita. Il server SSH fa ovviamente parte del servizio. Quando ci si connette al server, il server SSH in genere esegue il fork e il nuovo processo gestisce la sessione SSH. Effettuando il fork dal processo di sessione SSH o dai relativi figli, vengono avviati altri processi lato server, incluso lo schermo o tmux .

Killmode e attivazione socket

Il comportamento predefinito può essere modificato utilizzando la KillModedirettiva. Il progetto a monte non include AFAIK alcun .servicefile e quindi questi variano in base alla distribuzione. Esistono in genere due modi per abilitare SSH sul proprio sistema. Uno è il classico ssh.serviceche mantiene un demone SSH in esecuzione da lungo tempo in ascolto sulla rete. L'altro è tramite l'attivazione del socket gestita da quella ssh.socketche a sua volta inizia, sshd@.serviceche viene eseguita solo per una singola sessione SSH.

soluzioni

Se i tuoi processi vengono uccisi al termine della sessione, è possibile che tu stia utilizzando l'attivazione socket e viene ucciso da systemd quando nota che il processo della sessione SSH è terminato. In quel caso ci sono due soluzioni. Uno è di evitare di utilizzare l'attivazione tramite socket ssh.serviceinvece di ssh.socket. L'altro è quello di impostare KillMode=processnella Servicesezione di ssh@.service.

L' KillMode=processimpostazione può anche essere utile con il classico ssh.service, in quanto evita di uccidere il processo della sessione SSH o i processi di schermo o tmux quando il server viene arrestato o riavviato.

Note future

Questa risposta apparentemente ha guadagnato un livello di popolarità. Mentre ha funzionato per l'OP potrebbe accadere che in futuro non funzioni per qualcuno a causa dello sviluppo o della configurazione di systemd-logind . Controlla la documentazione sulle sessioni di logind se riscontri comportamenti diversi dalla descrizione in questa risposta.

Usi systemd con l'attivazione socket per SSH?

In tal caso, esiste un problema noto . Secondo i sostenitori di systemd, questa è in realtà una caratteristica: systemd uccide tutti i processi generati da una sessione al termine della sessione. (Posso vedere che è utile, ma nella GNU screen, o tmux, nel caso, sicuramente non lo vuoi ☺ né nella maggior parte degli altri casi in cui gli utenti possono eseguire processi in background, ovviamente.)

In tal caso, prova a passare da sshd.socketasshd.service .

Avevo lo stesso problema con tmux e schermo su Ubuntu 16.04 (kde neon). Quando la sessione ssh è stata disconnessa screen / tmux è stato terminato.

per farla breve, systemd ha modificato le impostazioni predefinite in killuserprocess = yes, quindi dopo aver lasciato una sessione ssh ogni processo creato da essa verrà terminato.

Correzione semplice (dopo ore di tentativi) esegui screen / tmux usando questo comando

Per lo schermo

systemd-run --scope --user screen

per Tmux

systemd-run --scope --user tmux

Puoi creare un alias per renderlo più semplice

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

Un'altra soluzione a questo, che non richiede il passaggio da sshd.socketa sshd.service, è avviare il tmuxserver come un servizio systemd [0]. In questo modo, il tmuxserver è già in esecuzione quando si SSH nel server, anziché generato dal tmuxcomando in SSH, quindi non verrà ucciso.

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

La migliore risposta che ho trovato, IMO, è data da Impedisci la disconnessione da Killing tmux Session :

Questa "funzionalità" esisteva in systemdprecedenza, ma gli systemdsviluppatori hanno deciso di effettuare una modifica del valore predefinito , per consentire l'impostazione per la terminazione dei processi figlio al logout di una sessione.

Puoi ripristinare questa impostazione nel tuo logind.conf( /etc/systemd/logind.conf):

KillUserProcesses=no