Il sistema Linux: kernel, processi, filesystem, servizi e device

Un sistema Linux moderno è composto da molti livelli. Capirli evita di trattare ogni problema come una sequenza di comandi da memorizzare: sappiamo invece quale componente osservare quando un servizio non parte, un processo consuma memoria, un filesystem si riempie o un’interfaccia di rete non compare.

Dal boot alle applicazioni

Firmware UEFI/BIOS
        |
        v
Bootloader
        |
        v
Kernel Linux + initramfs
        |
        v
PID 1 / init (spesso systemd)
        |
        +-- servizi
        +-- login
        +-- rete
        +-- mount
        +-- applicazioni

Il firmware inizializza l’hardware e carica il bootloader; questo carica kernel e initramfs. Il kernel monta il filesystem iniziale, rileva hardware e avvia il primo processo user-space, PID 1.

PID 1 e systemd

Su molte distribuzioni contemporanee PID 1 è systemd. Il suo compito non è soltanto “avviare i demoni”: gestisce dipendenze tra unità, mount, socket, timer, sessioni e stato dei servizi.

ps -p 1 -o pid,comm,args

systemctl --failed
systemctl status ssh
systemctl list-units --type=service

journalctl -b

Il fatto che systemd sia diffuso non significa che il kernel dipenda da esso: altre distribuzioni possono usare init differenti.

Processi e thread

Ogni programma in esecuzione vive come uno o più processi/thread. Il kernel assegna CPU, memoria, credenziali, file descriptor e priorità.

ps -eo pid,ppid,user,stat,%cpu,%mem,comm --sort=-%cpu | head

pstree -p

top
# oppure
htop

Il PPID mostra la relazione padre/figlio. Lo stato del processo aiuta a capire se sta eseguendo, dormendo, aspettando I/O o è diventato zombie.

Memoria virtuale

Ogni processo vede un proprio spazio di indirizzamento virtuale. Il kernel traduce gli indirizzi verso memoria fisica, gestisce cache, pagine condivise e swap.

free -h

vmstat 1

cat /proc/meminfo | head

pmap -x PID | tail

La RAM “used” non va interpretata come su un contatore elementare: Linux usa aggressivamente memoria libera per cache, liberandola quando un processo ne ha bisogno.

Filesystem: quasi tutto ha un nome nel namespace

La vecchia frase “in Unix tutto è un file” è utile come intuizione, ma non va presa letteralmente. Molte risorse vengono esposte attraverso il namespace dei file, ma un socket, un device, un processo e un normale file su disco hanno semantiche differenti.

findmnt

lsblk -f

df -hT

stat /etc/passwd

/proc e /sys: filesystem virtuali

/proc espone informazioni su processi e stato del kernel; /sys rappresenta dispositivi, driver e oggetti del kernel attraverso sysfs. Non sono normali directory persistenti su disco.

cat /proc/cpuinfo | head
cat /proc/uptime

ls /proc/$$

ls /sys/class/net
ls /sys/block

/dev e i device node

Dischi, terminali e molti altri dispositivi vengono rappresentati attraverso device node sotto /dev. Il kernel e udev gestiscono dinamicamente questi oggetti.

ls -l /dev/null
ls -l /dev/sda 2>/dev/null
ls -l /dev/tty

udevadm info /dev/sda 2>/dev/null | head

Il device node non contiene “i dati del disco” come un normale file: è un’interfaccia verso un driver del kernel.

Utenti, gruppi e credenziali

Ogni processo possiede UID, GID e gruppi supplementari. Queste identità alimentano i permessi tradizionali Unix e molte decisioni di sicurezza.

id
getent passwd "$USER"
getent group

ps -o pid,user,group,comm -p $$

I permessi sono approfonditi in Permessi Linux e home directory.

Networking

Il kernel gestisce interfacce, routing, neighbor table, socket e firewalling. Le applicazioni usano socket per comunicare attraverso lo stack di rete.

ip addr
ip route
ip neigh

ss -lntup

sysctl net.ipv4.ip_forward

Namespace e cgroup

Due tecnologie del kernel sono alla base di gran parte della containerizzazione moderna:

• namespace: isolano viste di processi, rete, mount, hostname e altre risorse;
• cgroup: organizzano processi e permettono controllo/contabilizzazione di CPU, memoria e altre risorse.

lsns

systemd-cgls

cat /proc/self/cgroup

Un container non è quindi una “macchina virtuale leggera” in senso stretto: condivide il kernel host e usa meccanismi di isolamento del kernel per costruire un ambiente separato.

Log e osservabilità

Processi, kernel e servizi producono eventi attraverso journal e syslog. Quando qualcosa non funziona, una delle prime domande dovrebbe essere “quale componente ha registrato il problema?”.

journalctl -b -p warning

journalctl -u nome-servizio

dmesg --level=err,warn

Per una trattazione completa: Logging su Linux: journald, rsyslog e log remoto.

Il modello mentale utile

Quando diagnostichiamo Linux conviene chiedersi a quale livello appartenga il sintomo:

• hardware/driver/kernel;
• storage/filesystem;
• rete;
• identità e permessi;
• servizio/systemd;
• applicazione;
• dipendenza esterna.

Questo approccio è molto più efficace del provare comandi casuali finché il sistema ricomincia a funzionare.