Linux e Unix

Unix è un sistema operativo, nato nel 1969 presso i Bell Labs ad opera di Dennis Ritchie, Ken Thompson, Brian Kernghan ed altri programmatori.

Inizialmente chiunque fosse interessato e possedesse l'hardware occorrente, poteva chiedere ad un costo irrisorio un nastro del software ed i relativi manuali stampati. Questo accadeva prima dell'avvento dei personal computer, pertanto si trattava in genere di università e centri di ricerca.

I singoli e i centri potevano modificare il codice sorgente ampliando e personalizzando il sistema in base alle loro necessità.

Una tappa importante è stata raggiunta alla fine degli anni '70 con la realizzazione della versione BSD (Berkley System Distribution) ad opera di alcuni esperti di informatica dell'Università della California di Berkeley, che apportarono diverse migliorie; la più importante fu l'adozione del protocollo TCP/IP.

Il codice sorgente venne reso pubblicamente disponibile con una licenza che ne consentiva la distribuzione con o senza codice sorgente, a condizione che queste parti del codice venissero ascritte a Berkeley.

La popolarità di Unix aumentò con il trascorrere degli anni. La Berkeley cedette ad AT&T i diritti sul software e Unix divenne un prodotto commerciale, che aveva un costo elevato anche per licenze accademiche ed il codice sorgente non era incluso.

Anche acquistando separatamente una copia dei sorgenti, non era più possibile modificare il codice sorgente e condividere le migliorie apportate con altri programmatori. Altre società commerciali adottarono la modalità di distribuzione del software senza sorgenti, copiando la formula di successo di Unix commerciale e proponendo un nuovo modello di sviluppo proprietario.

Nel 1984 Richard Stallman, invece di cedere a questa tendenza, decise di dare vita ad un nuovo sistema operativo di tipo Unix il cui codice sorgente potesse essere liberamente copiato e modificato.

Nacque il progetto GNU (GNU is Not Unix). GNU significa GNU's Not Unix, ovvero GNU non è Unix. Il nuovo modello di sviluppo prese il nome di Software Libero (free software). Venne inoltre scritta una specifica licenza, GNU General Public License (nota come GPL), che aggirasse i limiti imposti dai diritti d'autore e consentisse a chiunque di copiare e modificare un lavoro, seppur nel rispetto di condizioni e termini rigorosi. È anche nota come licenza copyleft.

contrapposizione al copyright.

Linux

Agli inizi degli anni '90, Linus Torvalds, uno studente finlandese in scienze dell'informazione, iniziò ad apportare variazioni a Minix, un sistema operativo di tipo Unix per personal computer allora utilizzato nei corsi universitari sui sistemi operativi.

Torvalds decise di migliorare il componente principale del software alla base di Minix, chiamato kernel, e di scriverne uno proprio. Alla fine del 1991 pubblicò la prima versione di questo kernel su Internet e la battezzò Linux, un gioco di parole basato sul suo nome e Minix.

La forza di questo progetto è stata l'adozione della licenza GNU GPL: in questo modo Linux risultava un software che poteva essere liberamente utilizzato, copiato e modificato da chiunque, a condizione che le stesse libertà fossero estese a tutte le copie e le varianti. Nel tempo migliaia di programmatori sparsi nel mondo contribuirono al progetto e Linux è diventato un sistema operativo completo, moderno e utilizzabile sia da programmatori che da non addetti ai lavori.

Kernel

Per kernel si intende il cuore di un sistema operativo, cioè quel codice che gestisce le risorse presenti sul sistema e le rende disponibili alle applicazioni; il kernel si occupa principalmente di gestire:

• Le comunicazioni con l’hardware del sistema, device driver
• File system e la memoria
• L’accesso alle risorse da parte dei processi, cioè le applicazioni eseguite sul sistema

Le versioni del kernel Linux sono identificate con numeri dal significato ben preciso.

Per esempio il kernel 2.6.22

Semplificando si può dire: major number . minor number . revision

Il major number identifica il valore più alto della revisione del kernel. Il minor number:

• Se pari il kernel viene considerato stable, cioè pronto per sistemi in produzione
• Se dispari si considera il kernel in development, cioè da usare con cautela o per sperimentazione

Le release stable sono sempre figlie delle release di sviluppo.

Kernel Monolitico o modulare?

Monolitico: è un singolo, grande file binario eseguibile in modalità “kernel” contenente il gestore del processo, della memoria, del sistema, device driver, ecc. Esempi: sistemi operativi UNIX, Linux, MS-DOS.

Modulare: indica un kernel con la capacità di caricare o scaricare parti di codice (moduli) secondo necessità e richieste.

Il Kernel monolitico è generalmente più veloce, poiché tutto il codice è caricato al bootstrap dell'OS; tuttavia occupa maggiori risorse. Un vantaggio del kernel monolitico è la maggiore stabilità quando non richiede moduli esterni, evitando dipendenze problematiche.

Il kernel modulare è quello utilizzato dalla maggior parte delle distribuzioni Linux odierne.

Distribuzioni Linux

Distribuzione	Note	Web
Red Hat Enterprise Linux (RHEL)	Distribuzione commerciale per server, cloud e data center, con cicli di supporto lunghi (attualmente RHEL 8, 9 e 10).	www.redhat.com
Fedora Linux	Distribuzione comunitaria sponsorizzata da Red Hat, con due rilasci all’anno (oggi intorno a Fedora 43); piattaforma “di prova” per le tecnologie che finiranno in RHEL.	fedoraproject.org
Mandriva (storica)	Distribuzione desktop molto popolare negli anni 2000, oggi discontinuata. La sua eredità continua in progetti come Mageia e OpenMandriva.	www.openmandriva.org
openSUSE (Leap / Tumbleweed)	Distribuzione del progetto openSUSE: Leap come versione stabile e Tumbleweed come rolling release sempre aggiornata.	www.opensuse.org
Slackware 15.0	Una delle distribuzioni più antiche ancora mantenute; molto vicina alla filosofia UNIX tradizionale, indicata per utenti esperti.	www.slackware.com
Debian 13 “Trixie”	Distribuzione comunitaria storica, conosciuta per stabilità e grande quantità di pacchetti; base per molte altre distro.	www.debian.org
Kali Linux (rolling)	Distribuzione specializzata in sicurezza informatica, penetration testing e digital forensics, aggiornata con rilasci rolling (es. serie 2025.x).	www.kali.org
Ubuntu 24.04 LTS “Noble Numbat”	Distribuzione basata su Debian, tra le più diffuse su desktop e server; release LTS con 5 anni di supporto standard.	www.ubuntu.com
Kubuntu 24.04 LTS	Flavor ufficiale di Ubuntu che utilizza l’ambiente desktop KDE Plasma invece di GNOME, pensato per l’uso quotidiano su PC.	www.kubuntu.org
Linspire 14	Distribuzione commerciale basata su Debian/Ubuntu, orientata alla semplicità d’uso su desktop, oggi nuovamente mantenuta da PC/OpenSystems.	www.linspirelinux.com

Directory radice e /bin

Il file system ha origine in /, detta root o "directory radice". Si nota esplicitamente che root è anche la username dell'amministratore di sistema la cui home directory è /root.

• /home — Contiene le "aree locali" dei singoli utenti. Quando un utente si collega facendo login, egli non si trova nella directory principale / ma nella propria home directory (associata al proprio account).

• /usr — Qui risiede la maggior parte del sistema. In /usr e nelle sue sottodirectory troviamo tutti i programmi installati, i file del manuale, la documentazione ecc.; i file in genere sono di sola lettura.

• /lib e /usr/lib — Questa directory contiene le librerie di sistema, cioè quegli archivi di funzioni utilizzati da tutti. Troveremo in questa directory le librerie di funzioni utilizzate dal linguaggio C, richiamate da tutti i programmi compilati in questo linguaggio, ma anche varie librerie utilizzate da altri linguaggi o sistemi.

• /bin — È la directory che contiene i programmi principali del sistema, quelli che devono essere disponibili subito all'accensione, per poter avviare il sistema.

• /sbin e /usr/sbin — Analoghe a /bin e /usr/bin; la 's' sta per superuser ed è riferita a root (utente amministratore).

• /etc — Una delle directory più importanti perché contiene la quasi totalità dei file di configurazione del sistema, compresi quelli necessari per la fase di accensione.

• /tmp — Directory temporanea: qui vengono memorizzati file temporanei. Il contenuto viene cancellato ad ogni accensione (comportamento che varia tra le distribuzioni).

• /var — Contiene, nelle sottodirectory, i file che registrano gli eventi del sistema, log files, le code di stampa e tutti i file di sistema che vengono modificati.

COMANDI LINUX

Un comando può avere una serie di opzioni che solitamente sono indicate con il segno -. Ogni spazio bianco separa il comando da ogni opzione.

<comando> <-opzione1> <-opzione2> <-opzione3> …

Esempio:

ls -l

Cambio directory (Cartella)

cd <directory>

Consente di cambiare la directory corrente in quella indicata (change directory).

Esempi d’uso:

cd Desktop — se la directory corrente è /home/<nome> e in questa vi è la directory Desktop, allora con questo comando si va in Desktop.

cd .. — porta alla directory superiore (o padre).

cd /var — qualunque sia la directory corrente va in /var.

cd ~/temp — la directory corrente diventa /home/<nome>/Desktop/temp.

pwd — mostra il percorso completo della directory corrente (print working directory).

In Linux ogni comando lavora con tre canali standard:

• stdin (0) – standard input, di solito la tastiera;
• stdout (1) – standard output, di solito lo schermo;
• stderr (2) – standard error, di solito lo schermo (messaggi di errore).

Questi canali sono chiamati descrittori di file (0, 1, 2) e il sistema li tratta come veri e propri file. Possiamo “ridirigere” questi canali verso altri file o comandi: questo meccanismo si chiama redirect.

Redirezionare l'output standard (stdout)

> sovrascrive il file, >> aggiunge in coda (append).

Salvare l'output di un comando in un file:

ls -la /etc > elenco_etc.txt

Crea (o sovrascrive) il file elenco_etc.txt con l'elenco dettagliato dei file di /etc.

Aggiungere output a un file esistente:

ls /usr/bin >> elenco_etc.txt

Aggiunge in fondo al file elenco_etc.txt l'elenco dei file di /usr/bin.

Redirezionare lo standard error (stderr)

Possiamo separare output normale e messaggi di errore:

ls /cartella_valida /cartella_inesistente 1> ok.txt 2> errori.txt

• ok.txt conterrà l'output corretto (stdout);
• errori.txt conterrà solo i messaggi di errore (stderr).

Redirezionare lo standard input (stdin)

Possiamo far arrivare l’input di un comando da un file invece che dalla tastiera, usando < (o 0<):

sort < parole.txt

Ordina le righe del file parole.txt e mostra il risultato sullo schermo.

wc -l < parole.txt

Conta il numero di righe di parole.txt.

Comando ls e redirect

ls (list) mostra il contenuto di una directory.

Sintassi: ls <opzioni> [directory|file...]

Opzioni utili:

• -a – mostra anche i file nascosti;
• -l – formato lungo (permessi, proprietario, dimensioni, data);
• -h – dimensioni “leggibili” (K, M, G);
• -R – esplora ricorsivamente le sottodirectory.

Esempi:

• ls – mostra il contenuto della directory corrente;
• ls -la – mostra tutti i file (inclusi nascosti) in formato lungo;
• ls -lh /var/log – elenco dei log con dimensioni comprensibili;
• ls -R /etc > elenco_etc.txt – salva l’elenco ricorsivo di /etc in un file.

cp: copia file e directory

cp — copia file o directory.

-r — copia ricorsivamente directory e sottodirectory.

-a — copia i file mantenendo permessi e timestamp (modalità archivio).

Alcuni esempi:

• cp file1 cart1 — copia il file file1 dentro la cartella cart1.
• cp -r cart1 cart2 — copia ricorsivamente la cartella cart1 dentro cart2 (incluso il contenuto).
• sudo cp -a cart1 cart2 — copia cart1 in cart2 mantenendo permessi, proprietà e timestamp (eseguito con privilegi amministrativi).

mv: muove o rinomina un file o una directory

mv — sposta o rinomina file e directory.

-i — chiede conferma prima di sovrascrivere un file esistente.

Esempi:

• mv vecchio nuovo — rinomina un file.
• mv file1 cart1 — sposta file1 nella directory cart1.

rm: cancella uno o più file

rm — rimuove file.

-r — rimuove ricorsivamente directory e contenuto.

-f — forza la cancellazione senza chiedere conferme.

Esempi:

• rm file1 file2 — cancella i file indicati.
• rm *.* — cancella tutti i file della directory corrente.
• rm -rf cart1 — cancella ricorsivamente la cartella cart1 e il suo contenuto.

rmdir: cancella una directory vuota

rmdir — cancella una directory vuota.

rmdir prova — cancella la directory prova, se è vuota.

mkdir: crea una directory

mkdir — crea una directory.

-p — crea directory intermedie se necessario.

• mkdir prova — crea la directory prova nella directory corrente.
• mkdir -p /Classi/4INF/Allievi — crea la gerarchia di directory, creando anche quelle intermedie se non esistono.

pwd: visualizza la directory corrente

pwd — mostra la directory corrente, ad esempio /home/number0sh.

Amministrazione degli utenti e permessi sui file.

chmod: modificare i permessi di un file

chmod permette di modificare i permessi di un file o di una directory. Con l'opzione -R li applica in modo ricorsivo a tutte le sottodirectory e ai file contenuti.

In GNU/Linux i permessi disponibili sono:

• r — read (lettura)
• w — write (scrittura)
• x — execute (esecuzione)

Questi permessi si applicano a tre categorie di soggetti:

• u — user (proprietario del file)
• g — group (gruppo)
• o — others (altri utenti)

Rappresentazione numerica (ottale)

Ogni permesso è associato a un valore numerico:

• r = 4
• w = 2
• x = 1

Si sommano i valori per ottenere il permesso completo su ogni categoria (utente, gruppo, altri):

• 4 → r-- (solo lettura)
• 6 → rw- (lettura + scrittura)
• 7 → rwx (lettura + scrittura + esecuzione)
• 0 → --- (nessun permesso)

Esempi:

• 644 → utente: rw-, gruppo: r--, altri: r--
• 755 → utente: rwx, gruppo: r-x, altri: r-x

Modalità simbolica

Si specificano soggetto, operazione e permesso:

chmod [ugo][+/-][rwx] nomefile

Esempi:

• chmod u+r file — aggiunge la lettura all’utente.
• chmod go-w file — rimuove la scrittura a gruppo e altri.

Modalità numerica (assoluta)

Si usa la notazione ottale a 3 cifre:

chmod 734 nomefile

Interpretazione:

• 7 (utente) → 4+2+1 → rwx
• 3 (gruppo) → 2+1 → -wx
• 4 (altri) → 4 → r--

Gestione utenti e gruppi

I gruppi servono a gestire insiemi di utenti con esigenze simili. Si definiscono i permessi su file e directory per il gruppo, poi si assegnano gli utenti ai gruppi.

Esempi di comandi:

sudo usermod -a -G groupname username
sudo usermod -a -G INF utenteescuola

File di sistema

• /etc/passwd — informazioni di base sugli account utenti.
• /etc/shadow — password (cifrate) e scadenze.
• /etc/group — definizione dei gruppi.

Creare, modificare, cancellare utenti

Creare un utente:

useradd [opzioni] nome_utente

Esempi:

• useradd -G visitatori pippo — crea l’utente e lo aggiunge al gruppo visitatori.
• usermod -G colleghi pippo — modifica i gruppi di pippo.
• userdel pippo — elimina l’utente.

Attenzione: assegnare l’UID 0 a un utente diverso da root significa dargli tutti i privilegi di amministratore.

chown: cambiare proprietario e gruppo

chown modifica proprietario e gruppo di file e directory.

Esempi:

sudo chown -R root:root drupal
chown nome1:gruppo1 file1
chown -R nome1:gruppo1 dir1
chown PROPRIETARIO:GRUPPO /usr/share/directory/

L’opzione -R applica il cambiamento in modo ricorsivo.

Cosa sono le pipe

Nei sistemi UNIX/Linux la pipe permette di inviare l’output di un comando come input del comando successivo, creando una pipeline di processi.

Si usa il simbolo | (barra verticale).

Esempio base:

ls -l /etc /bin | more

Qui:

• ls -l /etc /bin genera un elenco lungo di file;
• more mostra l’output una schermata alla volta.

Pipe con grep: filtrare l'output

Trovare solo le righe che contengono una parola chiave:

dmesg | grep -i usb

Cerca nei messaggi del kernel tutte le righe che contengono usb (ignorando maiuscole/minuscole).

Cercare un processo specifico:

ps aux | grep firefox

Mostra solo i processi che contengono la parola firefox nella riga del processo.

Vedere solo le righe con "ERROR" in un log:

cat /var/log/syslog | grep "ERROR"

Filtra il file di log e mostra solo le righe che contengono la parola ERROR.

Pipe con more/less: output lunghi

Visualizzare a pagine l’output di un comando:

ls -R /etc | less

less è simile a more ma permette di scorrere avanti e indietro.

Monitorare un log in tempo reale con pipe

Vedere gli ultimi messaggi di autenticazione e restare in ascolto:

sudo tail -f /var/log/auth.log

tail -f mostra le ultime righe e aggiorna l'output quando il file cambia.

Filtrare solo i tentativi falliti:

sudo tail -f /var/log/auth.log | grep -i "failed"

Combina tail -f e grep per vedere in tempo reale solo le righe che contengono failed. Utile per monitorare tentativi di login non riusciti.

lshw – elenco hardware

sudo lshw

Mostra la lista completa di tutti i dispositivi hardware del sistema, con informazioni su driver e firmware.

sudo lshw -class disk -class storage

Mostra solo i dispositivi di memorizzazione (dischi, controller, ecc.).

File di report: ace_check_disk_space / ace_check_disk_speed

In alcuni script vengono creati file come ace_check_disk_space e ace_check_disk_speed, che contengono:

• la lista dei dischi presenti nel sistema;
• le velocità di lettura/scrittura misurate sui dischi.

Questi file sono prodotti combinando comandi come lshw, hdparm e awk in pipeline.

hdparm – test dischi

hdparm permette di interrogare parametri dei dischi e misurarne le prestazioni.

sudo hdparm -I /dev/sda | grep -i speed
sudo hdparm -tT /dev/sda
sudo hdparm -tT /dev/sdb

touch – creare/aggiornare file

touch filename

Se il file non esiste, viene creato vuoto; se esiste, viene aggiornato il timestamp (data/ora di accesso e modifica).

cut – estrarre colonne di testo

cut permette di estrarre porzioni (colonne) da ogni riga di un file di testo o dall'output di un comando.

Opzioni principali:

• -c — seleziona colonne di caratteri (posizioni);
• -f — seleziona campi (field) separati da un delimitatore;
• -d — specifica il delimitatore (per esempio ; o ,).

Esempio semplice (posizioni di caratteri):

echo "123456789" | cut -c1-3

Mostra i primi 3 caratteri: 123.

Esempio con file di testo:

cut -c1-5 test.txt

Mostra i caratteri dalla 1 alla 5 di ogni riga di test.txt.

grep – cercare testo nei file

grep cerca una parola o un'espressione all'interno di file di testo o dell'output di un comando.

Sintassi base:

grep [opzioni] "testo_da_cercare" nomefile

Opzioni utili:

• -i — ignora maiuscole/minuscole;
• -n — mostra il numero di riga;
• -r — cerca ricorsivamente nelle sottodirectory;
• -v — mostra le righe che non contengono il testo cercato.

Esempi:

grep "ERROR" /var/log/syslog

Mostra le righe del file di log che contengono ERROR.

grep -i "warning" /var/log/syslog

Cerca warning ignorando maiuscole/minuscole.

grep -rn "ssh" /etc

Cerca ricorsivamente (-r) la parola ssh sotto /etc e mostra il numero di riga (-n).

Esempio pratico: file CSV degli studenti

Supponiamo di avere il file studenti.csv con formato:

cognome;nome;classe;media
Rossi;Marco;3INF;7.2
Bianchi;Luca;4INF;6.5
Verdi;Sara;3INF;8.1
...

Estrarre solo cognome e nome di tutti gli studenti:

cut -d";" -f1,2 studenti.csv

Estrarre solo gli studenti della 3INF:

grep ";3INF;" studenti.csv

Estrarre cognome, nome e classe solo per 3INF:

grep ";3INF;" studenti.csv | cut -d";" -f1,2,3

Vedere solo le prime 5 righe del file (intestazione + 4 studenti):

head -5 studenti.csv

Saltare l'intestazione e vedere i primi 10 studenti:

tail -n +2 studenti.csv | head -10

tail -n +2 parte dalla seconda riga (salta l'intestazione), head -10 prende le prime 10 righe risultanti.

head – prime righe di un file

head mostra le prime 10 righe (default) o un numero diverso con -n.

head -3 test.txt

Mostra le prime 3 righe di test.txt.

tail – ultime righe di un file

tail mostra le ultime 10 righe (default) o un numero diverso con -n.

tail -3 test.txt

Mostra le ultime 3 righe di test.txt.

Vedere solo la parte “finale” di un log molto lungo:

tail -50 /var/log/syslog

Mostra le ultime 50 righe del file di log.

df – panoramica veloce (introduzione)

df mostra lo spazio su disco utilizzato e disponibile sui filesystem montati.

df -h

Visualizza tutte le partizioni con dimensioni leggibili (K, M, G). Per le opzioni avanzate vedi il capitolo dedicato a df.

Opzioni utili di df

• -h — dimensioni “leggibili” (K, M, G)
• -T — mostra il tipo di filesystem
• -t <tipo> — mostra solo filesystem di quel tipo
• -x <tipo> — esclude il tipo indicato
• -l — mostra solo filesystem locali

df -h

Visualizza tutte le partizioni montate con dimensioni in formato umano.

Filtrare l'output di df con grep

Mostrare solo i dischi “veri” (dispositivi /dev):

df -h | grep "^/dev"

Mostra solo le righe di df -h che iniziano con /dev, cioè i dispositivi di disco, escludendo filesystem virtuali (tmpfs, cgroup, ecc.).

Mostrare solo i filesystem montati in /home:

df -h | grep "/home"

Utile quando la home è su una partizione separata.

sudo – eseguire comandi come root

sudo permette di eseguire un comando con i privilegi di root, senza dover effettuare login come root.

L’utente deve appartenere a un gruppo autorizzato (ad es. sudo o wheel, a seconda della distribuzione).

man – manuale dei comandi

man apre la pagina di manuale di un comando, con descrizione, opzioni e dettagli.

man ls

Mostra il manuale del comando ls.

Aggiornare la lista dei pacchetti

sudo apt-get update

Scarica le informazioni più recenti sui pacchetti dai repository configurati.

Aggiornare i pacchetti installati

sudo apt-get upgrade

Aggiorna alla versione più recente i pacchetti già installati, senza rimuovere o installare nuove dipendenze che rompano il sistema.

Aggiornamento “intelligente” (dist-upgrade)

sudo apt-get dist-upgrade

Può installare nuovi pacchetti e rimuoverne altri per completare l’aggiornamento. Utile per passare a una versione successiva della distribuzione.

Rimuovere pacchetti non più necessari

sudo apt-get autoremove

Rimuove pacchetti installati come dipendenze e non più richiesti da nessun pacchetto.

Pulire la cache dei pacchetti

sudo apt-get autoclean

Elimina dalla cache i pacchetti .deb che non sono più disponibili nei repository (versioni vecchie), liberando spazio.

Nano – editor testuale da terminale

Nano è un editor di testo semplice e intuitivo, usato nel terminale.

nano documento

Apre (o crea) il file documento.

Comandi di base

• Ctrl + O — salva (write Out)
• Ctrl + X — esci
• Ctrl + G — help

Altri comandi utili

• Ctrl + W — cerca testo
• Ctrl + K — taglia la riga corrente
• Ctrl + U — incolla l’ultima riga tagliata
• Ctrl + J — giustifica il paragrafo
• Esc + R — modalità replace (sostituzione testo)

Nano è molto pratico per modificare file di configurazione e script, anche da remoto (SSH).