Comandi_shell_bash

Commenti

Transcript

Comandi_shell_bash
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
[email protected]).
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
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
Indice
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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 3
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 4
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 5
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 6
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
- $ man -s1 chmod
$ man -s2 chmod
(Mostra la prima sessione)
(Mostra la seconda sessione)
In maniera alternativa, è possibile utilizzare
SINTASSI: $ comando --help
Accede direttamente alla sottosezione relativa alla descrizione delle options.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 7
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
[email protected]:~$ 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]
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 8
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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:
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 9
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
r
w
x
Visualizzare il contenuto della directory (il list è una lettura)
Scrivere all'interno della directory (rinomina, modifica, rimozione)
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
-i
-p
-R
-v
Forza la sovrascrittura
Richiede interattivamente la conferma di sovrascrittura
Mantiene le caratteristiche del file sorgente compresa la data e l'ora di referenziazione
Copia ricorsiva
Verbose mode
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 10
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
Opzioni:
-m ACL
-v
Crea una directory specificando l'ACL
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
-i
-v
Forza la sovrascrittura
Richiede interattivamente la conferma di sovrascrittura
Verbose mode
Esempi:
$mv file1 file2
$mv file1 dirA
$mv dirA file1
$mv dirA dirB
(rinomina file 1 come file2 eventualmente sovrascrivendolo)
(sposta file1 in dirA)
(non concesso se file1 è un file esistente)
(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
-v
Cancellazione ricorsiva del contenuto di una directory e della directory stessa, se non vuota
Verbose mode
Esempi:
$ rm -Rv provaFull
$ rm file1
rmdir
Il comando rmdir (remove directory), cancella una directory. La directory dev'essere vuota.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 11
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
SINTASSI: $ rmdir [opzioni] nomeDir_1 [nomeDir_n]
Opzioni:
--ignore-fail-on-non-empty
-v
Non mostra a video il messaggio di errore
Verbose mode
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
ino_t
st_ino
mode_t st_mode
nlink_t
st_nlink
uid_t
st_uid
gid_t
st_gid
dev_t
st_rdev
off_t
st_size
time_t
st_atime
time_t
st_mtime
time_t
st_ctime
blksize_t st_blksize
blkcnt_t st_blocks
}
/*ID del device che contiene il file*/
/*n.ro inode*/
/*tipo di file e permessi*/
/*numero di link al file*/
/*user ID del proprietario del file*/
/*group ID del proprietario del file*/
/*device ID (se il file è speciale a blocchi o a caratteri)*/
/*dimensione del file in bytes (per file regolari, directory o link)*/
/*orario dell'ultimo accessoai dati*/
/*orario dell'ultima modifica ai dati*/
/*orario dell'ultimo cambiamento all'inode (ad esempio attraverso chmod)*/
/*dimensione del blocco per l'oggetto (è specifica del FS, può variare da file a file)*/
/*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
-c
-m
Cambia l'orario di accesso
Non crea il file, aggiorna solo la data di ultimo accesso
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 12
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 13
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 14
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
Altri comandi di base
alias/unalias
L'alias è un nome alternativo dato ad una sequenza complessa
SINTASSI: $ alias
$ alias nomeAlias='comando'
Esempi:
$ alias al='ls -al'
$ alias cp='cp -i'
Visualizza tutti gli alias
Crea un alias
(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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 15
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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]
[g-z]
[^a]
Uno qualsiasi dei caratteri a,d,f,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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 16
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
$ echo '$HOME'=$HOME
$HOME=/home/silvia
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: [^abcd]
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 17
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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 '\<stringa' stampa la tutte le righe che contengono una parola che comincia con stringa (ad
es.: stringa, stringato, ma non costringa).
L'espressione regolare 'stringa\>' stampa la tutte le righe che contengono una parola che termina con stringa (ad
es.: stringa, costringa, ma non stringato).
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 18
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 19
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
L'espressione regolare '\<[[:digit:]]{4,}\>' 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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 20
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
$ grep a file
della riga
Mostra tutte le linee del file che contengono la lettera a almeno una volta in qualsiasi punto
$ 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 '[^abcd]' 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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 21
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
$ 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 '\<stringa' file
Stampa tutte le righe che contengono una parola che comincia con stringa
(stringa, stringato, ma non costringa)
$ grep 'stringa\>' file
Stampa tutte le righe che contengono una parola che termina con stringa
(stringa, costringa, ma non stringato)
$ grep '\<stringa\>' 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 '\<[[:digit:]]{4,}\>' 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...
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 22
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 23
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
Password
Indica il nome del gruppo.
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 24
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
Password
Nome di login al sistema dell'utente
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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 25
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
Password
Il nome dell'utente a cui fa riferimento la 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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 26
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
[email protected]:~ id silvia
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 27
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
whoami
Mostra chi è l'utente della shell
SINTASSI: $ whoami
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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 28
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 29
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 30
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
[email protected]:~$ 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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 31
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 32
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
comandi
pwd
ls
echo “comandi“
mkdir redirectdir
$ sh < comandi
SINTASSI: $ comando << file
<< redirezione doppia dell'input con accodamento fino alla digitazione di un carattere di escape o buffer pieno
$ grep 'ciao' << eof
> ciao ciao
> eof
$ sh << eof
> ls
> pwd
> eof
Per reindirizzare standard output e standard error nello stesso file si può utilizzare l'operatore &> (&>>)
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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 33
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 34
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
-c
-d
-f
-i
-m
-n
-r
-o file
Ignora i blank iniziali (spazi e tabulazioni)
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.
Dictionary order: ignora tutti i caratteri che non siano lettere, numeri o spazi
Non distingue tra lettere maiuscole e minuscole
Ignora i caratteri speciali al di fuori del set ASCII puro (ignora caratteri non stampabili)
Fonde insieme i file indicati che devono essere già ordinati (non effettua ordinamento)
Sort numerico: considera anche il segno meno e il punto decimale
Reverse: inverte il senso di ordinamento
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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 35
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
5
11
$ sort esempio_sort_num.txt
$ sort -n esempio_sort_num.txt
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
-c -#X
-n #X
-n -#X
Mostra i primi #X byte di un file
Mostra i byte di un file esclusi gli ultimi #X byte
Mostra le prime #X righe di un file (equivale a -#X)
Mostra le righe di un file escluse le ultime #X
$ cat elencotel
$ 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
-c +#X
Mostra gli ultimi #X byte di un file
Mostra gli ultimi byte di un file a partire dal byte #X
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 36
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
-n #X
-n +#X
Mostra le ultime #X righe di un file (equivale a -#X)
Mostra le ultime righe di un file a partire dalla riga #X
$ cat elencotel
$ 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
-d
-f N
-i
-s N
-u
-w N
Per ogni riga indica il numero di occorrenze
Mostra solo le linee duplicate
Salta il confronto delle prime N parole
Nel confronto ignora la differenza tra lettere maiuscole e minuscole
Salta il confronto dei primi N caratteri
Mostra solo le linee uniche non duplicate
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.
Questa riga è presente tre 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
-c range
-d separatore
-f intervallo
Estrae solo i byte indicati nel range (N, N-M, -N, N-)
Estrae solo i caratteri indicati nel range (N, N-M, -N, N-)
Indica il carattere/stringa separatore da utilizzare (anzichè TAB)
Indica la lista dei campi da estrarre (N, N-M, -N, N-)
$ cat cut_file
nome
pippo
cognome matricola
pluto
123456
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 37
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
ciccio
$ cut -f 2 cut_file
pallino
098765
$ cat cut_file_delim
nome;cognome;matricola;email;CDL
pippo;pluto;123456;[email protected];AUT
ciccio;pallino;098765;[email protected];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
-B
-r
--brief
--ignore-case
Ignora le differenze nella quantità di spazi bianchi
Ignora le differenze che consistono solo in righe vuote
Confrontando due directory, confronta ogni sottodirectory ricorsivamente
Riferisce solo se i file sono diversi, senza mostrarne le differenze
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 38
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
Gestione dei processi
Avvio del sistema
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
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 39
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 40
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
2532
2590
2658
TTY
pts/1
pts/1
pts/1
TIME
00:00:00
00:01:06
00:00:00
CMD
bash
yes
ps
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 41
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
Opzioni:
a
-e
-f
-F
f
-o
-p [lista_PID]
-r
-t [lista_tty]
-u [lista_utenti]
x
u
(all) Mostra i processi di tutti gli utenti
Visualizza tutti i processi
(full) Visualizza anche UID (effective user), PPID, argomenti e start time (STIME)
(father) Visualizza informazioni ancora più dettagliate rispetto a -f
Visualizza lo stato (STAT) e la dipendenza padre/figlio (COMMAND)
Consente di specificare l'elenco di informazioni da visualizzare
Solo le informazioni relative ai PID specificati
(running) Restringe la selezione solo ai processi in esecuzione
Seleziona per tty
Mostra solo i processi relativi agli utenti in lista_utenti, se non specificato all'utente corrente.
Mostra i processi di sistema (il tty è criptato)
Mostra informazioni accessorie rispetto al normale ps
USER
silvia
silvia
silvia
%CPU
0.0
6.1
0.0
PID
2532
2590
2657
USER:
PID:
%CPU:
%MEM:
VSZ:
RSS:
TTY:
STAT:
START:
TIME:
COMMAND:
%MEM
0.1
0.0
0.0
VSZ
21824
5872
16872
RSS
4364
608
1264
TTY
pts/1
pts/1
pts/1
STAT
Ss
T
R+
START
13:33
13:33
13:51
TIME
0:00
1:06
0:00
COMMAND
bash
yes
ps u
utente che ha lanciato il processo
Process ID
(tempo di CPU a carico del processo)/(tempo di CPU totale)
(memoria a carico del processo)/(memoria totale)
Virtual Size, quantità di memoria virtuale a carico del processo, espressa in byte
Resident Size, espressa in byte
Teletype (terminale)
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à
orario di inizio del processo
tempo di CPU utilizzato dal processo
nome comando
[email protected]:~$ 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 ?.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 42
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
pstree
Permette la visualizzazione ad albero dei processi
SINTASSI: $ pstree [opzioni]
Opzioni:
-h
Evidenzia il percorso fino al processo corrente
-p
Mostra il PID
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
[email protected]:~$ 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 free,
153360k cached
PID
1983
6059
48
5938
6541
6633
16217
4974
5492
1
2
3
4
5
6
0k
USER
root
root
root
mythtv
user
user
user
root
mysql
root
root
root
root
root
root
total,
PR
15
20
15
20
20
20
20
20
20
20
15
RT
15
RT
15
NI
-5
0
-5
0
0
0
0
0
0
0
-5
-5
-5
-5
-5
0k used,
VIRT
0
42320
0
69804
45252
30156
98.8m
13808
125m
3056
0
0
0
0
0
RES
0
14m
0
7844
14m
15m
25m
2820
17m
1888
0
0
0
0
0
SHR
0
7376
0
5044
8428
10m
12m
2288
5188
564
0
0
0
0
0
S
D
S
S
D
S
S
R
R
S
S
S
S
S
S
R
%CPU
3.7
3.7
1.3
1.3
0.7
0.7
0.7
0.3
0.3
0.0
0.0
0.0
0.0
0.0
0.0
%MEM TIME+ COMMAND
0.0
3.0
0.0
1.5
2.9
3.0
5.0
0.5
3.5
0.4
0.0
0.0
0.0
0.0
0.0
15:26.3
1:29.96
5:00.52
5:13.02
0:01.26
0:39.56
0:07.76
0:28.42
1:00.04
0:02.00
0:00.00
0:00.00
0:03.76
0:00.00
0:00.62
kjournald
Xorg
kblockd/0
mythbackend
gnome-settingsvmware-user-loa
gnome-terminal
vmtoolsd
mysqld
init
kthreadd
migration/0
ksoftirqd/0
watchdog/0
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à.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 43
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
Background e foreground
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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 44
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
SINTASSI: $ jobs [opzioni]
Opzioni:
-l
Visualizzazione estesa delle informazioni di ogni processo di stato
-p
Mostra solo il PID del processo leader del job selezionato
[email protected]:~$ jobs
[1]+ Running sleep 15 &
[email protected]:~$ jobs -l
[1]+ 17245 Running sleep 15 &
[email protected]:~$ 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).
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 45
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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
-nome_segn
-num_segn
-l
Invia il segnale nome_segnale al processo con #id PID
Elenca tutti i segnali ed i loro valori numerici (64 diversi segnali)
$ kill -SIGINT 1722
$ kill -INT 1722
$ kill -2 1722
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 46
CORSO DI FONDAMENTI DEI SISTEMI OPERATIVI
A.A. 2012-2013
(Prof. G. Piscitelli)
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]
-i
-nome_segn
-num_segn
Manda il segnale di terminazione a tutti i processi relativi all'utente specificato.
Chiede conferma prima di inviare il segnale, processo per processo.
$ 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.
Esercitazioni comandi shell Bash (Ing. S. Giannini)
Pagina 47

Documenti analoghi