2. Un processo è un'istanza di un programma in esecuzione

Un processo è un'istanza di un programma in esecuzione creato e gestito direttamente dal kernel Linux: nasce quando il kernel Linux carica un file eseguibile in memoria e ne avvia l’esecuzione. Quando un comando viene eseguito, il kernel crea un processo assegnandogli un identificativo univoco (PID), le risorse necessarie (CPU, memoria, I/O) e uno stato di esecuzione.

Sistema di init

Il sistema di init è il primo programma avviato dal kernel Linux ed è sempre il processo con PID 1 e viene eseguito con privilegi di root. Il processo con PID 1 è il primo processo creato dal kernel Linux durante l’avvio del sistema e da questo processo derivano, direttamente o indirettamente, tutti gli altri processi. Il suo compito principale è avviare e gestire tutti i servizi necessari al funzionamento del sistema operativo, come la rete, l’accesso remoto, il logging e molti altri servizi di base. Il processo con PID 1 ha un ruolo speciale: è responsabile della gestione dei processi orfani e della corretta terminazione dei servizi durante le fasi di shutdown e riavvio del sistema.

Nei sistemi Linux moderni il processo con PID 1 è solitamente systemd che si occupa di avviare e gestire i servizi di sistema. systemd è sviluppato da Red Hat ed è adottato dalla maggior parte delle distribuzioni Linux moderne. Oltre all’avvio dei servizi, ne monitora lo stato e ne gestisce il ciclo di vita.

Le principali funzionalità di systemd includono:

• avvio rapido e parallelo dei servizi
• gestione dei servizi tramite il comando systemctl
• consultazione dei log di sistema tramite journalctl

Per questi motivi systemd è oggi considerato lo standard de facto nel mondo Linux.

Sebbene systemd sia il sistema di init più diffuso esistono anche delle alternative spesso utilizzate in contesti specifici o in distribuzioni particolarmente leggere:

• SysVinit = Il sistema di init storico di Linux, basato su script di avvio sequenziali. Oggi è in gran parte superato.
• Upstart = Sviluppato inizialmente da Ubuntu, è stato progressivamente abbandonato in favore di systemd.
• OpenRC = Un sistema di init semplice e leggero, utilizzato ad esempio in Gentoo e Alpine Linux.
• runit = Un init minimale e molto veloce, adottato in alcune distribuzioni orientate alla semplicità.

In un sistema Linux tradizionale il processo con PID 1 è systemd che riceve i segnali dal kernel e si occupa di terminare correttamente i servizi e i processi in esecuzione. Nei container, invece, non viene avviato un vero sistema di init. Il kernel assegna il PID 1 direttamente al processo principale del container ovvero all’applicazione che viene eseguita. Questo significa che l’applicazione non è soltanto un normale processo ma assume anche il ruolo di init all’interno del container.

Quando il container deve essere fermato il runtime invia un segnale di terminazione (tipicamente SIGTERM) al processo con PID 1. Se l’applicazione gestisce correttamente questo segnale il container termina in modo ordinato. Se invece il processo con PID 1 ignora i segnali il container non si arresta correttamente e dopo un timeout viene terminato forzatamente con SIGKILL. Per questo motivo nei container è fondamentale che il processo principale sia in grado di gestire correttamente i segnali inviati dal kernel.

Comando top

top è un comando che permette di visualizzare in tempo reale i processi in esecuzione sul sistema e il loro consumo di risorse. Ogni riga rappresenta un processo gestito dal kernel.

Le colonne principali del comando top:

• PID = identificativo univoco del processo (Process ID) assegnato dal kernel
• USER = utente che ha avviato il processo
• PR = priorità del processo (valore più basso = priorità più alta)
• NI = valore “nice” che modifica la priorità (da -20 più prioritario a +19 meno prioritario)
• VIRT = memoria virtuale totale usata dal processo
• RES = memoria RAM reale utilizzata dal processo
• SHR = memoria condivisa con altri processi
• S = stato del processo (R=running, S=sleeping, D=I/O, Z=zombie, T=stopped)
• %CPU = percentuale di CPU utilizzata dal processo
• %MEM = percentuale di RAM utilizzata dal processo
• TIME+ = tempo totale di CPU consumato dal processo
• COMMAND = nome del comando o programma in esecuzione

L’interazione avviene tramite tasti rapidi che permettono di ordinare, filtrare e visualizzare le informazioni più rilevanti:

• Premi t per mostrare o nascondere il grafico della CPU
• Premi m per mostrare o nascondere il grafico dell’uso della memoria
• Premi P per ordinare i processi per utilizzo della CPU
• Premi M per ordinare i processi per utilizzo della memoria
• Premi T per ordinare i processi per tempo di CPU consumato
• Premi c per visualizzare il comando completo invece del solo nome
• Premi u e inserisci il nome utente per mostrare solo i processi di un utente specifico
• Premi k per inviare un segnale kill a un processo indicando il PID
• Premi q per uscire da top

Comando htop

htop è un monitor dei processi interattivo simile a top ma più comodo da usare. Mostra in tempo reale i processi in esecuzione e consente di ordinare, filtrare e gestire i processi tramite tastiera (e spesso anche con il mouse).

• Premi F5 per attivare la Tree View (vista ad albero)
• Premi F3 e cerca NOME_PROCESSO (esempio: stress) per visualizzare solo i processi interessati
• Premi F2 -> Setup -> Display options per migliorare la leggibilità:
  • Setup → Display options
  • Tree View (se non attiva)
  • Show custom thread names
  • Highlight program path
• Premi F9 per terminare un processo: seleziona un processo e invia un segnale (es. SIGTERM o SIGKILL)
• Premi il tasto q oppure F10 per terminare il programma htop

A differenza di top, htop supporta l’uso del mouse. È possibile cliccare sui nomi delle colonne per ordinare i processi in base al valore selezionato (CPU, memoria, PID, tempo, ecc.). Cliccando più volte sulla stessa colonna è possibile invertire l’ordine di ordinamento (crescente o decrescente).

Comando ps

ps aux è uno dei comandi più usati su Linux per vedere tutti i processi in esecuzione sul sistema ed elenca i processi che il kernel rende visibili all’ambiente corrente. In alternativa eseguire il comando ps -elf.

frank@laptop01:~$ ps aux | grep bash
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
frank       7311  0.0  0.0 233608  5800 pts/1    Ss  08:49   0:00 /bin/bash
frank       7874  0.0  0.0 233608  5792 pts/3    Ss  08:57   0:00 /bin/bash
root        8520  0.0  0.1 246544 10496 pts/1    S+  09:07   0:00 sudo unshare --pid --fork --mount-proc bash
root        8554  0.0  0.0 246544  3028 pts/2    Ss  09:07   0:00 sudo unshare --pid --fork --mount-proc bash
root        8555  0.0  0.0 230368  2108 pts/2    S   09:07   0:00 unshare --pid --fork --mount-proc bash
root        8556 0.0  0.0 233464  5784 pts/2    S+  09:07   0:00 bash
frank       8728  0.0  0.0 231292  2644 pts/3    S+  09:10   0:00 grep --color=auto bash

Le colonne mostrate dall’output di ps aux hanno il seguente significato:

• USER = utente proprietario del processo
• PID = identificativo univoco del processo
• >%CPU = percentuale di CPU utilizzata
• %MEM = percentuale di memoria RAM utilizzata
• VSZ = memoria virtuale allocata dal processo
• RSS = memoria fisica realmente occupata
• TTY = terminale associato al processo
• STAT = stato del processo
• START = orario di avvio del processo
• TIME = tempo totale di CPU consumato
• COMMAND = comando che ha avviato il processo

Nel comando ps aux la colonna STAT indica lo stato del processo ed è composta da una lettera principale (stato) più eventuali simboli aggiuntivi:

• R = (Running) processo in esecuzione
• S = (Sleeping) processo in attesa (stato normale)
• D = Attesa I/O non interrompibile
• T = Stoppato
• Z = Zombie

Si aggiungono simboli aggiuntivi come:

• s = Session leader
• + = Processo in foreground (terminale attivo)

Alcuni esempi di visualizzazione:

• Ss = processo in attesa ed è session leader
• S+ = processo in attesa in foreground
• Ss+ = processo in attesa, session leader e in foreground

Comando kill

Il comando kill permette di inviare un segnale a un processo generalmente per terminarne l’esecuzione e il processo viene identificato tramite il suo PID.

$ kill PID

Il segnale predefinito è SIGTERM che consente al processo di terminare correttamente. In caso di processi bloccati è possibile usare SIGKILL per forzarne la chiusura.

• SIGTERM (15) → terminazione gentile del processo (segnale predefinito)

  $ kill 1234

• SIGKILL (9) → terminazione forzata e immediata del processo

  $ kill -9 1234

• SIGSTOP (19) → sospende l’esecuzione del processo

  $ kill -STOP 1234

• SIGCONT (18) → riprende l’esecuzione di un processo sospeso

  $ kill -CONT 1234

Comando pgrep

Il comando pgrep permette di cercare i processi in esecuzione in base al nome o ad altri criteri e di ottenere direttamente il loro PID. È particolarmente utile in combinazione con il comando kill.

ps aux | grep e pgrep permettono entrambi di individuare processi in esecuzione. pgrep è più semplice e diretto quando serve ottenere il PID mentre ps aux | grep fornisce una vista più dettagliata del processo.

Cercare il PID di un processo in base al nome:

$ pgrep stress

Mostrare anche il nome del processo:

$ pgrep -l stress

Trovare i processi di un utente specifico:

$ pgrep -u frank

Terminare un processo combinando pgrep e kill:

$ kill $(pgrep stress)

In questo modo non è necessario conoscere il PID in anticipo: il processo viene individuato automaticamente in base al nome.

La directory /proc

La directory /proc è un filesystem virtuale creato dal kernel Linux. Non contiene file reali su disco: espone invece informazioni aggiornate in tempo reale su processi e stato del sistema.

All’interno di /proc ogni processo in esecuzione ha una directory dedicata con nome numerico che corrisponde al suo PID. Ad esempio, il processo con PID 1234 è rappresentato da /proc/1234.

Molti comandi di monitoraggio come ps, top e htop ottengono i dati proprio da /proc rendendolo una delle principali fonti di informazioni sui processi in Linux.

I Jobs

I jobs sono i processi avviati e gestiti direttamente dalla shell corrente. Quando un comando viene eseguito in background o sospeso, la shell lo registra come job e ne mantiene il controllo finché la sessione rimane attiva.

Quando parliamo di jobs parliamo di un concetto legato alla shell non al kernel Linux. Un job è un processo (o gruppo di processi) che la shell tiene traccia e gestisce durante una sessione interattiva.

Il kernel conosce solo i processi e i loro PID mentre la shell aggiunge un livello di gestione in più introducendo i job e assegnando loro un job ID.

I job esistono solo finché la shell è attiva e possono essere controllati tramite i comandi jobs, fg, bg e kill. Una volta chiusa la shell i job vengono terminati o persi.

Esempio pratico del comando jobs Avviamo un comando in background usando &:

frank@laptop01:~$ sleep 60 &
[1] 12345

Il numero [1] è l’ID del job mentre 12345 è il PID del processo.

Visualizziamo i job gestiti dalla shell corrente:

frank@laptop01:~$ jobs
[1]+  Running                 sleep 60 &

Avviamo ora un comando in foreground:

frank@laptop01:~$ sleep 100

Premiamo Ctrl+Z per sospenderlo:

^Z
[2]+  Stopped                 sleep 100

Mostriamo di nuovo i job:

frank@laptop01:~$ jobs
[1]-  Running                 sleep 60 &
[2]+  Stopped                 sleep 100

Riprendiamo il job sospeso in background:

frank@laptop01:~$ bg %2

Oppure riportiamolo in foreground:

frank@laptop01:~$ fg %2

Il comando jobs mostra solo i processi avviati e controllati dalla shell corrente non tutti i processi del sistema.