GNU/Linux >> Linux Esercitazione > >> Linux

Comando Killall in Linux con esempi

La riga di comando di Linux offre vari comandi per terminare un processo. Ad esempio, il comando 'kill' può essere utilizzato per terminare un processo passando il suo PID come argomento, il comando 'pkill' accetta un pattern come input e tutti i processi in esecuzione corrispondenti vengono uccisi. Ma esiste un comando 'killall', che corrisponde esattamente al nome dell'argomento per impostazione predefinita, e termina il processo di corrispondenza.

In questo articolo, discuteremo questo comando con alcuni esempi pratici. Il comando killall può essere utilizzato per inviare un segnale a un particolare processo usando il suo nome. Significa che se hai cinque versioni dello stesso programma in esecuzione, il comando killall li ucciderà tutti e cinque.

Il segnale può essere specificato come argomento di questo comando oppure SIGTERM viene inviato per impostazione predefinita. Un processo può generare processi figlio che sono indipendenti dal processo padre, significa che ogni sottoprocesso si identifica tramite il suo pid. Con il comando kill, utilizziamo il pid per selezionare il sottoprocesso da uccidere ma con il comando killall, indicando il nome, poiché tutti i sottoprocessi e il processo padre hanno lo stesso nome, tutti i processi verranno uccisi.

Discutiamo l'uso del comando killall attraverso alcuni esempi pratici.

1) Elenca tutti i segnali supportati

Il comando Kill supporta alcuni segnali che possono essere elencati con -l opzione. killall invia segnali ai processi. Puoi usare i -s opzione (seguita dal nome del segnale) per inviare un segnale particolare a un processo.

$ killall -l
 HUP INT QUIT ILL TRAP ABRT IOT BUS FPE KILL USR1 SEGV USR2 PIPE ALRM TERM
 STKFLT CHLD CONT STOP TSTP TTIN TTOU URG XCPU XFSZ VTALRM PROF WINCH IO PWR SYS
 UNUSED

Per impostazione predefinita SIGTERM/TERM (15) viene inviato al processo, in caso contrario viene dato il segnale al comando killall. I segnali di cui sopra sono utilmente utilizzati sia dagli utenti che dagli amministratori di sistema. Quindi killall supporta tutti questi segnali.

2) Uccidi un processo particolare

Per terminare un processo dobbiamo identificarlo per verificare se è in esecuzione. Possiamo uccidere un particolare processo con il suo nome. Supponiamo che ci siano due processi che hanno gli stessi caratteri iniziali :

$ ps -aef | grep "test"
 himanshu 3969 2811 0 14:14 pts/0 00:00:00 ./test
 himanshu 3970 2811 0 14:14 pts/0 00:00:00 ./test_again

Ora, ecco come puoi usare il comando killall per uccidere 'test_again' :

$ killall test_again
 [2]+ Terminated ./test_again

Come puoi vedere, il comando killall ha terminato il processo 'test_again'. Questo può essere confermato anche tramite il comando ps :

$ ps -aef | grep "test"
 himanshu 3969 2811 0 14:14 pts/0 00:00:00 ./test

Osserva che 'test_again' non viene visualizzato nell'output mentre viene terminato.

3) Termina un processo ignorando il caso

Il comando killall fa distinzione tra maiuscole e minuscole per impostazione predefinita. Ecco un esempio :

$ ps -aef | grep "test"
 himanshu 4177 3161 0 14:54 pts/3 00:00:00 ./test
 himanshu 4178 3161 0 14:54 pts/3 00:00:00 ./test_again
 himanshu 4180 3161 0 14:54 pts/3 00:00:00 grep --color=auto test

puoi vedere che tutti i nostri processi sono in minuscolo. proviamo a terminare il processo "./test" ma inseriamo il nome in maiuscolo

$ killall TEST
 TEST: no process found

Quindi puoi vedere che il comando killall non è riuscito a trovare alcun processo chiamato TEST, mentre un processo chiamato 'test' è già in esecuzione. Per assicurarti che il comando killall ignori il caso, usa -I opzione. Ecco un esempio :

$ killall -I TEST
 [1]- Terminated ./test

Osserva che ora ha terminato con successo il processo di 'test'.

4) Termina i processi con conferma

Il comando killall può essere usato per uccidere più di processare.

$ killall test test_again
 [2]- Terminated ./test_again
 [3]+ Terminated ./test

Ma può capitare di commettere un errore quando si inserisce il nome del processo indicando un altro nome. Può essere un problema serio se il processo indicato è un processo critico per il sistema. Quindi si consiglia di utilizzare killall per terminare i processi in modo interattivo chiedendo una conferma. Per farlo, puoi usare il -i opzione.

$ killall -i test test_again
 Kill test(4201) ? (y/N) y
 Kill test_again(4202) ? (y/N) y
 [1]- Terminated ./test
 [2]+ Terminated ./test_again

Quindi puoi vedere che in questo modo l'utente può controllare la terminazione dei processi usando il comando killall.

5) Termina il processo in silenzio

A volte, quando killall non è in grado di trovare un processo specifico, si lamenta dello stesso nell'output.

Ecco un esempio:

$ killall TEST
 TEST: no process found

Ma, se vuoi che killall svolga il suo lavoro in silenzio, puoi usare il -q opzione:

$ killall -q TEST
$

Quindi puoi vedere che quando è stato utilizzato -q, l'output è stato soppresso.

6) Uno strano risultato del comando killall

La pagina man del comando killall dice che per impostazione predefinita, trova nomi completi solo se sono lunghi o uguali a 15 caratteri. Pertanto, se il nome di un comando è più lungo di 15 caratteri, il nome completo potrebbe non essere disponibile (ovvero è stato sostituito). In questo caso, killall ucciderà tutto ciò che corrisponde entro i primi 15 caratteri.

Ad esempio, supponiamo che ci siano due processi seguenti con nomi lunghi:

$ ps -aef | grep "test"
 himanshu 4021 3161 0 14:27 pts/3 00:00:00 ./test_abcdefghij
 himanshu 4035 3161 0 14:27 pts/3 00:00:00 ./test_abcdefgh

Il primo processo nell'output sopra ha esattamente 15 caratteri nel nome. Proviamo a ucciderlo usando il comando killall :

$ killall test_abcdefghij
 [1]- Terminated ./test_abcdefghij

Quindi puoi vedere che il comando killall termina il processo con successo.

Ora, secondo la pagina man, se entrambi i nomi avessero avuto più di 15 caratteri corrispondenti, killall avrebbe terminato i processi in cui il nome è seguito da -e opzione o ucciderà tutto ciò che corrisponde entro i primi 15 caratteri. Ecco un esempio :

$ ps -aef | grep "test"
 himanshu 4114 3161 0 14:40 pts/3 00:00:00 ./test_abcdefghijklmnopqrstuvwx
 himanshu 4141 3161 0 14:46 pts/3 00:00:00 ./test_abcdefghijklmnopqrstuvwxyz
 himanshu 4143 3161 0 14:46 pts/3 00:00:00 grep --color=auto test

Osserva che entrambi i processi ora hanno più di 15 caratteri corrispondenti nel loro nome. Ora, quando ho provato a uccidere il secondo processo usando killall :

$ killall test_abcdefghijklmnopqrstuvwxyz
 [6]+ Terminated ./test_abcdefghijklmnopqrstuvwxyz

Ha ucciso solo il processo specificato e non anche il secondo processo

$ ps -aef | grep "test"
 himanshu 4114 3161 0 14:40 pts/3 00:00:00 ./test_abcdefghijklmnopqrstuvwx
 himanshu 4146 3161 0 14:47 pts/3 00:00:00 grep --color=auto test

Non sono sicuro se c'è qualcosa di sbagliato dalla mia parte, o è un bug nel comando killall. Ti sarei grato se esprimessi le tue opinioni in merito nei commenti.

A proposito, ecco i dettagli del comando killall sul mio sistema:

$ killall --version
killall (PSmisc) 22.20
Copyright (C) 1993-2012 Werner Almesberger and Craig Small

PSmisc comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it under
the terms of the GNU General Public License.
For more information about these matters, see the files named COPYING.

Conclusione

Da Centos 7, incoraggia a eseguire pkill invece di killall, quindi per impostazione predefinita potresti ricevere l'errore "killall:comando non trovato" quando esegui il comando. Se lo desideri ancora, installa pkill aggiungendo il pacchetto psmisc (# yum install psmisc).

Killall è utile perché possiamo uccidere un processo con il suo nome anche se non riusciamo a ricordare il suo pid. Non ha alcune opzioni perché è relativamente semplice da usare.