Comandi Bash shell - SisInf Lab

FONDAMENTI DEI SISTEMI OPERATIVI 

Appunti dalle esercitazioni del laboratorio di GNU/Linux 

(Ing. Silvia Giannini) 

Anno Accademico 2012-2013

CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI 

A.A. 2012-2013 

(Prof. G. Piscitelli) 

Premessa 

La presente dispensa contiene una descrizione dei comandi di shell Bash presentati a lezione 

nell’ambito delle esercitazioni su sistemi operativi GNU/Linux per il corso di Fondamenti dei 

Sistemi Operativi, tenuto dal Prof. Giacomo Piscitelli nei corsi di laurea di Ingegneria 

Informatica e dell’Automazione ed Ingegneria Elettronica e delle Telecomunicazioni (A.A. 

2012-13). 

Parte del contenuto è tratto dalle slide del corso di Laboratorio di Sistemi Operativi 

(distribuite nei termini della licenza Creative Commons “Attribuzione/Condividi allo stesso 

modo 2.5” http://creativecommons.org/licenses/by-sa/2.5/it/legalcode), tenuto dal Dott. 

Gennaro Oliva presso l’Università degli Studi di Napoli Federico II nell’A.A. 2010-11. 

Saranno apprezzate e benvenute le segnalazioni di errori, imprecisioni ed omissioni (mail to 

s.giannini@deemail.poliba.it). 

Tale dispensa non è da considerarsi esaustiva sugli argomenti affrontati a lezione. Per ulteriori 

approfondimenti si rimanda a "Linux e la shell Bash" 

(http://sisinflab.poliba.it/giannini/SO/Linux_e_la_shell_Bash.pdf) 

Esercitazioni comandi shell Bash (Ing. S. Giannini) Pagina 2

Indice 


A.A. 2012-2013 


Comandi di help .....................................................................................................................6 

man ....................................................................................................................................6 

Il file system ...........................................................................................................................8 

pwd ....................................................................................................................................8 

ls ........................................................................................................................................8 

Protezione di file e directory ...........................................................................................9 

cd ..................................................................................................................................... 10 

cp ..................................................................................................................................... 10 

mkdir ................................................................................................................................ 11 

mv .................................................................................................................................... 11 

rm ..................................................................................................................................... 11 

rmdir ................................................................................................................................ 11 

stat .................................................................................................................................... 12 

touch ................................................................................................................................ 12 

Manipolazione dei permessi .............................................................................................. 13 

chown ............................................................................................................................... 13 

chgrp ................................................................................................................................ 13 

chmod............................................................................................................................... 13 

Link .................................................................................................................................. 13 

Hard link .......................................................................................................................... 14 

Soft link o symbolic link ................................................................................................... 14 

Altri comandi di base ............................................................................................................ 15 

alias/unalias ...................................................................................................................... 15 

echo .................................................................................................................................. 15 

date ................................................................................................................................... 15 

which ................................................................................................................................ 15 

Caratteri speciali di shell....................................................................................................... 16 

1. File globbing................................................................................................................. 16 

2. Espansione della shell ................................................................................................... 16 

3. Regole di quoting .......................................................................................................... 16 

Espressioni Regolari ............................................................................................................. 17 

Sintassi delle espressioni regolari ...................................................................................... 17 

Caratteri speciali della shell ed espressioni regolari ........................................................... 19 

Caratteri speciali per le espressioni regolari ................................................................ 19 

Operatori di ripetizione ..................................................................................................... 19 

Regole di precedenza degli operatori ................................................................................ 20 

Comandi di ricerca di stringhe .............................................................................................. 20 

grep .................................................................................................................................. 20 

Gestione utenti e gruppi ........................................................................................................ 24 

Gruppi di utenti ................................................................................................................ 24 

groupadd .......................................................................................................................... 24 

groupdel ........................................................................................................................... 24 

groupmod ......................................................................................................................... 24 

useradd ............................................................................................................................. 25 



A.A. 2012-2013 


passwd .............................................................................................................................. 25 

userdel .............................................................................................................................. 26 

usermod ............................................................................................................................ 26 

su (substitute user) ............................................................................................................ 27 

Comandi informativi ............................................................................................................ 27 

id ...................................................................................................................................... 27 

whoami ............................................................................................................................. 28 

who .................................................................................................................................. 28 

groups............................................................................................................................... 28 

last .................................................................................................................................... 28 

Variabili ............................................................................................................................... 29 

Definizione ....................................................................................................................... 29 

Variabili d'ambiente ......................................................................................................... 29 

printenv ............................................................................................................................ 29 

export ............................................................................................................................... 30 

set/unset............................................................................................................................ 30 

Visualizzazione ed editing di file .......................................................................................... 31 

cat..................................................................................................................................... 31 

file .................................................................................................................................... 31 

less (more) ........................................................................................................................ 31 

Canali di comunicazione e ridirezione .................................................................................. 32 

Operatori di ridirezione dello standard output ................................................................... 32 

Operatori di ridirezione dello standard error ...................................................................... 32 

Operatori di ridirezione dello standard input ..................................................................... 32 

Operatore di pipeline ........................................................................................................ 33 

Liste di comandi ................................................................................................................... 33 

sequenza ........................................................................................................................... 33 

concorrenza ...................................................................................................................... 34 

condizione ........................................................................................................................ 34 

esclusione ......................................................................................................................... 34 

Exit status di liste di comandi ........................................................................................... 34 

Script BASH ........................................................................................................................ 34 

Filtri e programmi di utilità generica..................................................................................... 35 

sort ................................................................................................................................... 35 

wc..................................................................................................................................... 36 

head .................................................................................................................................. 36 

tail .................................................................................................................................... 36 

uniq .................................................................................................................................. 37 

cut .................................................................................................................................... 37 

diff ................................................................................................................................... 38 

Gestione dei processi ............................................................................................................ 39 

Avvio del sistema .............................................................................................................. 39 

Runlevel ........................................................................................................................... 39 

shutdown .......................................................................................................................... 40 

Controllo dei processi ....................................................................................................... 40 

ps ...................................................................................................................................... 41 



A.A. 2012-2013 


pstree ................................................................................................................................ 43 

top .................................................................................................................................... 43 

Background e foreground ............................................................................................. 44 

yes .................................................................................................................................... 44 

sleep ................................................................................................................................. 44 

wait .................................................................................................................................. 44 

jobs ................................................................................................................................... 44 

fg ...................................................................................................................................... 45 

bg ..................................................................................................................................... 45 

Segnali ............................................................................................................................. 45 

kill .................................................................................................................................... 46 

pkill .................................................................................................................................. 47 

killall ................................................................................................................................ 47 

Terminazione di un processo ............................................................................................ 47 



A.A. 2012-2013 


Comandi di help 

man 

Il comando man (manual) fornisce informazioni su qualsiasi comando, visualizzandone la pagina di manuale 

relativa. 

Il manuale è suddiviso in pagine logiche che corrispondono ad una sezione. Ogni sezione si riferisce ad un 

insieme di argomenti logicamente affini. 

Le pagine di manuale di un sistema UNIX sono raggruppate in 8 sezioni: 

1) programmi eseguibili o comandi di shell (ls, vi, ...); 

2) system call (open, write, fork, ...); 

3) funzioni di libreria (printf, scanf, …); 

4) file speciali (/dev/null, /dev/mouse, ...); 

5) formati di file (/etc/passwd, /etc/hosts, …); 

6) giochi (fortune, ...); 

7) protocolli, convenzioni, panoramiche, varie (tcp, boot, ... ); 

8) comandi per la gestione del sistema (iptables, mkfs, ...). 

SINTASSI: $ man [opzioni] comando 

$ man man 

All'interno di una pagina di manuale ci si può muovere con i tasti direzione: su, giù, pg su, pg giù. Si esce dalla 

visualizzazione premendo q (quit). Si può ricercare una stringa digitando /stringa e se ne visualizzano le 

occorrenze premendo n (occorrenza successiva) oppure N (occorrenza precedente). 

La struttura della documentazione dei comandi è simile per ogni comando e segue il paradigma LDP (Linux 

Documentation Project). All'interno di una pagina di manuale ci sono varie sottosezioni. Quelle convenzionali 

sono: NAME, SYNOPSIS, CONFIGURATION, DESCRIPTION, OPTIONS, EXIT STATUS, RETURN 

VALUE, ERRORS, ENVIRONMENT, FILES, VERSIONS, CONFORMING TO, NOTES, BUGS, EXAMPLE, 

AUTHORS, SEE ALSO. 

Di particolare rilevanza: 

NAME: nome del comando e relativo commento 

SYNOPSIS: sintassi del comando 

DESCRIPTION: descrizione dettagliata del comando 

OPTIONS: flag attribuibili al comando 

Opzioni: 

-f Mostra NAME (con session) e relativo commento (equivale a SINTASSI: $ whatis comando) 

-k Cerca nel NAME e nel commento del man di tutti i comandi il pattern (comando) in argomento. 

Risponde col NAME del comando e con il commento associato (equivale a SINTASSI: $ apropos comando) 

-L Consente di visualizzare il manuale nella traduzione richiesta, se disponibile. 

$ man -L it man 

$ man -L en man 

L'argomento del comando man viene ricercato all'interno delle sezioni in ordine crescente. Alla prima 

corrispondenza trovata, viene visualizzata la pagina di manuale individuata. Alcune parole chiave possono essere 

presenti in più sezioni, quindi per visualizzare il manuale di una sezione specifica bisogna anteporre come 

opzione il numero della sezione (preceduto o meno dal flag -s). 

Esempi. 

- La parola write corrisponde almeno a due pagine di manuale: (1) il comando write per comunicare con gli 

utenti; (2) la system call write per l'I/O a basso livello. 

Per visualizzare la pagina della system call usiamo: $ man 2 write 



A.A. 2012-2013 


- $ man -s1 chmod (Mostra la prima sessione) 

$ man -s2 chmod (Mostra la seconda sessione) 

In maniera alternativa, è possibile utilizzare 

SINTASSI: $ comando --help Accede direttamente alla sottosezione relativa alla descrizione delle options. 



A.A. 2012-2013 


Il file system 

Il file system di Unix ha un'organizzazione gerarchica ad albero, la cui radice (root) è una directory identificata 

dal carattere /. Alcune sottodirectory della root directory sono comuni a tutti i sistemi UNIX. 

bin: programmi binari (built-in) essenziali utilizzabili da tutti gli utenti 

sbin: (superuser bin) programmi binari essenziali per l'amministrazione del sistema 

boot: file necessari all'avvio del sistema quali il kernel ed i driver 

dev: file speciali associati a dispositivi hardware 

etc: file di configurazione 

home: home directory degli utenti che hanno un account sulla macchina 

root: home directory del root user 

tmp: file temporanei 

usr: file read-only 

var: file che il sistema scrive durante l'esecuzione (log, spool, cache, ...) 

Per i sistemi Linux i nomi delle directory e le loro funzioni sono stabilite dal Filesystem Hierarchy Standard 

(FHS). 

I nomi di file e directory possono essere composti da qualsiasi sequenza di caratteri eccetto /. E' buona prassi 

limitarsi nell'utilizzo degli spazi. Ogni directory contiene 2 directory speciali: ., che corrisponde alla directory 

stessa; .., che corrisponde alla directory padre (la directory padre di / è / stessa). 

La struttura ad albero consente di identificare univocamente un elemento del file system mediante il percorso che 

va dalla root directory / al file stesso. Questo percorso viene detto pathname. Nel pathname tutte le directory del 

percorso vengono separate dal carattere /. Un pathname che inizia con il carattere / viene detto assoluto, parte 

dalla root directory ed arriva ad un elemento del filesystem. Un pathname che inizia senza il carattere /, parte da 

una directory del file system e viene detto relativo. 

pwd 

Il comando pwd (print working directory) mostra sullo standard output il percorso completo (pathname assoluto) 

della directory di lavoro corrente. 

SINTASSI: $ pwd 

user@ubuntu:~$ pwd 

/home/user 

ls 

Il comano ls (list) lista il contenuto di una directory in ordine alfabetico (in assenza del path in argomento lista il 

contenuto della current working directory - cwd). 

SINTASSI: $ ls [opzioni] [path] 



A.A. 2012-2013 


Opzioni: 

-a (all) Mostra anche i file nascosti (tutti i file che iniziano con il carattere '.') 

-F Associa un identificatore per ogni tipo di file in coda al nome (@ link simbolico; * eseguibile; / 

directory; | FIFO; = socket) 

-t Ordina i file per data di modifica, dal più recente 

-u Ordina i file per data di ultimo accesso, dal più recente 

-r Inverte l'ordine alfabetico di visualizzazione 

-R Visualizza in modo ricorsivo il contenuto delle sottodirectory 

-1 Visualizza l'elenco in un'unica colonna 

-Q Circonda i nomi dei file con le virgolette (utile in caso di nomi di file che contengono spazi) 

-i Visualizza l'#i-node del file. 

-l Mostra informazioni dettagliate sui file contenuti nella directory in maniera tabellare: 

[Access Control List] [numero di link al file] [utente] [gruppo] [dimensione in byte] [ultimo accesso] 

[nome simbolico file] 

Protezione di file e directory 

Unix è un sistema multi utente e necessita di meccanismi di protezione di file e directory per consentire ad ogni 

utente di preservare i propri dati dall'accesso da parte di altri utenti. Ogni file ha un proprietario e un gruppo di 

appartenenza. L'amministratore può modificare, assieme al proprietario, i diritti d'accesso. 

Al file sono associate protezioni per tre tipi di accesso: 

a) Accesso in lettura identificato dalla lettera “r” (read) 

b) Accesso in scrittura identificato dalla lettera “w” (write) 

c) Accesso in esecuzione identificato dalla lettera “x” (execute) 

Le protezioni possono essere applicate a 3 classi di utenti: 

1. il proprietario del file (user) 

2. il gruppo a cui appartiene il file (group) 

3. tutti gli altri utenti (others) 

L'Access Control List (ACL) è una sequenza di 10 caratteri. Il primo carattere rappresenta il tipo di file: 

d directory (contiene nomi di file e puntatori ad i-node) 

l link simbolico (puntatore a file) 

- file ordinario o regolare (contengono dati, senza distinzione tra file binari o di testo) 

b file speciale a blocchi (file speciale che fornisce un'interfaccia bufferizzata a blocchi di lunghezza 

fissa per l'I/O da dispositivi di memorizzazione quali hard disk, cdrom, floppy ...) 

c file speciale a caratteri (file speciale che fornisce un'interfaccia non bufferizzata con blocchi di 

lunghezza variabile a dispositivi quali schede audio, terminali, porte seriali, ...) 

p file FIFO o pipe con nome (tipo di file destinato alla comunicazione iterprocesso su una stessa 

macchina) 

s socket (file utilizzato per la comunicazione tra due processi anche su rete) 

Gli altri 9 caratteri vanno interpretati a gruppi di tre: 

AuBuCu AgBgCg AoBoCo 

A: permesso di lettura (r o -) 

B: permesso di scrittura (w o -) 

C: permesso di esecuzione (x o -) 

per lo user owner (u); per il group owner (g); per gli others (o) ovvero il resto del mondo. 

Esempio di ACL: l rw- rw- r-- 

Si tratta di un link simbolico. L'utente proprietario ha permessi di lettura e scrittura, non di esecuzione; gli utenti 

appartenenti al gruppo del proprietario hanno diritto di lettura e scrittura, non di esecuzione; il resto del mondo 

ha solo diritto di esecuzione. 

Nel caso di directory, i tre tipi di permesso assumono il seguente significato: 



A.A. 2012-2013 


r Visualizzare il contenuto della directory (il list è una lettura) 

w Scrivere all'interno della directory (rinomina, modifica, rimozione) 

x Attraversare una directory, ovvero utilizzare il nome della directory per accedere ad un qualsiasi file 

contenuto nel sottoalbero di cui è radice. Assegnare un premesso di esecuzione ad una directory 

equivale a permettere la navigazione dell'albero. Se chiedo il list del contenuto di una cartella che non 

posso eseguire il sistema comunica permission denied. Negli altri casi il permesso di esecuzione 

esiste solitamente solo per file ordinari. 

E' d'uso fare una maschera in forma ottale dell'ACL, escluso il primo carattere. I 9 valori possono essere 

interpretati come bit (0: permesso negato; 1: permesso concesso) e considerati a gruppi di 3 (8 combinazioni per 

ciascun terzetto). 

Esempi: 

110 110 100 = 664 (dall'esempio precedente) 

755 = 111 101 101 ovvero rwx r-w r-w 

640 = 110 100 000 ovvero rw- r-- --- 

cd 

Il comando cd (change directory) cambia la cwd corrente con quella specificata. 

SINTASSI: $ cd [path] 

Utilizzi particolari: 

cd (Torna alla homedir dell'utente loggato: equivale a cd ~) 

cd - (Torna alla directory precedentemente referenziata, memorizzata nella variabile d'ambiente 

OLDPWD) 

cd . (Porta nella cwd) 

cd .. (Porta nella directory padre della cwd) 

$ cd / 

$ cd /usr/bin 

Esercizi 

1. Visualizzate la pagina di manuale del comando ls. 

2. Cercate la stringa “long” per leggere la sezione relativa all'opzione -l. 

3. Cercate la stringa “all” per leggere la sezione relativa all'opzione -a. 

4. Spostatevi nella directory /usr/bin . 

5. Visualizzatene il contenuto. 

6. Tornate nella vostra home directory. 

cp 

Il comando cp (copy) copia il file (o una directory vuota) dal percorso di partenza a quello di destinazione. Se il 

file di destinazione non esiste viene creato, viceversa si rischia la sovrascrittura. La copia di cartelle non vuote va 

effettuata in maniera ricorsiva. 

SINTASSI: $ cp [opzioni] [path/]fileOrigine [path/]fileDest 

Opzioni: 

-f Forza la sovrascrittura 

-i Richiede interattivamente la conferma di sovrascrittura 

-p Mantiene le caratteristiche del file sorgente compresa la data e l'ora di referenziazione 

-R Copia ricorsiva 

-v Verbose mode 


Esempi: 

$ cp esempio esempio.bak 

$ cp -i esempio2 esempio.bak 

$ cp -Rv dir/dir1 silviax 

mkdir 

Il comando mkdir (make directory), crea una directory. 

SINTASSI: $ mkdir [opzioni] [path/]nomeDir 


A.A. 2012-2013 


Opzioni: 

-m ACL Crea una directory specificando l'ACL 

-v Verbose Mode: mostra sullo standard output le operazioni eseguite 

Esempi: 

$ mkdir prova 

$mkdir prova1 prova2 

$ mkdir prova1/prova11 /home/silvia/prova/prova2 

$ mkdir -m 766 prova3 

Come verificate che la creazione sia andata a buon fine? 

$ mkdir -vm 766 provaV 

mv 

Il comando mv (move), sposta (cut and paste/rename) file o directory da un percorso di partenza ad uno di 

destinazione. 

SINTASSI: $ mv [opzioni] [path/]fileOrigine [path/]fileDest 

Opzioni: 

-f Forza la sovrascrittura 

-i Richiede interattivamente la conferma di sovrascrittura 


Esempi: 

$mv file1 file2 (rinomina file 1 come file2 eventualmente sovrascrivendolo) 

$mv file1 dirA (sposta file1 in dirA) 

$mv dirA file1 (non concesso se file1 è un file esistente) 

$mv dirA dirB (sposta dirA in dirB o rinomina dirA in dirB, se dirB non esiste) 

rm 

Il comando rm (remove file), rimuove un file (o una directory in manera ricorsiva se non vuota). 

SINTASSI: rm [opzioni] nomeFile 

Opzioni: 

-R Cancellazione ricorsiva del contenuto di una directory e della directory stessa, se non vuota 


Esempi: 

$ rm -Rv provaFull 

$ rm file1 

rmdir 

Il comando rmdir (remove directory), cancella una directory. La directory dev'essere vuota. 


SINTASSI: $ rmdir [opzioni] nomeDir_1 [nomeDir_n] 


A.A. 2012-2013 


Opzioni: 

--ignore-fail-on-non-empty Non mostra a video il messaggio di errore 


stat 

Ad ogni file sono associate una serie di informazioni o metadati, quali la dimensione, i permessi, le date di 

accesso e di modifica. Queste informazioni possono essere lette dal filesystem e vengono memorizzate in una 

struttura dati chiamata stat che contiene almeno i seguenti membri: 

struct stat { 

dev_t st_dev /*ID del device che contiene il file*/ 

ino_t st_ino /*n.ro inode*/ 

mode_t st_mode /*tipo di file e permessi*/ 

nlink_t st_nlink /*numero di link al file*/ 

uid_t st_uid /*user ID del proprietario del file*/ 

gid_t st_gid /*group ID del proprietario del file*/ 

dev_t st_rdev /*device ID (se il file è speciale a blocchi o a caratteri)*/ 

off_t st_size /*dimensione del file in bytes (per file regolari, directory o link)*/ 

time_t st_atime /*orario dell'ultimo accessoai dati*/ 

time_t st_mtime /*orario dell'ultima modifica ai dati*/ 

time_t st_ctime /*orario dell'ultimo cambiamento all'inode (ad esempio attraverso chmod)*/ 

blksize_t st_blksize /*dimensione del blocco per l'oggetto (è specifica del FS, può variare da file a file)*/ 

blkcnt_t st_blocks /*numero di blocchi allocati per l'oggetto*/ 

} 

Per avere informazioni su data di creazione, accesso e modifica di un file si può utilizzare il comando 

SINTASSI: $ stat nomeFile) 

touch 

Aggiorna data ed ora di ultima referenziazione del file in argomento (di default cambia sia l'orario di accesso che 

di modifica), con l'orario corrente. Se il file non esiste, crea un file vuoto con data e ora corrente. 

SINTASSI: $ touch [opzioni] nomeFile 

Opzioni: 

-a Cambia l'orario di accesso 

-c Non crea il file, aggiorna solo la data di ultimo accesso 

-m Cambia l'orario di modifica 

Esempio: 

$ touch prova/touch.exe 

Esercizi 

1. All'interno della vostra home directory create 2 directory denominate “uno” e “due”. 

2. Copiate il file /etc/profile nella directory uno, conservandone il nome. 

3. Copiate il file /etc/profile nella directory due cambiandone il nome in copia-profile. 

4. Spostate il file profile nella directory due ed il file copia-profile nella directory uno. 

5. Cancellate i due file con uno stesso comando. 

6. Cancellate le due directory vuote. 

7. Verificate il funzionamento di touch per la modifica dell'orario di ultimo accesso e per la creazione di un file 

vuoto. 



A.A. 2012-2013 


Manipolazione dei permessi 

Al momento della creazione di un file, esso appartiene all’utente che lo ha creato e assume il gruppo di 

quest’ultimo. Il superuser può modificare queste informazioni con i comandi: 

chown 

Il comando chown (change owner), modifica il proprietario di un file. 

SINTASSI: # chown newowner file1 [file2 ... fileN] 

chgrp 

Il comando chgrp (change group), modifica l'owner group di un file. 

SINTASSI: # chgrp newgroup file1 [file2 ... fileN] 

Esempio: 

# chown userB:groupB file1 

chmod 

Il comando chmod (change mode), consente all'utente proprietario (o al superuser) di modificare i permessi (la 

ACL) di file e directory. 

SINTASSI: $ chmod [codiceUtente±codicePermesso | formaOttale] file1 [file2 ... fileN] 

codiceUtente: user group other all 

operatore: + (aggiunge) – (rimuove); 

codicePermesso: read write execute. 

Esercizi 

1. Copiate il file /bin/ls nella vostra home directory specificando il pathname. 

2. Eliminate i permessi di esecuzione a tutti gli utenti per la copia locale. 

3. Ripristinate i permessi di esecuzione al solo proprietario del file. 

4. Create una directory “test” nella vostra home directory e copiate il file /bin/ls al suo interno 

5. Eliminate i permessi di esecuzione alla directory e provate a listare il contenuto. Perché non è concessa 

l'operazione? 

6. Ripristinate i vecchi permessi e cancellate con un unico comando il file all'interno della directory e la 

directory stessa. 

Link 

Un cilindro è organizzato in i-nodes (i-node table) e data-blocks. 



A.A. 2012-2013 


Ad ogni file è associato un singolo ed unico i-node che memorizza la maggior parte delle informazioni restituite 

da stat (numero di link, dimensione, proprietario, allocazione sul disco, etc.) e i puntatori ai data block, in cui 

viene memorizzato il contenuto di un file. All’aumento delle dimensioni del file può corrispondere un aumento 

dei data block allocati per il file. 

Il data block di una directory viene detto directory block e contiene, per ogni file contenuto nella directory, una 

directory entry (#inode, filename) contenente il nome del file e il numero di i-node ad esso associato. La 

modifica del nome di un file viene effettuata sull'informazione memorizzata nel directory block. 

Un riferimento ad un file è detto link. Ogni file può avere un numero qualsiasi di link. 

UNIX ha due tipi di link: hard link e soft link. Entrambi possono essere creati con il comando ln. 

Hard link 

Un hard link è un puntatore all'i-node di un file. Un hard link è un elemento all’interno di una directory il cui 

numero di i-node corrisponde a quello di un altro file. In pratica, è possibile creare “un file” all’interno di una 

directory creando un puntatore ad un file già esistente. Un hard link eredita tutte le informazioni associate all'inode 

del file originale e non c'è più modo di distinguere tra l'hard link e il file originale. 

Le directory hanno un numero di link almeno pari a 2: un puntatore è memorizzato nella voce corrispondente 

contenuta dalla directory “padre”; un puntatore è contenuto nella stessa directory verso “.”. 

La maggior parte di implementazioni UNIX moderne non consente di creare ulteriori hard link a directory. 

Questo limite viene imposto per evitare ricorsioni infinite nel tentativo di attraversare un albero che parte da un 

hard link che punta alla propria directory padre. Inoltre, non è possibile effettuare un hard link con un file 

memorizzato su una partizione diversa da quella della directory in cui lo si vuole creare. 

Ogni volta che si crea un hard link ad un file, il link count per il file si incrementa di 1. 

Quando il comando rm riceve come argomento un hard link, il sistema decrementa il link count (nell’i-node del 

file) di 1. Se il link count non è 0, il sistema rimuove solo la directory entry del file cancellato. Il contenuto del 

file e altre directory entry per quel file (hard link) rimangono inalterati. Se il link count è 0, il sistema rimuove la 

directory entry per quel file, libera l’-inode del file e dealloca i data block che contenevano il file. 

SINTASSI: ln [opzioni] fileEsistente1 [fileEsistente2 ... fileEsistenteN] nuovoFile 

fileEsistenteX non può essere una directory. 

nuovoFile può essere una directory. In tal caso viene creato un hard link all'interno di nuovoFile a tutti i 

fileEsistenti indicati nel comando e i link hanno lo stesso nome dei file originari. 

Opzioni: 

-n Non crea il link se nuovoFile esistente già. 

Soft link o symbolic link 

Un soft link (o symbolic link) corrisponde ad un file che contiene, all’interno dell’unico data block ad esso 

associato, il percorso assoluto di un altro file. I soft link superano i limiti degli hard link in quanto consentono di: 

- creare collegamenti tra entità su filesystem diversi; 

- creare link a directory. 

Un soft link può essere utilizzato per creare puntatori a file o directory lasciando sempre ben chiara la distinzione 

tra il file originale e il link. 

Quando il comando rm riceve come argomento un soft link, cancella quest'ultimo e non il file a cui esso si 

riferisce. 

SINTASSI: $ ln -s pathnameAssolutofileEsistente nomeLink 



A.A. 2012-2013 


Altri comandi di base 

alias/unalias 

L'alias è un nome alternativo dato ad una sequenza complessa 

SINTASSI: $ alias Visualizza tutti gli alias 

$ alias nomeAlias='comando' Crea un alias 

Esempi: 

$ alias al='ls -al' 

$ alias cp='cp -i' (impone al sistema il controllo di sovrascrittura) 

SINTASSI: $ unalias [opzioni] nomeAlias Distrugge l'alias nomeAlias 

Esempio: 

$ unalias al 

Opzioni: 

-a Distrugge tutti gli alias 

echo 

Stampa una stringa sullo standard output. 

SINTASSI: $ echo [stringa] 

Esempi: 

$ echo hello world! 

$ echo ~ (Mostra il percorso assoluto della home-dir dell'utente loggato, vedi sezione Espansione 

della shell) 

date 

Mostra la data e l'ora corrente 

which 

Stampa il path assoluto di un comando 

Esercizio: 

Trovate il path del comando whoami 



A.A. 2012-2013 


Caratteri speciali di shell 

Prima di eseguire un comando, la shell interpreta alcuni caratteri speciali (wildcard) sostituendoli secondo 

regole. Il carattere di escape \ preserva un singolo carattere dall'espansione della shell (analogo utilizzo è 

attribuito al simbolo di escape nelle espressioni regolari). 

$ echo \* 

1. File globbing 

* l'asterisco rappresenta un gruppo qualsiasi di caratteri, compreso il punto, purché il punto non si trovi all'inizio 

del nome 

$ rmdir pro* Cancella tutte le directory vuote il cui nome inizia con pro 

? il punto interrogativo rappresenta un unico carattere qualsiasi, compreso il punto, purché il punto non si trovi 

all'inizio del nome 

$ rmdir pro? Cancella tutte le directory vuote con nome pro seguito da un solo carattere qualsiasi 

[...] le parentesi quadre permettono di rappresentare un carattere qualsiasi o un intervallo di caratteri possibili. 

[adfz] Uno qualsiasi dei caratteri a,d,f,z 

[g-z] Uno qualsiasi dei caratteri compresi tra g e z 

[â] Un carattere qualsiasi diverso da a 

2. Espansione della shell 

{...} le parentesi graffe consentono di specificare un qualsiasi insieme di stringhe nella forma: 

prefisso{stringa1,stringa2,stringa3}suffisso 

Esempi: 

$ echo v{en,id,ic}i 

veni vidi vici 

$ echo v{en,i{d,c}}i 

veni vidi vici 

~ Utilizzato per riferirsi alle home directory dell'utente loggato 

~name Identifica la home dir dell'utente name 

$ mkdir ~/Mail (Crea una directory Mail sotto la home directory dell'utente loggato) 

$nomevar Espansione dei parametri d'ambiente e delle variabili (vedi sezione Variabili) 

$ echo $USER 

$(comando) Sostituisce l'output del comando 

$ echo Oggi e\' $(date) 

Oggi e' gio 24 mar 2011, 08.32.06, CET 

3. Regole di quoting 

L'inserimento di una stringa tra apici singoli ' ' protegge i caratteri speciali contenuti nella stringa dall'espansione 

da parte della shell. 


$ echo '$HOME'=$HOME 

$HOME=/home/silvia 


A.A. 2012-2013 


L'utilizzo di apici doppi “ ” consente l'espansione da parte della shell dei soli nomi di variabile, mentre preserva 

gli altri caratteri speciali dall'espansione. 

$ echo "ls $HOME/* mostra il contenuto della homedir" 

ls /home/silvia/* mostra il contenuto della homedir 

Esercizi 

1. Listare tutti i file della cartella /var/log che contengono il carattere '-' nel nome e che terminano per '.log'. 

2. Listare tutti i file della cartella /var/log composti da tre caratteri e che terminano con '.log'. 

3. Listare tutti i file della cartella /var/log che iniziano con un carattere compreso tra 'h' e 'z' e terminano con 

'.log'. 

4. Visualizzare i file nella directory /var/log che contengono un numero all'interno del nome e terminano in '.log'. 

5. Il man del comando mv riporta tra le options: 

-t DEST_DIR Sposta tutti gli argomenti della cartella sorgente nella cartella DEST_DIR 

Scrivere un comando per spostare il contenuto della cartella ./folder2 all'interno della cartella ./prova1. 

Disegnare l'albero delle directory risultante al termine dell'operazione, supponendo che la cartella ./folder2 

contenga i file file1, file2, folder1. Quale comando utilizzare per spostare l'intera cartella folder2 all'interno di 

prova1? 

Espressioni Regolari 

Un'espressione regolare è un pattern che rappresenta un insieme di stringhe. In altre parole, è una stringa scritta 

secondo una precisa sintassi. 

Le espressioni regolari vengono tipicamente utilizzate nella ricerca di stringhe all'interno di file di testo e nella 

sostituzione delle stringhe trovate con nuovo testo. 

Usando espressioni regolari nell'effettuare ricerche, non si è obbligati a specificare esattamente i termini da 

ricercare, ma si possono definire delle regole generali da utilizzare per trovare le stringhe di interesse. 

Sintassi delle espressioni regolari 

1. Il caso più elementare di espressione regolare è un singolo carattere, che rappresenta l'insieme delle stringhe 

costituite dal solo carattere. 

Il carattere a, ad esempio, rappresenta l'insieme di stringhe costituito dal solo carattere {a}. 

2. Insiemi di caratteri 

Per identificare diversi caratteri è possibile utilizzare le parentesi quadre [...], come accade per il file globbing. 

Una lista di caratteri racchiusa tra parentesi quadre corrisponde a qualsiasi carattere in esse contenuto. 

Se la lista viene preceduta dal simbolo ^, l'espressione corrisponde a qualsiasi carattere non contenuto nella lista. 

Esempio: [âbcd] 

fughe mostrata perché contiene f,u,g,h,e 

coda mostrata perché contiene o 

bada non mostrata perché non contiene caratteri diversi da a,b,c,d 

Il carattere ^, se specificato dopo il primo carattere, assume significato letterale. 

L’espressione '[a^b]' mostra le linee del file che contengono i caratteri a,^ e b e non caratteri a seguiti da caratteri 

diversi da b. 



A.A. 2012-2013 


All'interno delle parentesi quadre è possibile indicare un intervallo di caratteri specificando gli estremi e 

separandoli con il carattere -. 

L'espressione [a-g] mostra tutte le righe del file che contengono una lettera compresa tra a e g. 

Alcune localizzazioni prevedono l'ordinamento aAbBcCdD... per cui specificando [a-g] si individuano le lettere 

[aAbBcCdDeEfF]. 

Si possono anche identificare classi di caratteri attraverso le espressioni: 

[:alnum:] Caratteri alfanumerici (cifra o lettera) 

[:alpha:] Caratteri alfabetici 

[:digit:] Caratteri numerici 

[:lower:] Lettere minuscole 

[:upper:] Lettere maiuscole 

[:xdigit:] Cifre esadecimali 

... 

Esempio: [[:lower:]] Seleziona tutte le righe che contengono una minuscola. 

3. Concatenazione 

Due espressioni regolari, regex1 e regex2, possono essere concatenate in una nuova espressione regolare 

regex1regex2. Ad essa corrisponde qualsiasi stringa formata da due stringhe concatenate corrispondenti alle 

singole espressioni di partenza. 

La più semplice forma di concatenazione è una stringa di lettere o numeri. 

L'espressione regolare 'ab' ricerca tutte le righe che contengono la stringa ab. 

L'espressione regolare 'a[1-5]' restituisce tutte le righe contenenti una delle seguenti stringhe: {a1,a2,a3,a4,a5}. 

4. Alternanza 

Due espressioni regolari, regex1 e regex2, possono essere concatenate utilizzando l'operatore pipe |. 

L'espressione regolare risultante corrisponde a qualsiasi stringa che corrisponda alla prima o alla seconda. 

L'insieme delle stringhe rappresentate dall'espressione regex1|regex2 è l'unione degli insiemi delle stringhe 

rappresentate da regex1 e regex2. 

L'espressione regolare 'a|b' visualizza le righe che contengono le stringhe che contengono la lettera a e quelle che 

contengono la lettera b. 

5. Posizionamento 

a. I caratteri ^ e $ identificano all'interno di un'espressione regolare rispettivamente inizio e fine riga. 

L'espressione regolare 'stringa$' stampa tutte le righe che terminano con stringa. 

L'espressione regolare '^stringa' stampa tutte le righe che iniziano con stringa. 

L'espressione regolare '^stringa$' stampa le righe costituite solo dalla parola stringa. 

b. I simboli \< e \> individuano rispettivamente l'inizio e la fine di una stringa. 

L'espressione regolare '\


A.A. 2012-2013 


Caratteri speciali della shell ed espressioni regolari 

Le espressioni regolari possono generare confusione perché utilizzano gli stessi caratteri speciali della shell, ma 

con significati a volte diversi. 

L'espansione dei caratteri speciali della shell viene sempre effettuata prima di eseguire un comando. Per 

preservare le espressioni regolari utilizzate da alcuni comandi (come ad esempio grep) da interpretazioni errate, è 

opportuno proteggerle con gli apici '…', evitando così che la shell interpreti i caratteri speciali di shell contenuti 

nell'espressione regolare. Questo è necessario anche quando i caratteri speciali hanno la stessa funzione. 

Caratteri speciali per le espressioni regolari 

Il carattere punto . è un carattere speciale che rappresenta qualsiasi carattere (lettera, cifra, spazio, tab, ...). 

N.B. La sintassi delle espressioni regolari differisce da quella del file globbing dove un singolo carattere è 

rappresentato dal carattere ?. 

I caratteri speciali all'interno di un'espressione regolare con le quadre [...] perdono di significato e vengono 

considerati letteralmente. 

L'espressione regolare '[\.*]' mostra le linee del file che contengono i caratteri .,\ e * e non zero o più occorrenze 

del carattere . (vedi sezione Operatori di ripetizione). 

Operatori di ripetizione 

Un'espressione regolare che genera una corrispondenza con un singolo carattere può essere seguita da uno o più 

operatori di ripetizione. 

Il carattere * viene specificato per cercare un'espressione ripetuta un numero qualsiasi di volte (anche zero). 

N.B. Notare la differenza con il carattere * del file globbing! 

L'espressione regolare 'ab*c' visualizza le righe che contengono le stringe {ac,abc,abbc,abbbc,ab...bc}. 

Il carattere ? viene specificato per cercare un'espressione ripetuta al più una volta (anche zero) 

L'espressione regolare 'ab?c' visualizza le righe che contengono le stringe {ac,abc}, ma non corrisponde alle 

stringhe {abbc,abbbc,ab...bc}. 

Il carattere + viene specificato per cercare un'espressione ripetuta almeno una volta. 

L'espressione regolare 'ab+c' visualizza le righe che contengono le stringhe {abc,abbc,abbbc,ab...bc}, ma non 

corrisponde alla stringa {ac}. 

L'espressione {n} viene specificata per cercare un'espressione ripetuta esattamente n volte. 

L'espressione 'ab{2}c' visualizza le righe che contengono le stringhe {abbc}, ma non corrisponde alle stringhe 

{ac,abc,abbbc,ab...bc}. 

L'espressione {n,m} viene specificata per cercare un'espressione ripetuta almeno n volte e al più m volte. 

L'espressione regolare 'ab{2,5}c' visualizza le righe che contengono le stringhe {abbc,abbbc,abbbbc,abbbbbc}, 

ma non corrisponde alle stringhe {ac,abc,abbb...bbc}. 

L'espressione {n,} viene specificata per cercare un'espressione ripetuta almeno n volte. 



A.A. 2012-2013 


L'espressione regolare '\' visualizza le righe contenenti stringhe che cominciano con numeri 

aventi almeno quattro cifre. 

Regole di precedenza degli operatori 

Nell'interpretazione delle espressioni regolari le operazioni sulle espressioni vengono valutate nel seguente 

ordine 

1) ripetizione 

2) concatenazione 

3) alternanza 

Le parentesi tonde possono essere utilizzate per modificare quest'ordine predefinito. 

L'espressione regolare 'a|bc+', esplicitando l'ordinamento delle operazioni, equivale a: '(a|(b(c+)))' overo ricerca 

stringhe del tipo {a, bc, bcc, bccc...}. 

Con le parentesi tonde possiamo modificare l'ordinamento delle operazioni: 

con 'a|(bc)+' ricerchiamo stringhe del tipo {a, bc, bcbc...}; 

con '(a|b)c+' ricerchiamo stringhe del tipo {ac..., bc...}. 

Comandi di ricerca di stringhe 

grep 

Il comando grep (Global Regular Expression Print) viene utilizzato per cercare stringhe all'interno di un file. 

SINTASSI: $ grep [opzioni] 'pattern' [file] 

pattern è un'espressione regolare. Se il file non è specificato, grep opera sullo standard input. 

Opzioni: 

-v Stampa le righe che non contengono stringhe corrispondenti al pattern 

-n Antepone il numero di riga 

-c Visualizza soltanto quante righe contengono stringhe corrispondenti al pattern 

-i Rende il comando case-insensitive 

--color Evidenzia, colorandola, l'occorrenza del pattern all'interno della riga 

-E Abilita l'interpretazione di espressioni regolari estese 

I caratteri ?, +, {, }, |, (, e ), se utilizzati con grep che interpreta espressioni regolari base (in assenza dell'opzione 

-E), vanno preceduti dal carattere di escape \. Se si utilizzano con egrep o con l'opzione -E di grep, che abilita 

l'interpretazione di espressioni regolari estese, non è necessario anteporre il carattere \. La differenza è solo nella 

sintassi dell'espressione regolare non nella sua funzionalità: $ grep 'a\+' equivale a $ egrep 'a+'. 

Quando si proteggono gli argomenti del pattern di grep con gli apici singoli, si preclude l'utilizzo di variabili. In 

alcuni casi si possono utilizzare gli apici doppi, che non impediscono la sostituzione della variabile con il suo 

valore. 

$ grep “^$USER:” /etc/passwd (si veda la sezione Variabili) 

Esempi: 

Sia dato il seguente file di test denominato 'file': 

fughe 

coda 

bada 

MAIUSCOLE 

a1 


a2 

a3 

a4 

a5 

a6 

a7a8 

a9 

stringa 

stringa stringato costringa 

ac 

abc 

abbc 

abbbc 

file.txt 

ciao a * 

exit 

^_^ 

a^ 

done 

matr 543672 

matr 543321 

matr 523455 

tel 0801234567 

prefix 080 

a 

b 

bc 

bcc 

bccc 

bcbcbc 

bacbc 

bac 

ac 

acc 

caa 

acac 


A.A. 2012-2013 


$ grep a file Mostra tutte le linee del file che contengono la lettera a almeno una volta in qualsiasi punto 

della riga 

$ grep . file Mostra tutte le linee del file che contengono almeno un carattere 

$ grep '[abcd]' file Mostra tutte le linee del file che contengono almeno una tra le lettere a,b,c,d 

$ grep '[âbcd]' file Mostra le linee del file che contengono lettere diverse da a,b,c,d 

fughe mostrata perché contiene f,u,g,h,e; coda mostrata perché contiene o; bada non mostrata perché 

non contiene lettere diverse da a,b,c,d; etc. 

Quale comando utilizzare per visualizzare tutte le righe che non contengono a, b, c e d? 

$ grep '[a-g]' file Mostra tutte le righe del file che contengono una lettera compresa tra a e g 



A.A. 2012-2013 


$ grep [[:upper:]] file Stampa tutte le righe che contengono un carattere maiuscolo 

$ grep 'ad' file Stampa tutte le linee del file che contengono la stringa ad 

$ grep 'a[1-5]' file Ricerca una stringa di tipo {a1,a2,a3,a4,a5} 

$ grep 'stringa$' file Stampa tutte le righe che terminano con stringa 

$ grep '^stringa' file Stampa tutte le righe che iniziano con stringa 

$ grep '^stringa$' file Stampa le righe che contengono soltanto stringa 

$ grep '\' file Stampa tutte le righe che contengono una parola che termina con stringa 

(stringa, costringa, ma non stringato) 

$ grep '\' file Cosa restituisce? 

$ grep 'ab*c' file Visualizza le righe che contengono le stringhe: ac, abc, abbc, abbbc, ab...bc 

$ grep '[\.*]' file Mostra le linee del file che contengono i caratteri .,\ e * e non zero o più occorrenze 

del carattere . 

file.txt mostrata perché contiene .; ciao a * mostrata perché contiene *; etc. 

$ grep '[a^b]' file Mostra le linee del file che contengono i caratteri a, ^ e b e non caratteri a seguiti da 

caratteri diversi da b 

^_^ mostrata perché contiene ^; a^ mostrata perché contiene a e ^; etc. 

$ egrep 'ab?c' file Visualizza le righe che contengono le stringhe: ac, abc; ma non corrisponde alle 

stringhe: abbc, abbbc, ab...bc. 

$ egrep 'ab+c' file Visualizza le righe che contengono le stringhe: abc, abbc, abbbc, ab...bc; ma non 

corrisponde alla stringa ac 

$ egrep 'ab{2}c' file Visualizza le righe che contengono le stringhe abbc, ma non corrisponde alle stringhe 

ac, abc, abbbc, ab...bc 

$ egrep 'ab{2,3}c' file Visualizza le righe che contengono le stringhe abbc e abbbc, ma non corrisponde alle 

stringhe ac, abc, abbbbc, abbb...bbc 

$ grep -E '\' file Visualizza le righe contenenti i numeri con più di quattro cifre 

$ egrep 'a|b' file Visualizza le righe che contengono stringhe contenenti la lettera a o la lettera b 

$ egrep 'a|bc+' file Visualizza le righe che contengono stringhe del tipo: a, bc,bcc... 

$ egrep 'a|(bc)+' file Visualizza le righe che contengono stringhe del tipo: a, bc, bcbc.... 

$ egrep '(a|b)c+' file Visualizza le righe che contengono le stringhe di tipo: ac..., bc... 



A.A. 2012-2013 


Esercizi 

Scrivere un comando per visualizzare nel file /etc/passwd le righe: 

1. che non contengono cifre pari; 

2. che corrispondono ad utenti con prima lettera compresa tra g e l, ordinate in ordine alfabetico; 

3. che contengono la lettera 'c' ripetuta minimo 1 volta e massimo 2 volte di seguito. 

4. Scrivere un comando per visualizzare nel file /etc/services le righe contenenti la parola 'ftp'. 

5. Scrivere un comando che mostri a video tutti i file regolari contenuti nella cwd che risultano accessibili in 

lettura al resto del mondo. 



A.A. 2012-2013 


Gestione utenti e gruppi 

Nei sistemi Unix gli utenti si dividono in: superuser (utente amministratore o root) e utenti regolari. L'utente root 

ha tutti i privilegi sul sistema e può aggiungere o rimuovere i privilegi agli altri utenti (diritti di accesso), così 

come creare nuovi utenti. 

Gruppi di utenti 

Ciascun utente di un sistema Unix appartiene ad uno o più gruppi. Ogni utente ha un unico gruppo di login 

(gruppo principale) di cui è titolare e può essere membro di più gruppi supplementari, a cui l'utente aderisce 

senza esserne il titolare. Su alcuni sistemi, l'appartenenza ad alcuni gruppi supplementari determina la possibilità 

di utilizzare alcune funzionalità del sistema (audio – utilizzare la scheda audio; video – utilizzare la webcam; 

dialout – utilizzare il modem e le porte seriali; dip – utilizzare connessioni ad internet via modem; etc.). Di fatto i 

gruppi servono per gestire con maggiore flessibilità l'accesso ai file e di conseguenza l'uso delle risorse. 

L'amministratore di sistema può creare un gruppo e gli account per gli utenti che amministreranno il gruppo. 

Il file /etc/group contiene l'elenco dei gruppi di utenti presenti nel sistema. Ad ogni gruppo è associata una riga 

nella quale si trova l'IDgroup e l'elenco degli utenti che ne fanno parte. Alcuni sistemi Linux, alla creazione di un 

nuovo utente, se non si specifica il gruppo principale, di default creano un gruppo con lo stesso nome dell'utente 

di cui l'utente diventa titolare. Altri sistemi hanno il gruppo "users" in cui vengono automaticamente inseriti tutti 

gli utenti aggiunti al sistema. Le righe di /etc/group si presentano nella seguente forma: 

GroupName:Password:GroupID:User1,User2,...,UserN 

GroupName Indica il nome del gruppo. 

Password Indica la password del gruppo. Solitamente non viene data una password al gruppo ma solo ai 

singoli utenti. 

GroupID Indica l'ID associato a quel gruppo. 

User1,...,UserN E' l'elenco degli users aventi tale gruppo come gruppo supplementare. I nomi dei singoli users 

devono essere sparati da una virgola. 

groupadd 

Crea un nuovo gruppo. Il nuovo gruppo verrà aggiunto ai file di sistema necessari. 

SINTASSI: # groupadd [opzioni] nome_gruppo 

Opzioni: 

[-o] -g #gid Specifica il valore numerico dell'identificatore del gruppo (#gid). Deve essere univoco, a 

meno che si usi l'opzione -o. 

groupdel 

Modifica i file di account del sistema, rimuovendo tutte le voci che si riferiscono al nome del gruppo specificato 

(che si suppone esistente). Non è possibile rimuovere il gruppo primario di un utente senza aver rimosso prima 

quest'ultimo. 

SINTASSI: # groupdel nome_gruppo 

groupmod 

Modifica la definizione di un gruppo sul sistema. 

SINTASSI: # groupmod [opzioni] groupName 

Opzioni: 

[-o] -g #gid Modifica l'id del gruppo groupName in #gid. Il flag -o consente l'uso di un #gid non univoco. 

-n group_name Modifica il nome del gruppo groupName nel nuovo nome group_name. 



A.A. 2012-2013 


Ogni account utente è caratterizzato da: username (pubblico), userid (pubblico), password (privata), groupname 

(pubblico), groupid (pubblico). 

useradd 

Comando di basso livello per la creazione di un nuovo utente (analogo alla procedura guidata offerta dal 

comando adduser nomeutente). 

SINTASSI: # useradd [opzioni] nomeUtente 

Opzioni: 

-d home_dir Setta la home-directory dell'utente 

-m Crea la home-directory dell'utente 

-k /etc/skel Copia i file i file predefiniti nella home del nuovo utente 

-e #YYYY-MM-DD Imposta la data di scadenza dell'account 

-f giorni_inattività Indica il numero di giorni, che intercorrano fra la data di expire della password e la 

disabilitazione dell'account 

-g/--gid nome_gruppo/#gid Nome o #gid del gruppo principale assegnato al nuovo utente. Tale gruppo 

deve esistere! 

-G gruppo1[,gruppo2,...,gruppoN] Lista di gruppi supplementari assegnati all’utente. Tali gruppi devono esistere 

-p password_criptata Setta la password per il nuovo utente. La password inserita dev'essere la versione 

crittografata (hash MD5) 

-s defaultShell Nome della shell di login dell’utente 

[-o] -u #uid Valore numerico assegnato all’id utente. Dev'essere univoco a meno che non si usi 

l'opzione -o. 

-D [opzioni] Modifica le impostazioni di default di un nuovo utente 

# useradd -d /home/ciccio -m -k /etc/skel -g 100 -s /bin/bash ciccio 

passwd 

Comando che permette di settare o modificare la password di un utente. L'utente root può modificare le 

password di ogni utente, mentre gli utenti normali possono modificare solo la propria. 

SINTASSI: # passwd [opzioni] nomeutente 

Opzione: 

-d Disabilita la password per l'utente 

Il file /etc/passwd è il database degli utenti su ogni sistema Unix. Ad ogni user è dedicata una riga che definisce 

quali sono i suoi principali attributi. Sui sistemi Unix meno recenti in questo file viene scritta anche la password 

(criptata); su quelli più recenti essa viene scritta, generalmente, in /etc/shadow, che ha maggiori restrizioni in 

termini di sicurezza (visualizzate i diritti associati al file /etc/passwd). 

Le righe di /etc/passwd si presentano nella seguente forma: 

Username:Password:UserID:GroupID:Info:HomeDirectory:Shell 

Username Nome di login al sistema dell'utente 

Password Campo riservato alla password dell'utente. Può essere scritta direttamente in forma criptata o 

esserci semplicemente una x (la password c'è ma è scritta altrove, di solito in /etc/shadow). Se 

c'è un * significa che l'utente o non ha una password o la password non è valida (in questo caso 

non gli è permesso il login) 

UserID ID dell'user 

GroupID ID del gruppo di appartenenza 

Info Contiene informazioni sull'utente non necessarie al sistema (nome esteso, numero di telefono, 

mail,etc...) 

HomeDirectory Indica la directory della home dell'utente 

Shell Indica la shell di default per l'utente 



A.A. 2012-2013 


Storicamente su Unix il file /etc/passwd conteneva l'elenco di tutti gli utenti e la loro password in forma criptata. 

Per la stessa natura di Unix, tutti gli utenti devono poter aver accesso in lettura a questo file, per cui esporre le 

password di tutti, seppur criptate, risultava rischioso per la sicurezza del sistema. 

Su tutti i sistemi Linux e Unix recenti, la gestione della password è stata migliorata sia in termini di sicurezza 

che di versatilità, affiancando al normale /etc/passwd la gestione del file /etc/shadow che introduce nuove 

funzionalità (vedi i diritti associati al file /etc/shadow e confronta con /etc/passwd). Questo file è leggibile solo 

dal root, mentre viene lasciato l'accesso in lettura a /etc/passwd per tutti gli utenti. Le password in /etc/shadow 

sono criptate con algoritmi più complessi e robusti. È possibile gestire il tempo di scadenza, la durata minima e 

massima e i tempi di notifica della password. 

Il file /etc/shadow è il database delle password sui sistemi Unix più evoluti. In esso sono elencate, per ogni 

utente, la password (criptata) e vari parametri ad essa connessi (ultima modifica, durata massima e minima, 

ecc...). Ad esso fanno riferimento diversi files, fra cui /etc/passwd e tutti i comandi per la gestione degli utenti 

(useradd, userdel, usermod). 

Le righe in /etc/shadow si presentano nella seguente forma: 

Username:password:lastchange:min:max:warn:inactive:expire 

Username Il nome dell'utente a cui fa riferimento la password 

Password Password criptata (13 caratteri). Può assumere anche altri valori quali * che sta ad indicare che 

l'utente è disabilitato e !! (o nessun carattere) che indica che l'utente non ha password 

lastchange Numero di giorni compresi fra il 1 gennaio 1970 e l'ultima modifica della password 

min Minimo numero di giorni dall'ultima data di modifica prima di poter nuovamente cambiare la password 

max Durata massima della password (sempre in giorni) 

warn Numero di giorni di preavviso all'utente prima di invalidare la password 

inactive Numero di giorni di inattività possibili per l'utente 

expire Data dopo la quale il login non può più essere effettuato 

userdel 

Rimuove l'account di un utente, ma non i file relativi. 

SINTASSI: # userdel [opzioni] nome_utente 

Opzioni: 

-r Rimuove anche i file della home_directory utente 

usermod 

Comando che permette di cambiare le impostazioni di un account creato precedentemente. L'utente che lancia il 

comando deve possedere i privilegi di amministratore. 

SINTASSI # usermod [opzioni] login-name 

Opzioni: 

-d home_dir Modifica la home_dir dell'utente 

-e expire_date Modifica l'expire_date 

-f inactive_days Modifica il numero di giorni che intercorrono fra la scadenza della password e la disabilitazione 

dell'account 

-g initial_group Modifica il gruppo primario 

-G groups Modifica i Gruppi secondari 

-l login Cambia il nome di login dell'utente 

-p password Modifica la password criptata (sconsigliato) 

-s shells Modifica la shell di default dell'utente 

-u UID Modifica l'UID 

-L Esegue il lock dell'account 

-U Operazione inversa del lock, ovvero riabilita l'account 



A.A. 2012-2013 


su (substitute user) 

Cambia id utente o diventa superuser, se il nome utente non è specificato. 

SINTASSI: $ su [opzioni] [nomeutente] 

Opzioni: 

-l Fornisce un ambiente simile a quello di login dell'utente 

$ su (si intende root) 

Esercizi 

1. Creare un nuovo gruppo di nome 'new' assegnando l'id 1001 che corrisponde al gid di un gruppo esistente. 

2. Creare un nuovo utente con lo stesso nome del gruppo appena creato e assegnargli il gruppo new. 

3. Cambiare il gruppo principale dell'utente appena creato in userA e assegnare l'utente al gruppo supplementare 

supA. 

4. Rimuovere il gruppo creato all'esercizio 1. Viene rimosso anche il gruppo con #gid=1001? 

5. Definire una serie di comandi che consentano di creare manualmente un nuovo utente, senza far ricorso ai 

comandi useradd o adduser. Si suppone che il comando di riferimento sia: 

useradd -u 1006 --gid 1007 -d /home/ciccio -m -k /etc/skel -s /bin/bash ciccio 

a. Loggarsi come amministratore 

b. Editare il file /etc/passwd 

ciccio:x:1006:1007::/home/ciccio:/bin/bash 

c. Editare il file /etc/group 

ciccio:x:1007 

d. Editare il file /etc/shadow 

ciccio:......:15482:0:999:7::: 

e. Creare la home directory 

mkdir /home/ciccio 

f. Inizializzare i file della home 

cp /etc/skel/* /home/ciccio 

g. Cambiare il proprietario della home directory 

chown ciccio:ciccio /home/ciccio 

h. Cambiare i diritti di accesso alla home directory 

chmod 700 /home/ciccio 

i. Impostare una password per l'utente ciccio 

passwd ciccio 

Comandi informativi 

Consentono di ottenere dal sistema informazioni sugli utenti. 

id 

Mostra gli identificatori numerici (uid, gid, groups), e i nomi simbolici ad essi associati, dell'utente indicato 

come argomento. 

SINTASSI: $ id [opzioni] [nomeutente] 

Opzioni: 

-u Filtra sull'utente (mostra solo l'id) 

-g Filtra sul gruppo principale (mostra solo l'id) 

-G Filtra sui gruppi supplementari (mostra solo l'id) 

-n Se utilizzato assieme a -u, -g e -G mostra solo il nome anzichè l'id numerico 

silvia@ubuntu:~ id silvia 


whoami 

Mostra chi è l'utente della shell 

SINTASSI: $ whoami 


A.A. 2012-2013 


who 

Mostra tutti gli utenti correntemente connessi al sistema e i relativi dati (nome del terminale, data-ora) 

SINTASSI: $ who [opzioni] 

Opzioni: 

-a Mostra tutti gli utenti 

-l Mostra il login dei processi di sistema 

-q Mostra il nome degli utenti loggati e il loro numero complessivo 

-r Mostra il runlevel corrente 

groups 

Mostra i nomi dei gruppi a cui appartiene l'utente correntemente loggato o di quello specificato. 

SINTASSI: $ groups [nome_utente] 

last 

Lista gli ultimi login/logout degli utenti sul sistema e gli ultimi riavvii del sistema, interpellando il file 

/var/log/wtmp, altrimenti non visualizzabile. 

Visualizza: nome utente, console di login, identificativo del display, kernel, data di login, tempo di permanenza. 

SINTASSI: $ last [nomeutente] 

$ last root 



A.A. 2012-2013 


Variabili 

Permettono di memorizzare stringhe ed interi. I nomi sono case sensitive e possono contenere lettere, cifre e 

underscore '_', ma non spazi o punteggiatura; non possono iniziare con una cifra. 

Definizione 

SINTASSI: $ nomevar=valore 

$ a=5 

$ msg=”Benvenuti alla” 

Il valore di una variabile viene visualizzato attraverso il comando echo seguito dal nome della variabile 

preceduto dal simbolo $. Per delimitarne il nome si usano le parentesi graffe. 

$ echo $msg ${a}a lezione 

Benvenuti alla 5a lezione 

Variabili d'ambiente 

L'ambiente è un insieme di variabili che condizionano un processo eseguito dalla shell. Una variabile d'ambiente 

contiene valori di comodo caratteristici dell'ambiente di shell di un dato utente, è visibile a tutti i programmi 

eseguiti dalla shell, fornisce informazioni ai programmi ed eventualmente ne condiziona l'esecuzione. 

printenv 

Il comando printenv (print environment) stampa l'elenco delle variabili d'ambiente. Se provvisto di argomento, 

stampa il valore della variabile d'ambiente. 

SINTASSI: $ printenv [nomevariabile] 

USER Utente che esegue la bash 

HOME Home directory dell'utente che esegue la shell 

PS1 Prompt 

HOSTNAME Nome del computer 

SHELL Pathname assoluto della shell in uso 

PWD Percorso della cwd 

OLDPWD Percorso della directory precedentemente visitata 

UID Identificativo numerico dell'utente loggato 

GROUPS Vettore degli ID dei gruppi a cui l'utente appartiene 

PPID Process ID del processo genitore della shell attuale 

PATH 

La variabile PATH contiene i percorsi in cui la shell ricerca gli eseguibili dei comandi, memorizzati sottoforma 

di elenco di directory separate da due punti. Il valore di default per tutti gli utenti è impostato 

dall'amministratore. L'utente può modificarla nel corso dell'esecuzione inserendo un path a cui fa spesso 

riferimento o fare in modo che venga modificata ad ogni avvio. Tale variabile serve ad evitare che l'utente che si 

interfaccia con la shell debba scrivere per ogni comando tutto il percorso. 

# echo $PATH 

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin 

$ echo $PATH 

/usr/local/bin:/usr/bin:/bin:/usr/games 

Nell'esecuzione di un comando distinguiamo 2 casi. 



A.A. 2012-2013 


1) Quando il comando non contiene il carattere '/', la shell tenta di localizzarlo mediante i seguenti passi: 

a. verifica che il comando sia una funzione della shell; 

b. verifica che sia un comando incorporato (built-in); 

c. cerca nelle directory specificate nell'ordine in cui sono elencate nella variabile PATH un file 

eseguibile con il nome specificato. La shell esegue il primo file eseguibile con il nome specificato che 

trova. 

2) Quando il comando contiene uno o più '/', la shell esegue il programma corrispondente al pathname 

specificato. Quando si specifica il pathname per eseguire un comando, è necessario utilizzare almeno un 

carattere '/'. 

Per eseguire un comando il cui file è nella directory corrente, sarà necessario utilizzare la sintassi ./nome_file. 

Per ovviare a questo problema è possibile inserire la directory '.' nella variabile PATH. 

Exit status (?) 

Ogni comando shell, al termine dell'esecuzione, fornisce un exit status ovvero un valore intero compreso tra 0 e 

255 che ne descrive l'esito dell'esecuzione. Per convenzione: 

0 indica che il programma è stato eseguito con successo; 

[1-255] indica che il programma non è terminato correttamente (il significato del valore dell'exit status è 

descritto nella pagina di manuale). 

La shell memorizza l'exit status dell'ultimo comando eseguito nella variabile ?. 

$ cat /etc/shadow 

$ echo $? 

1 

export 

Per rendere d'ambiente una variabile dichiarata si usa il comando export. 

L'assegnazione o la creazione di una variabile ha validità solo nel'ambito della shell stessa. 

SINTASSI: $ export nome[=valore] 

set/unset 

Il comando set visualizza tutte le variabili definite nella shell in esecuzione, anche quelle create manualmente. 

Il comando: 

SINTASSI: $ unset nomevariabile 

rimuove la variabile. 

Esercizi 

1. Copia il file /bin/echo nella tua home directory ed eseguilo con gli argomenti “Hello World!” 

2. Aggiungi alla variabile PATH la directory '.' facendo in modo che il comando echo eseguito sia sempre quello 

della copia nella tua home directory. 



A.A. 2012-2013 


Visualizzazione ed editing di file 

cat 

Il comando cat (concatenate) legge ogni file argomento in sequenza e mostra sullo standard output il contenuto, 

ovvero concatena file. L'operazione non genera alcun file e si utilizza per controllare il contenuto di file testuali. 

SINTASSI: $ cat [opzioni] file 

Opzione: 

-n Numera le righe sullo stdout 

Esempio: 

file1: Questo è il primo file 

file2: Questo è il secondo file 

$ cat file1 

$ cat file1 file2 

file 

Visualizza il tipo di uno o più file. 

SINTASSI: $ file file_esempio 

user@ubuntu:~$ file ./* 

./esempio_sort_num.txt: ASCII text 

./esempio_sort.txt: ASCII text 

./esempio_uniq.txt: UTF-8 Unicode text 

./file_esempio.txt: ASCII text 

Esercizio: Che tipo di file è il file /var/log/wtmp? 

less (more) 

Visualizza un file in modo interattivo. Apre il paginatore e formatta il testo in pagine per facilitarne la lettura. 

SINTASSI: $ less nomefile 

more è un paginatore alla stregua di less, ma consente solo lo scorrimento delle pagine in avanti. 

N.B. I paginatori si possono scorrere con i tasti invio, spazio e frecce. Per uscire dal paginatore si usa Q. Per 

chiedere l'help del paginatore si usa H. 

$ ls -l | less (Si veda la sezione Operatori di redirezione) 

Esercizi 

1. Visualizzate il contenuto del file /etc/passwd. 

2. Visualizzate l'inizio e la fine del file /etc/passwd attraverso un paginatore. 

3. Determinare la tipologia dei file /etc/passwd e /bin/ls. 



A.A. 2012-2013 


Canali di comunicazione e ridirezione 

I programmi dispongono di 3 canali di comunicazione standard (standard file descriptor): 

0 Standard input (tastiera) 

1 Standard output (terminale) 

2 Standard error (terminale) 

La shell consente il reindirizzamento dei 3 canali standard all'interno di file con la sintassi: 

$ comando operatore file 

Operatori di ridirezione dello standard output 

Ridirige lo std output del comando sul file. Se il file non esiste, viene creato; se il file esiste, viene sovrascritto 

(>) oppure il nuovo output viene accodato (>>). 

SINTASSI: $ comando > file 

> ridirige lo standard output in modalità truncate 

SINTASSI: $ comando >> file 

>> ridirige lo standard output in modalità append 

$ who 

$ who > whofile 

$ cat whofile 

$ ls -l > stdout.txt 

$ cat stdout.txt 

$ echo parola esempio >> file_prova 

$ cat file1 file2 > file3 

Operatori di ridirezione dello standard error 

Ridirige lo std error del comando su file. Se il file non esiste, viene creato; se il file esiste, viene sovrascritto (2>) 

oppure il nuovo output viene accodato (2>>). 

SINTASSI: $ comando 2> file 

2> ridirige lo standard error in modalita truncate 

SINTASSI: $ comando 2>> file 

2>> ridirige lo standard error in modalità append 

Operatori di ridirezione dello standard input 

Ridirige lo std input del comando su file, cioè fa sì che l'input di un comando provenga, anziché da tastiera, da 

un file. 

SINTASSI: $ comando < file 

< ridirige lo standard input 

$ grep 'ciao' /home/silvia/file 

$ grep 'ciao' < /home/silvia/file 

L'interprete standard di comandi (sh), permette di eseguire comandi letti da una stringa a riga di comando (-c), 

dallo standard input (-s) o da un file specificato. 


comandi 

pwd 

ls 

echo “comandi“ 

mkdir redirectdir 

$ sh < comandi 


A.A. 2012-2013 


SINTASSI: $ comando (&>>) 

SINTASSI: $ comando &> filename 

Più reindirizzamenti possono essere effettuati nella stessa linea di comando: 

$ comando < in > out 2> err 

Operatore di pipeline 

Canale di ridirezione che collega lo standard output di un programma allo standard input di un altro (vedi figura). 

Utilizza il simbolo |. 

SINTASSI: $ comando1 | comando2 | … 

$ ls -l /etc | less 

Liste di comandi 

Sulla stessa linea di comando è possibile eseguire una lista di comandi separandoli con caratteri speciali. 

Tipi di esecuzione: 

sequenza 

SINTASSI: $ comando1 ; comando2 



A.A. 2012-2013 


Indipendentemente dal loro exit status, con ';' i due comandi vengono eseguiti in sequenza (prima comando1 e 

poi comando2) . 

$ env > env-silvia ; cp env-silvia /tmp/ 

$ ls -l /tmp/env-* env-* (Per verifica) 

$ (date;ls) > compfile 

concorrenza 

SINTASSI: $ comando1 & comando2 

Il comando1 viene eseguito in background, il comando2 in foreground (si veda la sezione Gestione dei processi). 

condizione 

SINTASSI: $ comando1 && comando2 

Il comando1 viene eseguito sempre; il comando2 soltanto se il primo è terminato con successo (exit status 0). 

Supponiamo che il file /tmp/env1 non esista 

$ cp /tmp/env-silvia1 . && cat env-silvia1 env-silvia > env-silviax2 

In questo caso cat non viene eseguito perche' cp non ha trovato il file da copiare. Una volta generato il file da 

copiare, eseguendo lo stesso comando il cat verrà eseguito perché cp terminerà senza errori. 

esclusione 

SINTASSI: $ comando1 || comando2 

Il comando1 viene sempre eseguito; il comando2 soltanto se il primo è terminato con exit status diverso da 0. 

$ chown silvia /tmp/env-vito || rm -f env-silvia 

In questo caso il secondo rm viene eseguito perché l'utente corrente non può cambiare il proprietario di un file. 

$ rm -f /tmp/env-silvia || rm -f env-silvia1 

In questo caso il secondo rm non viene eseguito perché il primo rm termina senza errori. 

Exit status di liste di comandi 

Quando si eseguono più programmi in una sola linea di comando (come nelle pipeline o nelle liste di comandi), 

l'exit status è relativo all'ultimo comando eseguito. 

Script BASH 

Non c'è differenza tra quello che si può scrivere utilizzando la shell interattivamente o mediante uno script. 

Uno script di shell BASH è un file di testo che: 

- contiene comandi di shell; 

- inizia con la stringa “#!/bin/bash”; 

- ha permesso di esecuzione. 

I primi due caratteri #! indicano che il file è uno script o più in generale un programma interpretato. La stringa 

successiva è il pathname dell'interprete per il programma. 

La shell esegue l'interprete specificato nella prima linea passandogli come argomento il nome dello script. 



A.A. 2012-2013 


Filtri e programmi di utilità generica 

I programmi introdotti qui di seguito, così come cat, less e quasi tutti i comandi Unix, in mancanza di specifiche 

diverse fornite a linea di comando effettuano una trasformazione sullo standard input. 

sort ordina le linee di un file di testo 

wc è un programma che permette di contare caratteri, parole e linee 

head e tail estraggono linee da un file di testo 

uniq elimina linee ripetute consecutive da un file 

cut estrae sezioni di una riga di testo 

diff confronta due file di testo 

grep seleziona linee di specificata struttura (vedi sezione Comandi di ricerca di stringhe) 

sort 

Ordina il file ottenuto concatenando i file indicati, e scrive il risultato sullo standard output. Se non è indicato 

alcun file, ordina lo standard input. 

SINTASSI: $ sort [opzioni] [file1 ... fileN] 

Opzioni: 

-b Ignora i blank iniziali (spazi e tabulazioni) 

-c Controlla se i file indicati sono già ordinati. Se non lo sono, viene emessa una segnalazione di errore 

e il programma mostra la prima riga che non rispetta l'ordine. 

-d Dictionary order: ignora tutti i caratteri che non siano lettere, numeri o spazi 

-f Non distingue tra lettere maiuscole e minuscole 

-i Ignora i caratteri speciali al di fuori del set ASCII puro (ignora caratteri non stampabili) 

-m Fonde insieme i file indicati che devono essere già ordinati (non effettua ordinamento) 

-n Sort numerico: considera anche il segno meno e il punto decimale 

-r Reverse: inverte il senso di ordinamento 

-o file Utilizza il file indicato per inserire il risultato dell'operazione, invece di utilizzare lo standard output 

$ cat numeri 

10 

1 

2 

5 

77 

750 

8 

$ sort numeri 

$ sort -r numeri 

$ sort -n numeri 

$ cat esempio_sort.txt 

RIGA A 

RIGA B 

RIGA D 

RIGA C 

$ sort esempio_sort.txt 

$ sort -c esempio_sort.txt 

$ sort numeri esempio_sort.txt > sort1 

$ sort -o sort numeri esempio_sort.txt 

$ cat esempio_sort_num.txt 

1.1 

100 


5 

11 

$ sort esempio_sort_num.txt 

$ sort -n esempio_sort_num.txt 


A.A. 2012-2013 


wc 

Conta e mostra il numero di linee (-l), il numero di parole (-w), il numero di caratteri (-m) e il numero di byte 

(-c) di uno o più file. L'opzione di default è -lwc (righe, parole e byte). 

SINTASSI: $ wc [-lwmc] [file] 

Formato risposta: [righe] [parole] [caratteri] [byte] nome_file 

I campi restituiti dalla risposta vengono mostrati sempre nell'ordine del formato della risposta, 

indipendentemente dall'ordine di inserimento dei flag nel comando. Semplicemente viene effettuato un filtro dei 

campi mostrati a seconda che vengano o meno inseriti tutti i flag. 

$ cat elencotel 

roberto 48000529 

marco 3452328 

mario 5567843 

luigi 67421467 

$ wc elencotel 

4(n.linee) 8(n. parole) 60(n. byte) elencotel 

$ wc -w -l -m -c esempio_uniq.txt 

6 37 209 215 esempio_uniq.txt 

head 

Copia le prime X linee o byte di un file sullo standard output (default X=10). Se nessun file è specificato, copia 

linee dallo standard input. 

SINTASSI: $ head [opzioni] [filename] 

Opzioni: 

-c #X Mostra i primi #X byte di un file 

-c -#X Mostra i byte di un file esclusi gli ultimi #X byte 

-n #X Mostra le prime #X righe di un file (equivale a -#X) 

-n -#X Mostra le righe di un file escluse le ultime #X 


$ head -1 elencotel (equivale a $ head -n 1 elencotel) 

$ head -n -1 elencotel 

$ head -c 6 file_esempio.txt 

15 fif 

tail 

Copia il file sullo standard output, iniziando da un posto specificato (linee, blocchi o caratteri dall'inizio o dalla 

fine del file). Se non è specificato nessun file, copia lo standard input. Mostra le ultime righe o byte di un file, di 

default le prime 10 righe. 

SINTASSI: $ tail [opzioni] [file] 

Opzioni: 

-c #X Mostra gli ultimi #X byte di un file 

-c +#X Mostra gli ultimi byte di un file a partire dal byte #X 



A.A. 2012-2013 


-n #X Mostra le ultime #X righe di un file (equivale a -#X) 

-n +#X Mostra le ultime righe di un file a partire dalla riga #X 


$ tail -c +3 elencotel 

$ tail -n 3 elencotel 

$ tail -c 3 file_esempio.txt 

ne (l'ultimo byte è EOF!) 

$ tail -n +13 file_esempio.txt 

3 three 

2 two 

1 one 

and mission... 

uniq 

Mostra od omette le linee ripetute. Se non è specificato nessun flag, visualizza tutte le righe senza ripetizioni. 

SINTASSI: $ uniq [opzioni] file 

Opzioni: 

-c Per ogni riga indica il numero di occorrenze 

-d Mostra solo le linee duplicate 

-f N Salta il confronto delle prime N parole 

-i Nel confronto ignora la differenza tra lettere maiuscole e minuscole 

-s N Salta il confronto dei primi N caratteri 

-u Mostra solo le linee uniche non duplicate 

-w N Confronta non più di N caratteri per riga 

$ cat esempio_uniq.txt 

Questa riga è presente una sola volta. 

Questa riga è presente due volte. 

Questa riga è presente due volte. 

Questa riga è presente tre volte. 



$ uniq esempio_uniq.txt 

$ uniq -cd esempio_uniq.txt 

$ uniq -u esempio_uniq.txt 

$ uniq -cs 22 esempio_uniq.txt 

cut 

Permette di estrarre sezioni di una riga di testo, delimitate da un carattere separatore. 

SINTASSI: $ cut [opzioni] [file] 

Opzioni: 

-b range Estrae solo i byte indicati nel range (N, N-M, -N, N-) 

-c range Estrae solo i caratteri indicati nel range (N, N-M, -N, N-) 

-d separatore Indica il carattere/stringa separatore da utilizzare (anzichè TAB) 

-f intervallo Indica la lista dei campi da estrarre (N, N-M, -N, N-) 

$ cat cut_file 

nome cognome matricola 

pippo pluto 123456 


ciccio pallino 098765 

$ cut -f 2 cut_file 


A.A. 2012-2013 


$ cat cut_file_delim 

nome;cognome;matricola;email;CDL 

pippo;pluto;123456;p.p@p.it;AUT 

ciccio;pallino;098765;ciccio@gmail.com;INF 

$ cut -d \; -f 2-3,5 cut_file_delim 

Considera ogni riga composta da più stringhe separate dal (;) e ne visualizza solo la seconda, la terza e la quinta. 

diff 

Trova differenze tra due file. Questo comando risulta molto utile per confrontare i file di configurazione. Se si 

sostituisce a uno dei file da confrontare il trattino (-), questo indica che il confronto verrà eseguito con lo 

standard input. 

SINTASSI: $ diff [opzioni] file1 file2 

Opzioni: 

-b Ignora le differenze nella quantità di spazi bianchi 

-B Ignora le differenze che consistono solo in righe vuote 

-r Confrontando due directory, confronta ogni sottodirectory ricorsivamente 

--brief Riferisce solo se i file sono diversi, senza mostrarne le differenze 

--ignore-case Considera allo stesso modo maiuscole e minuscole, ignorando ogni relativa differenza 

$ diff –brief /etc/passwd /etc/shadow 

colordiff 

Il comando ha le stesse opzioni ed effetti di diff ma mostra un output colorato che permette una maggiore 

leggibilità. 

Esercizi 

1. Conta il numero di linee contenute nel file /etc/passwd 

2. Visualizza le righe del file /etc/passwd in ordine alfabetico 

3. Nella pagina di manuale di sort trova l'opzione per l'ordinamento numerico 

4. Conta i file che terminano con '.log' nella directory /var/log 

5. Sapendo che l'opzione '-k POS' del comando sort consente di ordinare le righe di un testo in base al k-esimo 

campo, ordina i file nella tua directory in base al numero di link e visualizza l'elenco con less. 

6. Visualizza i file in /etc e le relative informazioni ordinati per dimensione. 

7. Crea un file contenente tutte le variabili di ambiente denominato env-MATR e copialo sotto /tmp. Concatena i 

due file e visualizza il contenuto ordinato senza mostrare le linee ripetute. Visualizza prima le linee che non 

presentano, ripetizioni poi quelle ripetute. 


Avvio del sistema 


A.A. 2012-2013 


Gestione dei processi 

Il BIOS (Basic Input Output System) è l'insieme di routine eseguite all’avvio del sistema e che svolgono funzioni 

di collegamento tra il software e l’hardware (controllano la presenza di RAM, le periferiche IDE, la tastiera, 

etc.). Il BIOS si occupa di caricare il primo settore (Master Boot Record) del primo cilindro del dispositivo di 

boot (di default il primo hard disk del primo canale IDE) ed esegue le istruzioni in esso contenute, cedendo il 

controllo del sistema al Boot Loader, un piccolo programma contenuto nei primi 512 byte del Master Boot 

Record che si occupa di caricare il kernel in memoria ed eseguirlo. 

Un singolo boot loader è in grado di caricare molti tipi di kernel e quindi anche diversi sistemi operativi presenti 

in partizioni differenti. Naturalmente può essere caricato un solo kernel per volta. 

Il kernel di GNU/Linux, cioè Linux, è in grado di accettare parametri da riga di comando. Una volta avviato, si 

decomprime, esamina ed elabora i parametri passati ed avvia /sbin/init. Il processo init è il primo processo 

eseguito subito dopo la fase di bootstrap del sistema, dopo che il kernel è stato caricato, ed è avviato direttamente 

dal kernel. 

init viene spesso denominato il genitore di tutti i processi presenti su un sistema GNU/Linux (più correttamente è 

l'avo di tutti i processi), rimane attivo per tutto il funzionamento del sistema ed ha il compito di inizializzare e 

gestire il sistema ad un livello più alto di quello del kernel, per permetterne l'utilizzo da parte degli utenti. 

Il suo ruolo fondamentale è quello di eseguire tutti i processi necessari al funzionamento del sistema secondo le 

direttive specificate nel file /etc/inittab, in cui ogni riga ha una struttura di tipo id:runlevel:action:process: 

id: identificatore univoco della riga; 

runlevel: elenco dei runlevel per i quali il comando specificato deve essere applicato; 

action: azione da intraprendere da parte di init; 

command: nome del file eseguibile associato all'azione. 

init svolge una serie di compiti amministrativi fondamentali per il funzionamento del sistema e non può mai 

essere terminato. La riga contenente la direttiva sysinit è indipendente dal runlevel corrente ed è associata ad un 

file eseguibile che si occupa di eseguire le operazioni preliminari, di configurazione del sistema. 

Successivamente vengono avviati i servizi per l’utilizzo del sistema, i deamon. 

/etc/inittab contiene solitamente istruzioni per l'attivazione dei terminali e la specifica del runlevel di default. 

Runlevel 

Linux può funzionare in modalità diverse, ovvero la sua esecuzione dipende dal valore di un parametro 

importantissimo detto runlevel, per mezzo del quale init cambia la modalità di funzionamento del sistema. Un 

runlevel è una configurazione software che specifica i servizi da attivare o disattivare sul sistema. 

I valori di runlevel riservati sono: 

0: halt, spegnimento del sistema 

1: single user mode 

6: reboot, riavvio del sistema 

Quelli configurabili vanno dal 2 al 5 e ciascuna versione di UNIX o distribuzione di Linux attribuisce loro un 

significato (3: full multi user; 5: full multi user + sessione grafica). 

Il comando 

SINTASSI: $ runlevel 

restituisce il valore del runlevel corrente. 

Digitando il comando 

SINTASSI: $ init numero_ runlevel 

si manda il sistema in esecuzione in quel runlevel. 

# init 6 



A.A. 2012-2013 


La direttiva initdefault in /etc/inittab indica il runlevel di default di avvio del sistema: id:2:initdefault: . 

I servizi da attivare o disattivare in ciascun runlevel sono specificati nelle directory /etc/rcX.d dove X è il 

runlevel. 

shutdown 

Spegne il sistema in maniera sicura. Tutti gli utenti loggati ricevono un messaggio quando viene eseguito tale 

comando. È possibile spegnere o riavviare il sistema immediatamente, dopo un intervallo di tempo, oppure ad un 

orario prefissato mediante l’argomento time, che può avere diversi formati: now (spegne il sistema 

immediatamente); +m (spegne il sistema dopo m minuti); hh:mm (specifica l'orario di spegnimento). 

SINTASSI: $ shutdown [-krh] time [messaggio_avviso] 

Opzioni: 

-k Non spegne realmente il sistema, ma manda il messagio di avviso specificato a tutti gli utenti connessi 

-r Riavvia il sistema dopo lo spegnimento, equivalente a $ init 6 

-h Spegne il sistema, equivalente a $ init 0 

Controllo dei processi 

L'istanza di un programma in esecuzione in ambiente UNIX viene detta processo. Ogni programma può generare 

diversi processi. Ad esempio, ogni utente collegato al sistema esegue la sua shell; ogni utente può eseguire 

un'istanza di vi. 

Nei sistemi Unix ad ogni processo è assegnato un intero univoco, compreso tra 0 e 32767, denominato PID 

(process identification number), e un parent PID (PPID), ovvero il PID del processo che lo ha generato. 

Il sistema operativo assegna ad ogni nuovo processo un PID che il processo mantiene fino alla sua terminazione. 

I PID possono essere riutilizzati dopo la conclusione del processo e associati ad un nuovo processo. La maggior 

parte delle implementazioni di UNIX utilizza un algoritmo che posticipa il più possibile il riuso dei PID in modo 

da evitare che processi eseguiti a breve distanza di tempo utilizzino lo stesso PID. 

Il processo con PID 0 è solitamente lo scheduler (anche noto come swapper). Al processo init, invece, è 

associato PID=1 e nessun PPID. 

Tutti gli altri processi si creano tramite system call fork a partire da init. Il nuovo processo è detto processo 

“figlio” mentre il processo che ha invocato la fork è detto processo “genitore”. Nell'esecuzione dei programmi, il 

sistema operativo UNIX effettua normalmente le seguenti operazioni: 

1. creazione di un nuovo processo; 

2. esecuzione del programma figlio nello spazio del nuovo processo; 

3. attesa dal processo padre della terminazione del processo figlio; 

4. terminazione dell'esecuzione del processo figlio. 



A.A. 2012-2013 


fork è una system call speciale che viene invocata una volta, ma in caso di successo ritorna due volte e restituisce 

due valori diversi: una volta nel genitore restituendo il PID del figlio; una volta nel figlio restituendo 0. 

La fork restituisce il PID del figlio per consentire al genitore di tenere traccia del processo generato. Ogni 

processo può avere più figli e non esistono system call che elenchino i figli di un dato processo, mentre ogni 

processo ha sempre un unico genitore. 

Il processo figlio è una copia integrale del genitore. Il figlio ha una copia delle variabili del processo genitore, 

quindi la modifica di una variabile nello spazio di indirizzamento del figlio non modifica la variabile nel 

processo genitore. 

Dopo la fork, in entrambi i processi viene eseguita l'istruzione successiva alla fork. Il modo più semplice per 

distinguerli ed eseguire istruzioni diverse nel genitore e nel figlio è controllare il valore di ritorno della fork. 

La fork consente anche di suddividere il carico di lavoro tra diversi processi assegnando ad ognuno di essi parte 

del lavoro. Un caso frequente è quello di un programma che fornisce un determinato servizio: ad ogni richiesta 

ricevuta, il processo genera un figlio e gli assegna la richiesta da servire, mentre il genitore ritorna in attesa di 

nuove richieste. 

Ad ogni processo sono associati due utenti: 

Real user: utente che ha lanciato il processo; 

Effective user: utente che determina i diritti del processo. 

Solitamente i due utenti coincidono, ma quando un file eseguibile ha il set-uid-bit impostato, il corrispondente 

processo avrà: 

Real user: utente che ha lanciato il processo 

Effective user: utente proprietario dell'eseguibile. 

Questo metodo consente agli utenti di effettuare operazioni che normalmente non potrebbero fare e al 

programma di stabilire l'effettiva identità dell'esecutore. Il processo figlio eredita dal genitore una serie di 

proprietà tra cui real ed effective UID. 

Esempio : Il comando passwd 

Il comando passwd serve per modificare la password d'accesso al sistema. Quando eseguito da un utente 

normale, chiede all'utente la vecchia password, poi una volta verificato che la password coincide, chiede una 

nuova password 2 volte e sostituisce il campo corrispondente nel file di password del sistema (normalmente 

/etc/shadow). L'utente che esegue passwd non ha il permesso di modificare il file di sistema, ma il programma 

passwd ha il set-uid-bit impostato. 

$ ls -la /usr/bin/passwd 

-rwsr-xr-x 1 root root 42824 apr 9 2012 /usr/bin/passwd 

Quando viene eseguito da root, il comando passwd permette di cambiare la password di qualsiasi utente. Non 

chiede mai la vecchia password (neanche quando si tratta della password di root). Dal momento che qualsiasi 

utente esegua passwd ottiene i permessi di root, il comando passwd per accorgersi di essere stato eseguito da root 

confronta Real ed Effective user. 

ps 

Il comando ps (process status) visualizza i processi in esecuzione sul sistema (è una snapshot statica). 

Di default su ogni processo dell'elenco vengono visualizzate le seguenti informazioni: il PID, il terminale (TTY) 

da cui il processo è stato lanciato, il tempo di CPU utilizzato dal processo (TIME) ed il comando (CMD). In 

assenza di opzioni, visualizza i processi eseguiti dalla shell corrente in ordine crescente di PID. 

SINTASSI: $ ps [opzioni] 

PID TTY TIME CMD 

2532 pts/1 00:00:00 bash 

2590 pts/1 00:01:06 yes 

2658 pts/1 00:00:00 ps 



A.A. 2012-2013 


Opzioni: 

a (all) Mostra i processi di tutti gli utenti 

-e Visualizza tutti i processi 

-f (full) Visualizza anche UID (effective user), PPID, argomenti e start time (STIME) 

-F (father) Visualizza informazioni ancora più dettagliate rispetto a -f 

f Visualizza lo stato (STAT) e la dipendenza padre/figlio (COMMAND) 

-o Consente di specificare l'elenco di informazioni da visualizzare 

-p [lista_PID] Solo le informazioni relative ai PID specificati 

-r (running) Restringe la selezione solo ai processi in esecuzione 

-t [lista_tty] Seleziona per tty 

-u [lista_utenti] Mostra solo i processi relativi agli utenti in lista_utenti, se non specificato all'utente corrente. 

x Mostra i processi di sistema (il tty è criptato) 

u Mostra informazioni accessorie rispetto al normale ps 

USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND 

silvia 2532 0.0 0.1 21824 4364 pts/1 Ss 13:33 0:00 bash 

silvia 2590 6.1 0.0 5872 608 pts/1 T 13:33 1:06 yes 

silvia 2657 0.0 0.0 16872 1264 pts/1 R+ 13:51 0:00 ps u 

USER: utente che ha lanciato il processo 

PID: Process ID 

%CPU: (tempo di CPU a carico del processo)/(tempo di CPU totale) 

%MEM: (memoria a carico del processo)/(memoria totale) 

VSZ: Virtual Size, quantità di memoria virtuale a carico del processo, espressa in byte 

RSS: Resident Size, espressa in byte 

TTY: Teletype (terminale) 

STAT: caratteri che indicano lo stato del processo 

R = running; Ss = sleeping interrompibile; D = sleeping non interrompibile; Z = zombie; X = 

dead; T = treased o stopped; W = non residente in memoria; < = alta priorità 

START: orario di inizio del processo 

TIME: tempo di CPU utilizzato dal processo 

COMMAND: nome comando 

silvia@ubuntu:~$ ps -u silvia -o pid,ppid,%cpu,%mem 

$ ps au 

$ ps aux 

$ ps aur 

$ ps ax | head -n 10 Visualizza i processi utilizzando la notazione BSD 

PID TTY STAT TIME COMMAND 

1 ? Ss 0:02 /sbin/init 

2 ? S< 0:00 [kthreadd] 

3 ? S< 0:00 [migration/0] 

4 ? S< 0:03 [ksoftirqd/0] 

5 ? S< 0:00 [watchdog/0] 

6 ? S< 0:00 [events/0] 

7 ? S< 0:00 [khelper] 

46 ? S< 0:00 [kintegrityd/0] 

48 ? S< 4:46 [kblockd/0] 

Esercizi 

1. Ordina i processi in esecuzione sul sistema in base al nome utente. 

2. Elencare tutti i processi in esecuzione sul sistema che hanno TTY pari a ?. 


pstree 

Permette la visualizzazione ad albero dei processi 

SINTASSI: $ pstree [opzioni] 

Opzioni: 

-h Evidenzia il percorso fino al processo corrente 

-p Mostra il PID 


A.A. 2012-2013 


top 

Mostra dinamicamente una serie di informazioni sui processi e sul sistema. Lo stato dei processi sulla macchina 

viene aggiornato ad intervalli regolari. 

SINTASSI: $ top 

(con q si esce dal top). 

Nella parte superiore sono presenti informazioni generali sul sistema. 

TOP: orario di ultimo aggiornamento (consente di capire ogni quanto avviene l'aggiornamento); 

UP: da quanto tempo è acceso il sistema; 

USER: numero di utenti connessi; 

LOAD AVERAGE: carico medio della macchina in termini di utilizzo di CPU calcolato per intervalli di 15 

min, 5 min, 1 min; 

N. TASK: totali e per stato; 

% UTILIZZO CPU: da parte di US (utente), SY (sistema), etc.; 

MEMORIA: quantità totale e utilizzata/libera/buffer 

SWAP: quantità totale e utilizzata/libera/cached 

user@ubuntu:~$ top 

top - 12:31:19 up 7:12, 2 users, load average: 1.64, 1.45, 1.36 

Tasks: 116 total, 4 running, 112 sleeping, 0 stopped, 0 zombie 

Cpu(s): 2.7%us, 1.7%sy, 0.0%ni, 33.2%id, 62.5%wa, 0.0%hi, 0.0%si, 0.0%st 

Mem: 514296k total, 493048k used, 21248k free, 136620k buffers 

Swap: 0k total, 0k used, 0k free, 153360k cached 

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 

1983 root 15 -5 0 0 0 D 3.7 0.0 15:26.3 kjournald 

6059 root 20 0 42320 14m 7376 S 3.7 3.0 1:29.96 Xorg 

48 root 15 -5 0 0 0 S 1.3 0.0 5:00.52 kblockd/0 

5938 mythtv 20 0 69804 7844 5044 D 1.3 1.5 5:13.02 mythbackend 

6541 user 20 0 45252 14m 8428 S 0.7 2.9 0:01.26 gnome-settings- 

6633 user 20 0 30156 15m 10m S 0.7 3.0 0:39.56 vmware-user-loa 

16217 user 20 0 98.8m 25m 12m R 0.7 5.0 0:07.76 gnome-terminal 

4974 root 20 0 13808 2820 2288 R 0.3 0.5 0:28.42 vmtoolsd 

5492 mysql 20 0 125m 17m 5188 S 0.3 3.5 1:00.04 mysqld 

1 root 20 0 3056 1888 564 S 0.0 0.4 0:02.00 init 

2 root 15 -5 0 0 0 S 0.0 0.0 0:00.00 kthreadd 

3 root RT -5 0 0 0 S 0.0 0.0 0:00.00 migration/0 

4 root 15 -5 0 0 0 S 0.0 0.0 0:03.76 ksoftirqd/0 

5 root RT -5 0 0 0 S 0.0 0.0 0:00.00 watchdog/0 

6 root 15 -5 0 0 0 R 0.0 0.0 0:00.62 events/0 

NI (nice). 

Il valore di nice rappresenta un meccanismo di correzione della priorità statica; è un numero intero positivo o 

negativo che misura la correttezza dell'algoritmo di scheduling e cerca di spostare i processi CPU bound o I/O 

bound. Ad esempio, un fattore ni = +19 abbassa la priorità; ni = -5 alza la priorità. 


Background e foreground 


A.A. 2012-2013 


Normalmente la shell esegue i comandi dell'utente in foreground, ovvero restituisce il controllo del terminale 

soltanto a comando terminato. Utilizzando il simbolo & subito dopo un comando, il comando viene eseguito in 

background e la shell restituisce subito il controllo del terminale. Se non rediretto in file, il comando in 

background utilizza il terminale per lo standard output e lo standard error. 

$ ls -R /usr > ~/elenco & 

[1] 3347 (rappresentano [jobnumber] PID) 

Quando viene lanciata una pipeline in background vengono mostrati il numero di job in background sulla 

macchina e il PID dell'ultimo processo della pipeline. In maniera informale un job è definibile come un'attività 

derivata da un comando dato attraverso una shell. 

Un processo eseguito in foreground interagisce in maniera diretta con l'utente (browser, editor di testo). 

Un processo in background è invece un processo che non interagisce direttamente con l'utente e tipicamente 

fornisce un servizio non direttamente visibile all'utente (servizio di sistema, demone). La gestione del 

background abilita il multitasking. 

yes 

Stampa il carattere “y”, o la stringa specificata indefinitamente sullo standard output, finché non viene terminato. 

SINTASSI: $ yes [stringa] 

Notare la differenza di esecuzione in foreground e background: 

$ yes > /dev/null 

$ yes > /dev/null & 

/dev/null è un black hole, un cestino senza fondo. Si usa quando c'è un output ripetuto che non interessa 

all'utente. 

sleep 

Sospende la shell per i secondi specificati. 

SINTASSI: $ sleep num_secondi 

$ sleep 20 

pwd 

ls -l 

echo è tardi 

wait 

Sospende l'esecuzione del processo padre di quello passato in argomento, finché quello in argomento non 

termina l'esecuzione. Il comando viene usato per forzare il controllo dell'output del figlio prima che riparta il 

processo padre. Senza argomento, sospende il padre finché non terminano tutti i figli. Per uscire dal wait si 

utilizza Ctrl+C. 

SINTASSI: $ wait [PID] 

$ sleep 20 & 

[1] 2972 

$ wait 2972 

jobs 

Mostra i processi attualmente in background. 


SINTASSI: $ jobs [opzioni] 


A.A. 2012-2013 


Opzioni: 

-l Visualizzazione estesa delle informazioni di ogni processo di stato 

-p Mostra solo il PID del processo leader del job selezionato 

user@ubuntu:~$ jobs 

[1]+ Running sleep 15 & 

user@ubuntu:~$ jobs -l 

[1]+ 17245 Running sleep 15 & 

user@ubuntu:~$ jobs -p 

17245 

fg 

Porta in foreground un job che prima era in background. Se non viene specificato il job su cui agire, riporta in 

foreground l'ultimo processo lanciato in background. 

SINTASSI: $ fg [num_job] 

$ fg 1 

Ctrl+Z sospende il processo attualmente in foreground o tutti i processi della pipeline, restituendo il controllo 

alla shell. Il job in questione viene messo in background. 

bg 

Permette di far riprendere in background l'esecuzione di un job sospeso, se il job in questione non è in 

attesa di un input o di poter emettere l'output. Senza argomento riporta in background l'ultimo job 

sospeso. 

SINTASSI: $ bg [num_job] 

$ yes > /dev/null & 

[1] 2590 

$ fg 1 

yes > /dev/null 

Ctrl+Z 

[1]+ Stopped yes > /dev/null 

$ bg 1 

[1]+ yes > /dev/null & 

Provate ad eseguire la stessa sequenza di comandi senza redirigere l'output di yes. Cosa accade? 

Ctrl+C termina il processo o la pipeline attualmente in esecuzione in foreground. 

Segnali 

I segnali sono interrupt software che forniscono una tecnica rudimentale di comunicazione asincrona tra 

processi. I segnali ci consentono di gestire eventi asincroni quali ad esempio: 

- un utente che interrompe l'esecuzione di un programma utilizzando Ctrl+C; 

- la fine prematura di un processo in una pipeline. 

I segnali costituiscono un insieme ben definito ed a ciascuno di essi è associata una costante simbolica ed un 

intero positivo. I sistemi Linux prevedono 64 segnali diversi: 

1-31: segnali standard; 

32-63: segnali “real-time”; 

0: utilizzato per controllare se si hanno i permessi sufficienti per inviare un segnale ad un processo. 

Le costanti simboliche hanno tutte il prefisso SIG, sono definite nell'header signal.h e descritte nella pagina di 

manuale signal(7). 



A.A. 2012-2013 


Distinguiamo le seguenti categorie di segnali in base alla loro origine: 

- Segnali provenienti dal terminale: generati quando l'utente utilizza alcune combinazioni di tasti quali Ctrl+C 

(SIGINT) o Ctrl+Z (SIGSTOP). 

- Segnali derivanti da eccezioni hardware: generati dall'hardware quando si verificano eventi quali la divisione 

per 0 o il tentativo di accesso ad un'area di memoria non valida; gli eventi vengono rilevati dal kernel che invia il 

segnale corrispondente al processo che ha causato le eccezioni (ad esempio SIGSEGV). 

- Segnali provenienti dalla funzione kill(2) (e dal comando kill(1)) kill verso un determinato PID. 

- Segnali collegati ad eventi software: generati quando accade un evento di cui un processo deve essere 

informato; è il caso, ad esempio, di un processo che scrive in una pipeline mentre il processo che legge è già 

terminato (set | less); in tale ipotesi il primo riceve un segnale SIGPIPE quando il secondo termina. 

La generazione di un segnale e la sua notifica passano attraverso il kernel che li gestisce utilizzando una coda di 

segnali pendenti. La notifica è un evento asincrono rispetto alla generazione e dipende dal kernel. Sui sistemi 

Linux un segnale standard (non real time) viene inserito nella coda dei segnali pendenti solo se non è già 

presente. In pratica inviando n volte lo stesso segnale standard ad un processo: la prima istanza viene inserita in 

coda, mentre quelle successive vengono scartate fintanto che la prima è in coda. 

Il processo che riceve il segnale può decidere di gestirlo in 3 modi: 

- ignorare il segnale; 

- catturare il segnale specificando una funzione detta signal handler da eseguire; 

- eseguire l'azione di default associata al segnale (molto spesso la terminazione del processo). 

I segnali SIGKILL (9) e SIGSTOP (19) non possono essere né catturati né ignorati ma eseguono sempre l'azione 

di default. Le azioni di default sono specificate nella pagina di manuale signal(7). 

Regole di protezione: per inviare un segnale utilizzando la system call kill (ed il comando kill) è necessario che 

l'uid (real o effective) del processo mittente sia uguale all'uid (real o effective) del processo destinatario. L'utente 

root può inviare segnali a tutti i processi. 

kill 

Il comando kill permette di inviare un segnale ad un processo, indicando direttamente il PID del processo. Se 

non si specifica nessun segnale viene inviato SIGTERM (15), che è catturabile. 

SINTASSI: $ kill [opzioni] [PID] 

Opzioni: 

-s nome_segnale Invia il segnale nome_segnale al processo con #id PID 

-nome_segn 

-num_segn 

-l Elenca tutti i segnali ed i loro valori numerici (64 diversi segnali) 

$ kill -SIGINT 1722 

$ kill -INT 1722 

$ kill -2 1722 



A.A. 2012-2013 


pkill 

Consente di inviare un segnale ad un processo specificando il nome del programma piuttosto che il pid. 

$ pkill -9 a.out 

Invia il segnale SIGTERM a tutte le istanze di a.out a cui l'utente ha il permesso di inviare segnali. 

killall 

Si comporta esattamente come il comando kill ma non riceve come argomento uno o più PID. Come il comando 

kill, se non è specificato nessun segnale di default esso è SIGTERM (15). 

SINTASSI: $ killall [opzioni] [nome_proc] 

Opzioni: 

-u [utente] Manda il segnale di terminazione a tutti i processi relativi all'utente specificato. 

-i Chiede conferma prima di inviare il segnale, processo per processo. 

-nome_segn 

-num_segn 

$ killall gdm 

Termina tutti i processi della sessione grafica, questi infatti sono tutti figli del processo gdm. 

Terminazione di un processo 

Un processo single-threaded può terminare l'esecuzione normalmente in 3 modi: 

- eseguendo return dalla funzione main; 

- invocando la funzione exit; 

- invocando la system call _exit o la funzione _Exit; 

oppure non normalmente in 2 modi: 

- invocando la system call abort che genera SIGABRT; 

- ricevendo un segnale che ne causa la terminazione. 

Lo stato di terminazione può essere definito dall’utente utilizzando return o exit e varianti o assegnato dal kernel, 

se l’utente non lo fa esplicitamente o in caso di terminazione con errore. 

Fino a quando il genitore non preleva le informazioni sulla terminazione del figlio questi assume lo stato di 

zombie ed il PID del processo rimane utilizzato (visualizzabile con ps). 

Quando un processo termina prima dei suoi figli, gli orfani diventano figli del nonno o di init, che preleva lo 

stato di terminazione di ogni figlio terminato per consentire al kernel di rilasciare i descrittori di processo. 

Il diagramma descrive il tipico ciclo di vita di un processo dalla sua creazione alla sua terminazione.

Comandi Bash shell - SisInf Lab

Create successful ePaper yourself

Delete template?

Save as template?