Corso per l'amministrazione base di un sistema Linux, della durata di 8-16 ore

1. Corso su Linux
Usare il Pinguino e vivere felici (v. 1.1)
Paolo Campegiani
paolo@paolocampegiani.it
http://www.paolocampegiani.it
– p.

2. Indice per sezioni - 1
Concetti generali, 4
Comandi su file, 56
Operazioni su dischi, 81
Comandi su file di testo, 98
Comandi per l’archiviazione, 114
Bash e linea di comando, 127
Utenti e gruppi, 144
L’ambiente grafico, 157
Stampare, 162
– p.

3. Indice per sezioni - 2
Interoperabilitá con Windows, 168
Data ed ora, 175
Informazioni sull’hardware, 182
Controllare il sistema, 185
Rete e networking, 209
Sequenza di boot, 231
Gestione dei pacchetti con RPM, 244
Compilare il Kernel e gestire i moduli, 255
Trovare documentazione, 272
– p.

4. Cenni su Unix - 1
Unix viene sviluppato nei Bell Labs a partire dal 1969. Si tratta di
una famiglia di sistemi operativi, sviluppati da costruttori diversi, che
condividono una comune interfaccia di programmazione:
AIX di IBM
Solaris di Sun
HP-UX di Hewlett Packard
FreeBSD università di Berkeley
E’ il primo sistema operativo scritto in un linguaggio di
programmazione ad alto livello, il C, inventato nel 1972 proprio a tal
fine.
– p.

5. Cenni su Unix - 2
Unix é stato pensato fin dall’inizio per essere semplice,
coerente, efficiente. É un sistema operativo multiutente e
multiprogrammato:
multiprogrammato: piú processi si contendono l’uso delle
risorse del sistema;
multiutente: utenti diversi richiedono al sistema di
compiere delle operazioni, e sono autorizzati o meno a
compierle.
– p.

6. Cenni su Unix - 3
Un sistema Unix consente di eseguire in modo efficiente
molte centinaia di processi distinti che operano
concorrentemente.
Unix é particolarmente orientato ad applicazioni server e a
compiti di networking: Internet é stata sviluppata su Unix.
La compatibilitá tra le diverse versioni di Unix é a livello di
codice sorgente e di comandi di sistema disponibili.
Le specifiche di Unix sono pubbliche, le implementazioni
sono proprietarie oppure liberamente usabili (FreeBSD).
– p.

7. Cosa é Linux
Linux é una implementazione di Unix realizzata partendo
da zero, e distribuita secondo la licenza GPL (Gnu Public
License).
Linux nasce nel 1991 ad opera di Linus Torvalds, a cui si
sono aggiunti negli anni centinaia di sviluppatori che
operano gratuitamente e si coordinano tramite una mailing
list pubblicamente accessibile. Torvalds é il responsabile
ultimo di ogni decisione relativa alle funzionalità da inserire
nel kernel e sulla scelta tra le diverse implementazioni
possibili.
– p.

8. La licenza GPL
La licenza GPL (GNU Public License) rappresenta
l’essenza del software libero. Con una licenza GPL si puó:
ottenere il software gratuitamente ed in formato
sorgente, pagando eventualmente delle spese di
spedizione;
utilizzarlo in qualsiasi ambito e con qualsiasi finalitá;
ridistribuire anche gratuitamente il software cosí
ottenuto;
modificare il software ottenuto;
distribuire il software modificato, citando l’autore
originale, ma solo sotto licenza GPL;
– p.

9. I sistemi GNU/Linux
Linux é il kernel, tutti gli altri programmi necessari al
funzionamento del sistema (il compilatore C, la libreria C) e
il software di sistema (i comandi di base) sono sviluppati da
un altro organismo, la Free Software Foundation, che negli
anni ’80 ha dato il via alla realizzazione di un proprio Unix
gratuito (GNU é un anti-acronimo, significando GNU is Not
Unix).
E’ quindi piú corretto parlare di sistemi GNU/Linux.
– p.

10. Caratteristiche di Linux - 1
Linux é un sistema operativo multipiattaforma, nella sua
ultima versione gira tra l’altro su:
x86 e compatibili (Intel, Amd, ...) a 32 e 64 bit
PowerPc a 32 e 64 bit
Motorola 68k
Arm
Digital Alpha
MIPS
Sparc
IBM S390
– p. 1

11. Caratteristiche di Linux - 2
É una implementazione di Unix
Multiutente
Multiprocesso
Multiprocessing simmetrico (SMP), da 2 a 16
processori (di piú con il kernel 2.6)
Minime richieste hardware (il kernel occupa meno di 2
MB di memoria)
Grande interfacciabilitá verso altri sistemi operativi
Particolarmente ottimizzato per il networking
– p. 1

12. La numerazione del kernel - 1
Il kernel di Linux ha un sistema di numerazione a tre cifre:
1. Version: versione del kernel (correntemente é la 2, ci
sono state la 0 e la 1)
2. Patchlevel: il livello di patch
Numeri pari: versioni stabili del kernel
Numeri dispari: versioni di sviluppo
3. Sublevel: un numero progressivo che rappresenta le
varie sottoversioni.
– p. 1

13. La numerazione del kernel - 2
Quindi ad esempio 2.4.24 é una versione stabile, mentre
2.5.33 é una versione di sviluppo.
Una versione stabile non é necessariamente priva di bug!
Se ci sono dei bug, questi vengono segnalati alla mailing
list di sviluppo e corretti in una delle prossime versioni
(SubLevel maggiore).
Al 9 Luglio 2004 esistono diversi rami stabili della versione
2.0 ( finger @kernel.org):
2.0.40
2.2.26
2.4.26
2.6.7
– p. 1

14. La numerazione del kernel - 3
La versione 2.4.26 é più stabile della versione 2.6.7, che é
invece appena stata rilasciata ed é quindi in corso di
sviluppo attivo.
Progressivamente la versione 2.6 diventerá stabile, e ad un
certo punto si passerá allo sviluppo della versione 2.7, che
incorporerá nuove funzionalitá (nello sviluppo di una
versione pari si correggono sono gli errori presenti). Lo
sviluppo della versione 2.6 si limiterá a correggere problemi
di sicurezza.
– p. 1

15. Le dimensioni del kernel
Il kernel è costituito da circa 5.6 milioni di righe di codice C
(con una piccola parte in assembler specifica per ogni
piattaforma) e viene distribuito in formato sorgente (circa
200 MB non compressi). Ottenuti i sorgenti, occorre
compilarli sulla propria macchina per avere un kernel da
poter installare, oppure usare un kernel compilato da terze
parti.
Il kernel realizza solo le funzioni essenziali: l’interfaccia
grafica e tutti i programmi (compreso il software di sistema)
sono indipendenti e sviluppati autonomamente.
– p. 1

16. La libreria e il compilatore C
La libreria e il compilatore C sono due componenti
essenziali del sistema.
Il kernel stesso viene compilato usando il compilatore C, e
praticamente tutti i programmi presenti usano direttamente
o indirettamente la libreria C.
– p. 1

17. Il compilatore C
Il compilatore C/C++ si chiama gcc (Gnu Cross Compiler)
ed é sviluppato da Free Software Foundation.
Oggi sono sostanzialmente disponibili due versioni:
2.96 la versione stabile, fortemente consigliata per
compilare il kernel
3.3-3.4 la nuova versione, utilizzabile per compilare la
maggior parte dei programmi
Sono disponibili molti altri linguaggi di programmazione: a
volte i relativi compilatori operano traducendo il codice in
linguaggio C/C++ e poi invocando il compilatore gcc.
– p. 1

18. La libreria C
La libreria C attualmente utilizzata é la libreria glibc (Gnu
libc).
Implementa POSIX.1 e parte di POSIX.2.
La versione corrente é la 2.3.
– p. 1

19. Le librerie dinamiche
Le librerie utilizzate dai programmi possono essere
collegate agli stessi in modo statico o dinamico.
Il consolidamento statico viene preferito quando occorre
avere un programma che possa funzionare in modo
indipendente dal resto del sistema, avendo al suo interno
tutto il codice necessario al funzionamento.
Il consolidamente dinamico é di gran lunga il piú usato,
permettendo di avere programmi di dimensioni minori.
– p. 1

20. Gli standard di Linux
Con la diffusione di Linux, e l’esistenza di molti venditori di
soluzioni basate su questo sistema, si é reso necessario
definire degli standard per garantire uno standard comune
che governi:
le funzioni esportate da alcune delle librerie dinamiche
la dislocazione di alcuni dei file (di configurazioni o di
comandi) presenti nel sistema
i parametri di alcuni dei comandi di sistema
Un consorzio indipendente ha realizzato lo standard
relativo, il Linux Standard Base (LSB):
http://www.linuxbase.org.
– p. 2

21. Le distribuzioni - 1
Un sistema Linux contiene quindi un kernel, delle librerie
dinamiche, del software di sistema, e dei programmi
applicativi. Tutti questi componenti sono variamente
interdipendenti (ad esempio un certo programma richiede
una certa versione di una libreria) ed occorre quindi garantire
che l’installazione, la rimozione o l’aggiornamento di uno di
questi componenti non comprometta il funzionamento
dell’intero sistema.
Questo é uno dei compiti svolto una distribuzione.
– p. 2

22. Le distribuzioni - 2
Una distribuzione è fondamentalmente, quindi, un sistema
di gestione delle dipendenze, anche se ci sono altri
elementi specifici per una distribuzione, come ad esempio il
modo in cui viene effettuata la configurazione dell’hardware
e come sono attivati i servizi offerti dalla macchina.
Esistono centinaia di distribuzioni di Linux, che coprono
necessitá molto diverse (e sono quindi fornite anche con
insiemi di software applicativi diversi).
– p. 2

23. Le distribuzioni - 3
Le piú diffuse e significative distribuzioni per Linux sono:
RedHat
Debian
SuSe
Mandrake
Slackware
Gentoo
– p. 2

24. La distribuzione RedHat
La piú diffusa distribuzione per Linux, é oggi presente in piú
versioni:
Red Hat Linux/Red Hat Fedora la versione gratuita e
prelevabile da Internet;
Red Hat Enterprise Linux WS per workstation;
Red Hat Enterprise Linux ES per server web;
Red Hat Enterprise Linux AS per server Oracle;
La differenza sostanziale tra la versione gratuita e quelle a
pagamento é l’assistenza fornita. Il sistema di gestione
delle dipendenze si basa in ogni caso sul software rpm
(RedHat Package Manager).
– p. 2

25. Le distribuzioni SuSe e Mandrake
Queste due distinte distribuzioni usano lo stesso package
manager di RedHat, e si differenziano sul modo in cui i
singoli pacchetti sono organizzati.
Sono anch’esse disponibili in due versioni, una gratuita e
prelevabile da Internet, ed una a pagamento in cui si
aggiungono dei software proprietari e/o dell’assistenza
tecnica.
– p. 2

26. La distribuzione Debian
Questa distribuzione é completamente gratuita, realizzata
da un gruppo di volontari. Utilizza un proprio sistema di
gestione dei pacchetti (il cui nucleo é il software dpkg).
E’ divisa in tre filoni:
stable che viene aggiornata ogni 2 anni circa, e
contiene software ampiamente testato;
testing che contiene quella che diventerá la prossima
versione Stable;
unstable che contiene software instabile o sotto
sviluppo attivo;
– p. 2

27. La distribuzione Gentoo
Ultima arrivata tra le distribuzioni piú famose, ha
guadagnato rapidamente popolaritá per l’idea innovativa su
cui si basa: tutto il software installato viene ricompilato in
locale, in modo da ottimizzarlo al massimo dal punto di
vista delle prestazioni.
In questo modo é inoltre sempre immediatamente
disponibile l’ultima versione di ogni programma.
– p. 2

28. La distribuzione Slackware
E’ la distribuzione piú essenziale: il sistema di gestione
delle dipendenze é spartano (ed é stato introdotto in tempi
recenti, prima era compito dell’amministratore del sistema
capire se e come era possibile installare o rimuovere un
dato programma).
E’ anche la distribuzione che permette il massimo grado di
controllo su ció che viene installato nel sistema.
– p. 2

29. Quale é la migliore distribuzione?
Non esiste una distribuzione migliore delle altre. Ogni
buona distribuzione ha un suo campo d’elezione:
Suse/Mandrake per avere un Linux molto user friendly
Fedora per una distribuzione RedHat ma di sviluppo (ed
instabile)
Debian per avere la massima stabilitá e semplicitá di
amministrazione;
Gentoo quando le prestazioni e l’efficienza sono critiche
(ad esempio sui portatili);
Slackware per server Internet molto specializzati
In questo corso ci baseremo su RedHat.
– p. 2

30. Utenti
Gli utenti presenti nel sistema (sia le persone che i processi
di sistema) sono univocamente identificati da un numero
detto UID (User ID). A questo numero é associata poi una
stringa identificativa, ma il kernel considera sempre e solo
l’UID.
É sempre presente un utente, root, identificato da UID pari
a 0 che non ha alcuna restrizione nelle operazioni che
compie sul sistema.
– p. 3

31. Processi - 1
Un processo é l’esecuzione di un programma. Lo stesso
programma puó quindi essere eseguito piú volte anche
contemporaneamente, dando luogo a piú processi distinti.
Ogni processo é identificato univocamente da un numero
detto PID (Process ID). Il PID é unico in un dato momento,
ma puó essere riutilizzato in seguito per un altro processo.
– p. 3

32. Processi - 2
I processi sono organizzati gerarchicamente: ogni processo
ha un processo padre (che é il processo che ne ha chiesto
l’attivazione), ad eccezione del processo init. Due processi
figli dello stesso padre sono detti fratelli. Un processo figlio
diventa orfano quando il processo padre termina (magari
inaspettatamente), e viene “adottato” dal processo init.
– p. 3

33. File - 1
Sotto Linux, come in ogni Unix, tutto é un file.
Tutti i dispositivi fisici collegati al sistema sono visti come
dei file a cui si puó accedere in lettura o in scrittura.
I nomi dei file sono sensibili al maiuscolo (filename é
diverso da FILENAME). I file sono contenuti in directory, e
la directory radice é indicata con /. Nei nomi di file le
directory sono separate dal simbolo /.
– p. 3

34. File - 2
Tutti i filesystem e i dispositivi montati sono visti come
sottodirectory della directory radice.
Ad esempio, il contenuto di un floppy potrebbe essere
presente nella directory /mnt/floppy: quindi le operazioni di
lettura e scrittura dei file in quella directory
leggeranno/modificheranno i file sul floppy.
– p. 3

35. File - 3
Ad ogni file sono associate molte informazioni, come ad
esempio:
Data di creazione, ultimo accesso, ultima modifica
Proprietario del file
Permessi sul file
La combinazione dei permessi sul file, sulla directory in cui
il file é contenuto (e sulle superdirectory in cui é contenuta
la directory) definiscono quali operazioni un utente puó
compiere sul file.
– p. 3

36. File - 4
Esistono diversi tipi di file:
(regular) file
directory
link
socket
named pipe (FIFO)
block device
character device
– p. 3

37. Gerarchia dei file - 1
Gli standard di Linux prevedono una specifica gerarchia di /:
/etc Contiene la configurazione del sistema
/bin Contiene programmi eseguibili (per utenti)
/sbin Contiene programmi eseguibili che possono
richiedere permessi speciali)
/home Contiene le home directory degli utenti
/root Contiene l’home directory dell’utente root
/tmp Directory temporanea
– p. 3

38. Gerarchia dei file - 2
/usr Contiene eseguibili e dati per gli utenti
/opt Riservata a software proprietario
/dev Contiene i device del sistema
/proc Contiene il proc filesystem
/var File di log e informazioni varie
– p. 3

39. La directory /dev - 1
I file presenti in /dev rappresentano tutti i dispositivi
collegati o collegabili al sistema. La lettura o scrittura su
questi file si concreta nella lettura o nella scrittura
direttamente sui dispositivi che rappresentano.
Quindi ad esempio scrivere sulla scheda audio significa
mandare in play un file, e leggere dal file che rappresenta la
tastiera significa acquisire il carattere premuto dall’utente
(se c’é).
– p. 3

40. La directory /dev - 2
I dischi EIDE sono rappresentati secondo questa
numerazione:
/dev/hda Il master della catena primaria
/dev/hdb Lo slave della catena primaria
/dev/hdc Il master della catena secondaria
/dev/hdd Lo slave della catena secondaria
Questi nomi possono essere seguiti da un numero che
indica la partizione (primaria od estesa):
/dev/hda1 Prima partizione di /dev/hda
/dev/hdb2 Seconda partizione di /dev/hdb
– p. 4

41. La directory /dev - 3
Altri elementi in questa directory sono:
/dev/sd... i dischi SCSI (adottano un analogo schema
<disco><partizione> di quelli EIDE)
/dev/tty<...> sono associati alle console
/dev/fd... floppy disk
/dev/usb la directory per i dispositivi USB
– p. 4

42. La directory /dev - 4
/dev/par... le porte parallele
/dev/ttyS... le porte seriali (compreso il mouse)
/dev/zero la lettura da questo file ritorna sempre e solo 0
/dev/null un file di dimensione nulla su cui ogni
operazione di scrittura ha successo
/dev/random un file che si comporta come un generatore
di numeri casuali
– p. 4

43. Il filesystem /proc - 1
La directory /proc contiene il filesystem /proc. I file
contenuti in questa directory permettono di:
1. acquisire informazioni sul sistema
2. fare il tuning del kernel
La directory /proc risiede tutta in memoria, e il contenuto
dei file viene creato dinamicamente quando vengono letti.
– p. 4

44. Il filesystem /proc - 2
Il tuning dinamico dei parametri del kernel viene effettuato
scrivendo i valori desiderati all’interno di file contenuti nella
directory /proc/sys.
I parametri correnti sono visualizzabili leggendo gli stessi
file.
I file del tipo /proc/<nnnn> contengono informazioni sul
processo con PID pari a nnnn.
– p. 4

45. Il filesystem swap
Linux utilizza di solito una partizione del disco come area di
swap. In questa area vengono allocate le pagine di
memoria dei processi attualmente sospesi, in modo tale da
lasciare spazio libero a processi in esecuzione che hanno
bisogno di piú memoria.
É possibile avere piú partizioni di swap per aumentare le
prestazioni, e viceversa avere un file come file di swap.
Lo swap dovrebbe avere una dimensione pari ad 1-2 volte
la memoria disponibile, ma comunque non oltre i 2 GB.
– p. 4

46. Il filesystem tmpfs
Originariamente chiamato shmfs (Shared Memory FS), é
un filesystem che risiede completamente in memoria (sia
centrale che di swap), aumentando o riducendo le proprie
dimensioni a seconda della quantitá di dati in esso presenti.
– p. 4

47. Gli inode
Per ogni file presente viene definito un inode, che é la
struttura in cui sono memorizzati i metadati associati al file
(nome, proprietá, permessi, timestamp) e delle ulteriori
strutture per consentire un accesso diretto veloce ai dati del
file.
– p. 4

48. I filesystem di Linux
Linux ha diversi filesystem nativi a disposizione:
1. ext2/ext3
2. Reiserfs
3. JFS
4. XFS
Tutti questi filesystem offrono le funzionalitá di base di un
filesystem Unix (proprietá e permessi dei file, gestione dei
metadati per ogni file con gli inode).
– p. 4

49. Il filesystem ext2/ext3 - 1
Il primo filesystem sviluppato per Linux è stato il filesystem
ext2. La sua evoluzione ext3 é con esso del tutto
compatibile, aggiungendo solo un file che utilizza come
journal: le operazioni di modifica dei dati e dei metadati su
disco vengono prima scritte nel journal e solo in un
secondo tempo trasferite su disco.
– p. 4

50. Il filesystem ext2/ext3 - 2
In questo modo si evita che una interruzione forzata del
sistema costringa a scansionare tutto il disco per
ripristinare la correttezza dei metadati (se possibile): in un
caso del genere é sufficiente riapplicare le modifiche
presenti nel journal file.
Si puó sempre passare da un filesystem ext2 ad uno ext3 e
viceversa.
– p. 5

51. Il filesystem Reiserfs
É stato il primo filesystem di tipo journaled per Linux. Le
due funzionalitá aggiuntive piú importanti rispetto ad
ext2/ext3 sono:
liste di controllo degli accessi a livello di file
gestione efficiente delle directory con molti file
– p. 5

52. I filesystem XFS e JFS
Sono entrambi filesystem di tipo journaled:
XFS é sviluppato da Sun. Ottimo nei file server, richiede
indispensabilmente un gruppo di continuitá poiché
effettua un notevole caching dei dati e dei metadati in
memoria
JFS sviluppato da IBM
– p. 5

53. I filesystem non nativi
Linux puó accedere in lettura (e in scrittura) a molti altri
filesystem, quali ad esempio:
FAT, VFAT, NTFS, HPFS
ISO9660, UDF
BeOS, QNX
– p. 5

54. Quale filesystem usare?
La scelta del filesystem dipende molto dal tipo di utilizzo
della macchina:
PC personali, piccoli server: ext3 oppure Reiserfs.
mail server e file server: Reiserfs, XFS, JFS.
server Oracle: ext3 (per suggerimento di Oracle
stessa), OCFS, raw devices
– p. 5

55. Come partizionare il disco?
Un buon partizionamento del disco prevede sempre una
piccola partizione di boot, di tipo ext2 oppure ext3, in cui
allocare le immagini dei kernel da lanciare, posizionata
all’inizio del disco e con una dimensione di 100 MB.
Si possono quindi avere piú partizioni per le varie parti del
filesystem (ad esempio, una partizione per i dati degli
utenti), ed una partizione di swap.
L’installazione di tutti i programmi forniti con RedHat non
richiede piú di 5 GB. Oltre a questo bisogna aggiungere lo
spazio per applicativi esterni e per i dati utente.
– p. 5

56. Comandi su file: ls
Il comando ls (list) visualizza il contenuto di una directory.
ls senza parametri oppure ls . fa riferimento alla directory
corrente, mentre ls .. della sovradirectory ..
ls dirname riporta il contenuto della directory dirname (il
parametro passato può essere assoluto o relativo).
Alcuni parametri:
-l per avere informazioni estese sui file;
-R per visualizzare ricorsivamente il contenuto delle
sottodirectory;
-a per visualizzare anche i file che hanno un nome che
comincia con .
-i visualizza il numero dell’inode di ogni file;
I parametri sono combinabili in un unico switch (ls -lR).
– p. 5

57. Comandi su file: pwd
Il comando pwd (Print Working Directory) mostra la
directory corrente.
pwd Mostra la directory corrente.
– p. 5

58. Comandi su file: cd
Il comando cd permette di cambiare directory.
cd dirname per spostarsi nella directory dirname.
cd .. per spostarsi nella directory superiore (lo spazio é
importante!).
cd . rimane nella directory corrente.
cd torna nella home directory dell’utente (equivale cioé a
cd $HOME).
– p. 5

59. Comandi su file: mkdir
Il comando mkdir crea una directory.
mkdir dirname crea la directory dirname.
mkdir -p piu/livelli/insieme crea la directory piu se non
esiste, quindi la sottodirectory livelli se non esiste, quindi la
directory insieme se non esiste.
– p. 5

60. Comandi su file: rm
Il comando rm permette di rimuovere uno o piú file.
rm file rimuove il file senza chiedere conferma.
rm -i file rimuove il file chiedendo una conferma interattiva.
E’ conveniente definire un alias in modo tale che ogni volta
che viene invocato il comando rm si aggiunga in
automatico questo switch.
rm dirname -fR rimuove una directory e tutti i file in essa
contenuti.
I file cosí cancellati non sono recuperabili.
– p. 6

61. Comandi su file: rmdir
Il comando rmdir rimuove una directory purché sia vuota (a
meno di uno switch che lo forzi altrimenti).
rmdir dirname rimuove la directory dirname se questa é
vuota.
– p. 6

62. Comandi su file: cp
Il comando cp permette di copiare un file.
cp sorgente destinazione copia il file sorgente in destinazione. I
nomi possono essere assoluti o relativi.
cp -R dirsor dirdest copia ricorsivamente la directory dirsor nella
directory dirdest.
cp -Rs dirsor dirdest invece di creare i file produce dei link.
cp -p sorgente destinazione copia e mantiene gli stessi
permessi, proprietá e timestamp del file.
Il parametro destinazione deve sempre essere presente; puó
essere il . per indicare la directory corrente.
– p. 6

63. Comandi su file: mv
Il comando mv rinomina un file o lo sposta in un’altra
directory.
mv vecchio nuovo cambia il nome del file da vecchio a
nuovo.
mv *.c backup sposta tutti i file *.c nella directory backup.
mv dir1 dir2 sposta la directory dir1 in dir2.
Se il file destinazione esiste giá, viene sovrascritto. É quindi
consigliabile aggiungere lo switch -i che chiede nel caso
conferma dell’operazione (anche con un alias).
– p. 6

64. Comandi su file: du
Il comando du (Directory Usage) permette di determinare
quanto spazio é occupato dai file di una directory e dalle
sue sottodirectory.
du dirname riporta lo spazio (in KB) usato dalla directory
dirname e da tutte le sottodirectory.
du -sh dirname riporta le informazioni in modo sintetico e
in formato piú humano.
– p. 6

65. Comandi su file: ln - 1
Il comando ln crea un link (hard o soft). Un hard link é a tutti
gli effetti lo stesso oggetto con un altro nome, quindi
cancellando l’hard link si cancella anche l’oggetto di
partenza.
ln file nome-link Il file file risulta accessibile anche con il
nome nome-link.
ln -s file nome-link Come sopra, ma il link creato é un soft
link.
– p. 6

66. Comandi su file: ln - 2
ln -s dir1 nome-link la directory dir1 é ora accessibile
anche via nome-link.
Solo l’utente root puó creare hard link tra directory.
– p. 6

67. Comandi su file: fuser
Il comando fuser (File USER) riporta, per un file passato
come parametro sulla riga di comando, i PID dei processi
che hanno quel file aperto.
$ fuser CorsoLinux.ps
CorsoLinux.ps 3890 4500
– p. 6

68. Comandi su file: file
Il comando file riporta, per ogni file passato
come parametro sulla linea di comando, il tipo del file stesso.
file *
CorsoLinux.out: empty
CorsoLinux.ps: PostScript document text conforming at level 2.0
CorsoLinux.tex: LaTeX 2e document text
archiviazione.tex: ISO-8859 text, with CRLF line terminators
myprog ELF 32-bit LSB executable, Intel 80386 [...]
foto.jpg JPEG image data, JFIF standard 1.02, [...]
– p. 6

69. Comandi su file: touch
Il comando touch imposta l’ora di ultima modifica di un file
all’ora corrente, se il file passato come parametro esiste.
Altrimenti crea un file con il nome dato di dimensione nulla.
touch filename aggiorna l’ora di ultimo accesso a filename
all’ora attuale, ovvero lo crea se non esiste.
Questo comando si rivela utile quando si vuole forzare la
ricompilazione di un sorgente che make non effettua in
quanto il corrispondente file .o é piú recente.
– p. 6

70. Comandi su file: locate, updatedb
Questo comandi permettono di ricercare un file (locate)
consultando un database di nomi di file aggiornato con
updatedb che deve quindi essere eseguito periodicamente.
locate tex ricerca tutti i file che hanno la stringa tex nel
nome o nel percorso.
locate "*d*.tex” é un criterio di ricerca piú complesso che
utilizza le virgolette per evitare l’espansione dei parametri
eseguita dalla shell.
– p. 7

71. Comandi su file: slocate
Il problema di locate é che permette ad un utente di
controllare quali file possiede un altro utente. Questa falla
di sicurezza é stata superata con slocate (secure-locate).
locate é un link verso slocate.
slocate -u crea il database.
slocate pippo ricerca tutti i file che hanno pippo nel nome
o nel percorso, e che sono accessibili all’utente che ha
invocato slocate.
E’ possibile non indicizzare alcune directory.
– p. 7

72. Comandi su file: find - 1
Il comando find permette di ricercare tutti i file che
soddisfano uno o piú criteri, ad esempio che abbiano una
certa dimensione, una stringa nel nome o nel percorso,
alcuni permessi, siano stati creati o modificati in un certo
arco di tempo, ... Sui file ottenuti é possibile compiere una
operazione specifica, che di default é stampare il nome del
file.
find / -name “*.c” ricerca tutti i file che si trovano sotto / e
che terminano in .c.
– p. 7

73. Comandi su file: find - 2
find / -perm 0777 ricerca tutti i file che hanno tutti i
permessi di scrittura, lettura ed esecuzione impostati. Lo 0
iniziale indica che si é adottata la notazione ottale.
find / -name “*.[ch]” ricerca tutti i file sotto / che
terminano in .c oppure in .h
find / -name “*.txt” -print -exec cat { } ; ricerca tutti i file
che terminano in .txt, ne stampa il nome (-print) e su
ognuno di essi esegue il comando cat, con parametro il
nome del file.
– p. 7

74. Comandi su file: grep - 1
Il comando grep permette di ricercare delle stringhe
all’interno di uno o piú file di testo. Se la stringa viene
trovata viene mostrato il nome del file che la contiene e la
riga.
grep saluti filename ricerca la stringa saluti all’interno del
file filename.
grep inode *.c cerca la stringa inode in tutti i file .c della
directory corrente.
– p. 7

75. Comandi su file: grep - 2
grep -v inode source.c mostra tutte le righe di source.c
che non contengono la stringa inode. grep -lv inode *.c
mostra tutti i nomi di file .c che non contengono la stringa
inode.
grep -5 inode *.c scrive, per ogni occorrenza della stringa
inode all’interno di un file .c, le 5 righe seguenti.
grep -B 10 inode *.c come sopra, ma mostra 10 righe
precedenti.
– p. 7

76. Comandi su file: chmod - 1
Il programma chmod consente di impostare i permessi su
uno o più file. I permessi sono r per la lettura, w per la
scrittura e x per l’esecuzione, e si applicano al proprietario
del file (u per user), al gruppo del proprietario (g per group)
e al resto del mondo (o per others).
chmod ugo+r file1 file2 assegna il permesso di lettura al
proprietario del file, al suo gruppo e a tutti gli altri.
chmod o-r file revoca il permesso di lettura del file al resto
del mondo.
– p. 7

77. Comandi su file: chmod - 2
chmod u=rw file imposta il permesso di lettura e scrittura
del file al proprietario, ma non quello di esecuzione. Gli altri
permessi non sono toccati.
chmod o-rwx file toglie i permessi di lettura, scrittura ed
esecuzione al resto del mondo.
– p. 7

78. Comandi su file: chmod - 3
Le modalita’ possono anche essere espresse con la
notazione ottale, usando 3 cifre (una per user, group ed
other). Ogni cifra indica il totale dei permessi che
user/group/other ha sul file, pesati come:
1 esecuzione
2 scrittura
4 lettura
quindi per dare il permesso di lettura (2) e scrittura (4) a
user, group ed other il comando sará: chmod 666 file
– p. 7

79. Comandi su file: chmod - 4
Invece per dare lettura, scrittura ed esecuzione al
proprietario, lettura al gruppo e nessun permesso agli altri il
comando sará: chmod 740 file.
chmod -R <permessi> opera ricorsivamente sulle
directory.
– p. 7

80. Comandi su file: chown
Il comando chown permette di cambiare l’utente
proprietario o il gruppo proprietario di un file.
chown pippo:pluto file Il file file diventa di proprietá
dell’utente pippo e del gruppo pluto.
chown pippo file Il file file diventa di proprietá dell’utente
pippo.
chown -R pippo * Tutti i file della directory corrente e delle
subdirectory diventano di proprietá dell’utente pippo.
– p. 8

81. Operazioni su dischi: /etc/fstab - 1
Il file /etc/fstab contiene la corrispondenza tra dispositivi fisici e
punti di montaggio (mount point), specificando inoltre il tipo del file
system e le opzioni di montaggio.
Il formato delle righe presenti in questo file é:
DispositivoFisico MountPoint TipoDiFilesystem Opzioni Dump OrdineCheck
– p. 8

82. Operazioni su dischi: /etc/fstab - 2
Dove si ha:
DispositivoFisico é il nome del dispositivo (es: /dev/hda);
MountPoint é la directory che mapperá il contenuto del
dispositivo fisico;
TipodiFilesystem é il tipo del file system (ext2, ext3, swap,
VFAT, iso9660,proc);
Dump specifica se il contenuto della partizione deve
essere processato da dump;
OrdineCheck specifica l’ordine in cui il file system deve
essere analizzato al boot;
– p. 8

83. Operazioni su dischi: fstab - 3
Esempio di /etc/fstab:
/dev/hdb1 / ext3 defaults 11
/dev/hda1 /msdos vfat noauto 00
/dev/hdb2 swap swap defaults 00
/dev/hda2 swap swap defaults 00
/dev/cdrom /mnt/cdrom iso9660 noauto,owner,kudzu,ro 0 0
/dev/scd0 /mnt/cdrw iso9660 noauto,user 00
none /dev/pts devpts gid=5,mode=620 00
none /proc proc defaults 00
none /dev/shm tmpfs defaults 00
L’elenco completo delle opzioni é nella pagina di manuale di
mount.
– p. 8

84. Operazioni su dischi: mount - 1
Il comando mount permette di montare un file system.
mount /msdos monta la directory /msdos se esiste una
entrata nel file /etc/fstab che la descrive.
mount -t FSType -o options device dir monta il
dispositivo device nella directory dir con le relative opzioni
ed il filesystem previsto. Puó essere usato quando in
/etc/fstab non é presente l’entrata desiderata.
In ogni caso é possibile montare un file system solo se la
directory corrispondente esiste giá, altrimenti bisogna
crearla con mkdir.
– p. 8

85. Operazioni su dischi: mount - 2
Una opzione particolarmente utile di mount permette di
montare un file come se fosse un disco: in questo modo si
puó ad esempio montare una immagine ISO9660 per
verificarne il contenuto prima di procedere alla
masterizzazione.
mount -t iso9660 -o loop prova.iso /mnt/cdrom/ monta il
file prova.iso nella directory /mnt/cdrom.
mount mostra tutti i file system montati.
– p. 8

86. Operazioni su dischi: umount - 1
Il comando umount (scritto senza la n, é un errore di
ortografia che si tramanda da decenni) smonta un file
system. Affinché questo sia possibile occorre che nessun
processo stia lavorando con quel file system (ad esempio
avendo dei file aperti in lettura o scrittura oppure avendo
una delle directory del file system come directory corrente).
umount /mnt/cdrom smonta il file system mappato su
/mnt/cdrom.
– p. 8

87. Operazioni su dischi: umount - 2
Quindi se si vuole montare un floppy per leggerne o
modificare il contenuto occorre:
1. Inserire il floppy nel lettore
2. Montare il floppy (mount /mnt/floppy)
3. Compiere le operazioni dovute
4. Smontare il floppy (umount /mnt/floppy)
L’ultimo punto é essenziale. Linux puó tenere in memoria (e
scrivere in un secondo tempo) i dati modificati e solo
smontando il dispositivo si forza il trasferimento degli stessi
su disco.
– p. 8

88. Operazioni su dischi: sync
Con questo comando si chiede al sistema di sincronizzare il
contenuto della memoria con i dati su disco, ovvero di
scrivere fisicamente su disco ogni dato (contenuto di file) e
metadato (superblocchi, inodes,...) modificato.
sync sincronizza la cache di tutti i dischi.
– p. 8

89. Operazioni su dischi: /etc/mtab
Il file /etc/mtab contiene l’insieme dei file system
correntemente montati. É quindi un file aggiornato
dinamicamente dal sistema operativo.
$ cat /etc/mtab
/dev/hdb1 / ext3 rw 0 0
none /proc proc rw 0 0
/dev/hdb6 /tmp var ext2 rw 0 0
none /dev/pts devpts rw,gid=5,mode=620 0 0
none /dev/shm tmpfs rw 0 0
– p. 8

90. Operazioni su dischi: fdformat
Con questo comando si puó formattare a basso livello un
floppy.
fdformat /dev/fd0 per formattare il primo floppy.
fdformat /dev/fd0h720 formatta il floppy a 720 KB di
capacitá.
– p. 9

91. Operazioni su dischi: mkfs
Il comando mkfs crea un file system di tipo specificato su
un dispositivo fisico.
mkfs -t FSType <opzioni> dispositivo crea un file system
di tipo FSType con le eventuali opzioni nel dispositivo
dispositivo.
mkfs -t ext3 /dev/hdb3 crea un file system di tipo ext3 nel
dispositivo fisico /dev/hdb3.
Il contenuto del dispositivo viene perso per sempre.
– p. 9

92. Operazioni su dischi: mkisofs
Il comando mkisofs viene utilizzato per creare una immagine ISO9660
(con eventuali estensioni Joliet e/o Rock Ridge).
mkisofs -o immagine.iso /home/user/ crea un file immagine.iso
contenenente tutti i file della directory /home/user, comprese le
sottodirectory. L’immagine ottenuta puó essere poi trasferita su CD-RW
con cdrecord. Alcune opzioni sono:
-f segue i link simbolici, sostituendo quindi al link il contenuto effettivo.
-l consente nomi di file fino a 31 caratteri (viola ISO9660).
-J aggiunge informazioni per Joliet.
-R usa le estensioni Rock Ridge.
-r come sopra ed imposta proprietari e permessi dei file in modo
conveniente.
– p. 9

93. Operazioni su dischi: dd - 1
Il comando dd (Data Dump) permette di leggere e
convertire il contenuto di un file.
dd if=/dev/hda count=4 mostra i primi quattro settori del
disco /dev/hda (if sta per input file).
dd if=/dev/hda of=/dev/hdb copia tutto il contenuto di
/dev/hda in /dev/hdb (of sta per output file).
– p. 9

94. Operazioni su dischi: dd - 2
dd if=/dev/zero of=/dev/hda sostituisce il contenuto di
/dev/hda con una sequenza di 0.
dd if=immagine of=/dev/fd0 bs=512 count=2880
conv=sync Copia una immagine di 1.44MB sul floppy
/dev/fd0; si tratta di 2880 settori da 512 byte l’uno, e
completa ogni blocco con degli spazi (sync).
dd if=dati-iniziali.txt of=dati-finali.txt CONV=lcase
converte il file dati-iniziali.txt in dati-finali.txt sostituendo a
tutte le maiuscole le minuscole.
– p. 9

95. Operazioni su dischi: dump
Il comando dump permette di effettuare backup
incrementali di un intero filesystem.
dump -0u / -f /dev/st0 effettua un dump completo (0)
scrivendo in /etc/dumpdates l’esito della operazione (u) ed
usando come dispositivo di backup /dev/st0 (cartuccia a
nastro).
dump -1u -f /dev/st0 come sopra, ma copiando solo i file
cambiati dall’ultimo backup completo.
dump -2u -f /dev/st0 come sopra, ma copiando solo i file
cambiati dall’ultimo backup di livello 1.
– p. 9

96. Operazioni su dischi: restore
Il comando restore ripristina i file prodotti con un backup dal
comando
restore rf /dev/st0 ricrea il file system leggendolo da
/dev/st0
Il programma puó operare in modo interattivo, e crea il file
restoresymtable per passare informazioni tra i vari ripristini.
– p. 9

97. Operazioni sui dischi: fsck
Il programma fsck verifica e controlla un file system Linux.
fsck -t FSType dispositivo <opzioni> verifica il file system
montato su dispositivo considerandolo di tipo FSType e con
le eventuali opzioni. Si tratta di un front-end per i vari
programmi fsck.<FSType>.
Mentre l’operazione di verifica di un file system ext2 puó
richiedere anche ore (dipendendo dalla dimensione del file
system) su un file system ext3 occorrono pochi secondi (il
tempo di riapplicare il journal).
– p. 9

98. Comandi su file di testo: cat
Il comando cat (concatenate) visualizza il contenuto di uno
o piú file di testo.
cat file.txt visualizza il file file.txt.
cat file1 file2 file3 visualizza file1 e subito a seguire file2 e
subito a seguire file3.
cat - -number file.txt visualizza il file file.txt numerandone
le righe.
– p. 9

99. Comandi su file di testo: zcat
Il comando zcat mostra il contenuto di un file di testo
compresso.
zcat file.txt.gz file2.txt.gz
– p. 9

100. Comandi su file di testo: tac
Il comando tac visualizza uno o piú file di testo in ordine
inverso, partendo dall’ultima riga e procedendo verso la
prima.
tac file.txt visualizza le righe del file file.txt in ordine
inverso partendo dall’ultima.
– p. 10

101. Comandi su file di testo: more
Il comando more mostra il contenuto di uno o piú file di
testo, mostrando una pagina per volta. Premendo invio si
avanza di una riga, premendo spazio si va avanti di una
pagina.
more file.txt
– p. 10

102. Comandi su file di testo: less
Il comando less permette non solo di avanzare (come
more) ma anche di tornare indietro. Si usano a tal fine i tasti
cursore e i PgUp e PgDown. Con il tasto / si puó effettuare
una ricerca di testo all’interno del file visualizzato (andando
in avanti con n e all’indietro con N).
less file.txt
– p. 10

103. Comandi su file di testo: tail
Il comando tail permette di vedere le ultime righe ( o gli
ultimi bytes) di un file di testo. Se il file cresce, con l’opzione
-f si visualizzano le aggiunte.
tail -30 file.txt visualizza le ultime 30 righe del file file.txt.
tail -f file.txt visualizza la parte finale del file file.txt e la
aggiorna una volta al secondo.
L’opzione -f é particolarmente utile per monitorare i file di
log del sistema.
– p. 10

104. Comandi su file di testo: head
Il comando head visualizza le prime righe (o i primi bytes)
di un file di testo.
head pippo.txt visualizza le prime 10 righe (10 é il valore
di default) del file pippo.txt.
head -50 pippo.txt visualizza le prime 50 righe del file
pippo.txt.
– p. 10

105. Comandi su file di testo: wc
Il comando wc conta quanti caratteri, parole o righe
compongono un file di testo.
wc -l pippo.txt Ritorna di quante righe é costituito il file
pippo.txt.
wc -m pippo.txt Ritorna di quanti caratteri é costituito il file
pippo.txt.
wc -w pippo.txt Ritorna di quante parole é costituito il file
pippo.txt.
– p. 10

106. Comandi su file di testo: uniq
Il comando uniq sostituisce a piú righe uguali consecutive
una sola riga.
uniq pippo.txt Produce in output il file pippo.txt con una
sola riga al posto di piú righe uguali consecutive.
uniq -c pippo.txt Per ogni riga in output visualizza a
quante righe uguali consecutive corrisponde.
E’ possibile fare il confronto anche su parti di una riga.
– p. 10

107. Comandi su file di testo: sort
Il comando sort ordina uno o piú file di testo secondo vari
criteri (lessicografico,numerico,mensile), distinguendo o
meno tra maiuscole e minuscole, considerando tutte le
righe oppure solo una porzione delimitata.
sort -g valori.txt Produce in output il file valori.txt ordinato
in modo numerico, considerando tutta la riga.
sort -n - -key 5,5 Ordina numericamente in base al valore
del quinto campo (i campi sono separati da un delimitatore,
di default é lo spazio)
– p. 10

108. Comandi su file di testo: split
Il comando split scompone un file in piú componenti, aventi
una dimensione massima specificata (come numero di
bytes o numero di righe).
split grande.dat - -bytes=1400000 Scompone il file
grande.dat in file xaa xab xac ognuno avente dimensione
massima di 1400000 bytes.
– p. 10

109. Comandi su file di testo: paste
Il comando paste produce un file di testo le cui righe sono
la concatenazione delle righe dei file di input.
cat primo
a
b
cat secondo
1
2
paste primo secondo
a1
b2
– p. 10

110. Comandi su file di testo: join
Il comando join effettua il join di due o piú file di testo,
permettendo di specificare quale é la chiave da usare.
$ cat primo
a a1
b b1
c c1
$ cat secondo
a aaaa
b bbbb
d dddd
$ join primo secondo
a a1 aaaa
b b1 bbbb
– p. 11

111. Comandi su file di testo: tr - 1
Il comando tr (translate) sostituisce una sequenza di
caratteri con un’altra. Il file su cui operare viene passato su
standar input, e l’output é su standard output.
tr a A < file.txt Produce in output il file file.txt dove ogni a é
stata sostituita con A.
tr abc ABC < file.txt Come sopra, ma in piú sostituendo b
con B e c con C.
tr a-z A-Z < file.txt Come sopra ma facendo il maiuscolo di
tutte le lettere dell’alfabeto.
– p. 11

112. Comandi su file di testo: tr - 2
Con la notazione [:CLASS:] si intende una classe di
caratteri, ad esempio:
alpha caratteri alfabetici
alnum caratteri alfanumerici
lower caratteri minuscoli
upper caratteri maiuscoli
blank spazi
digit cifre
– p. 11

113. Comandi su file di testo: tr - 3
Lo switch - -d cancella i caratteri passati come parametro,
mentre - -s sostituisce un carattere ripetuto piú volte
consecutivamente con una sola copia.
tr -d [:blank:] < file.txt cancella tutti gli spazi dal file file.txt
tr -s [:alpha:] < file.txt sostisuisce alle sequenze AA, AAA,
AAA, ... Z, ZZ, ZZZ le sequenze A, ... Z
tr -d aeiou < file.txt cancella le vocali dal file file.txt.
– p. 11

114. Comandi per archiviazione: compress
Il comando compress comprime un file. Il file ottenuto ha un
nome dato dal nome del file originario seguito
dall’estensione .Z, ed il file originario viene rimosso.
compress file.dat Comprime il file file.dat sostituendolo
con il file compresso file.dat.Z
L’algoritmo di compressione utilizzato é il meno efficiente
tra quelli disponibili.
– p. 11

115. Comandi per archiviazione: uncompress
Il comando uncompress decomprime un file compresso con
compress, sostituendo al file compresso la versione
decompressa.
uncompress file.dat.Z decomprime il file file.dat.Z
sostituendolo con il decompresso file.dat.
– p. 11

116. Comandi per archiviazione: gzip
Il comando gzip comprime un file usando lo stesso
algoritmo di PKZIP/WinZip, con cui i file prodotti sono
compatibili. I file compressi hanno l’estensione .gz
gzip file.dat comprime il file file.dat producendo il file
file.dat.gz e rimuovendo il file originario.
– p. 11

117. Comandi per archiviazione: gunzip
Il comando gunzip decomprime un file compresso con gzip.
gunzip file.dat.gz decomprime file.dat.gz sostituendolo
con la versione decompressa file.dat.
gunzip -l file.dat.gz riporta informazioni sul contenuto del
file compresso file.dat.gz.
– p. 11

118. Comandi per archiviazione: zip ed unzip
Questi due comandi permettono di comprimere e
decomprimere un file in modo tale da essere compatibili
con PKZIP/Winzip.
unzip -l file.zip Riporta il contenuto del file compresso
file.zip
– p. 11

119. Comandi per archiviazione: bzip2
Questo é il piú efficiente compressore disponibile, al costo
di un tempo necessario per comprimere il file molto
maggiore rispetto a gzip. I file prodotti hanno l’estensione
.bz2.
bzip2 file.dat Comprime il file file.dat sostituendolo con la
versione compressa file.dat.bz2
bzip -9 file.dat Come sopra, comprimendo al massimo (ed
impiegando piú tempo)
– p. 11

120. Comandi per archiviazione: bunzip2
Il comando bunzip2 decomprime un file compresso con
bzip2.
bunzip2 file.dat.bz2 Decomprime il file file.dat.bz2
sostituendolo con la versione decompressa file.dat.
– p. 12

121. Comandi per archiviazione: tar - 1
Il comando tar (Tape ARchiver) raggruppa piú file in un
unico archivio o viceversa espande un archivio nei suoi file
costituenti. L’archivio ottenuto puó essere compresso con
compress, gzip o bzip2.
Tipicamente il nome dei file di archivio ha l’estensione .tar,
seguito da:
.Z se il l’archivio é stato compresso con compress
.gz se l’archivio é stato compresso con gzip
.bz2 se l’archivio é stato compresso con bzip2
ottenendo quindi ad esempio un archivio dal nome
file.tar.gz (nel caso di compressione con gzip si usa anche
la forma contratta file.tgz).
– p. 12

122. Comandi per archiviazione: tar - 2
Per visualizzare il contenuto di un archivio si usa lo switch
- -list (forma contratta: t).
tar - -list - -file archivio.tar
tar tf archivio.tar
L’opzione - -file indica come l’archivio sia passato come
parametro su linea di comando e non da standard input. Il
nome del file é in tal caso il parametro immediatamente
successivo.
– p. 12

123. Comandi per archivazione: tar - 3
Se l’archivio é compresso con gzip, si aggiunge l’opzione
- -gzip (forma contratta: z).
tar - -list - -gzip - -file archivio.tar.gz
tar tfz archivio.tar.gz
L’opzione - -verbose (v) mostra ulteriori informazioni sui file
che fanno parte dell’archivio (dimensione, proprietà,
permessi).
– p. 12

124. Comandi per archiviazione: tar - 4
Per estrarre un archivio si usa l’opzione - -extract (forma
contratta: x).
tar - -extract - -file archivio.tar
tar xf archivio.tar.gz
tar - -extract - -gzip - -file archivio.tar.gz
tar xfz archivio.tar.gz
– p. 12

125. Comandi per archiviazione: tar - 5
Se l’archivio é stato compresso con bzip2 lo switch da
utilizzare é - -bzip2 (forma contratta: j).
tar - -extract - -bzip2 - -file archivio.tar.bz2
tar xfj archivio.tar.bz2
– p. 12

126. Comandi per archiviazione: tar - 6
Per creare un archivio si usa l’opzione -create (forma
contratta: c). I file che compongono l’archivio vengono
passati da linea di comando. Le directory sono processate
ricorsivamente.
tar - -create - -gzip - -file archivio.tar.gz file1 file2 mydir
tar czf archivio.tar.gz file1 file2 mydir
In questo caso l’opzione - -verbose (v) mostra i nomi dei
file mano mano sono aggiunti.
– p. 12

127. Shell: introduzione - 1
La shell é una interfaccia tra il sistema operativo e l’utente,
il quale sottomette al sistema dei programmi da eseguire
tramite la shell.
Esistono numerose shell per Unix/Linux:
Bourne Shell (sh)
C-Shell (csh)
Korn Shell (ksh)
Bourne Again Shell (bash)
Queste shell hanno molti punti in comune, differenziandosi
per come impostano le variabili di ambiente e le funzioni
predefinite.
– p. 12

128. Shell: introduzione - 2
In tutti i casi, le shell operano a riga di comando: l’utente
scrive una riga in cui specifica il programma da eseguire, gli
eventuali parametri, la modalità di esecuzione, e la invia
alla shell.
$ programma param1 param2 param3
– p. 12

129. Shell: introduzione - 3
Il programma da eseguire puó essere interno alla shell
(come ad esempio alias per Bash) o meno. Se é esterno
puó essere specificato per percorso assoluto (/sbin/ifconfig)
oppure solo con il nome: in tal caso viene ricercato tra tutte
le directory presenti nel percorso di ricerca, definito dalla
variabile di ambiente PATH.
– p. 12

130. Shell: introduzione - 4
Due funzionalitá presenti in Bash sono:
Completion Tab: se si preme il tasto tab mentre si sta
scrivendo un nome di file o un comando la shell lo
completa, se c’é una scelta univoca; altrimenti
ripremendo tab mostra tutte le alternative possibili;
history: usando i tasti cursore su e giù é possibile vedere
l’elenco dei comandi impartiti. Tale elenco é riportato
nel file .bash_history dell’home directory.
– p. 13

131. Shell: variabili di ambiente
Le variabili di ambiente sono impostate con il comando
export.
export CORSO=linux
e se ne puó accedere al valore premettendo al nome il
simbolo $:
$ echo $CORSO
linux
– p. 13

132. Shell: alias
Un alias del tipo:
alias rm=”rm -i”
fa sì che ogni volta che si esegue il comando rm venga in
realtá eseguito il comando rm -i, quindi ad esempio rm a b
c diventerá un piú sicuro rm -i a b c.
Alias e variabili di ambiente sono specifati nei file .bashrc e
.bash_profile dell’home directory.
– p. 13

133. Shell: caratteri speciali: ? e * - 1
I caratteri * e ? sono utilizzati quando, nello specificare dei
nomi di file come parametri di un comando, si vogliono
indicare tutti quei file che hanno una certa struttura nel
nome.
Se l’utente chiede di eseguire $ programma *.txt la shell
chiederá al sistema operativo di eseguire $ programma
primo.txt secondo.txt lettera.txt ... se nella directory
corrente esistono i file primo.txt, secondo.txt, lettera.txt,...
– p. 13

134. Shell: caratteri speciali: ? e * - 2
In modo analogo $ programma dati*dat potrebbe essere
espansa in $ programma dati1.dat dati2.dat dati.dat
dati-finali.dat se questi file esistono nella directory
corrente.
In modo analogo $ programma /usr/l*/a viene espanso in
$ programma /usr/lib/a /usr/local/a /usr/libexec/a
– p. 13

135. Shell: caratteri speciali: ? e * - 3
Il carattere ? invece sostituisce un solo carattere.
$ programma dati?.dat viene espanso in
$ programma dati1.dat dati2.dat
– p. 13

136. Shell: caratteri speciali: ? e * - 4
Se si vuole evitare l’espansione effettuata dalla shell,
occorre racchiudere il parametro contenente i caratteri
speciali tra doppi apici.
$ programma *tex viene espanso in
$ programma archiviazione.tex hardware.tex ...
mentre $programma “*tex” non viene espanso, quindi il
programma invocato riceve come primo parametro la
stringa *tex
– p. 13

137. Shell: redirezione - 1
La redirezione é un meccanismo per cui l’output (o l’input)
di un comando viene inviato (prelevato) da un file, o da un
altro comando.
$programma > risultato Invia l’output di programma al file
risultato; questo file viene azzerato se giá esistente.
$programma » risultato Aggiunge l’ouput di programma al
file risultato.
– p. 13

138. Shell: redirezione - 2
In modo analogo si puó fornire come input di un programma
un file giá esistente.
$programma < argomento
Un caso tipico di utilizzo di questa funzionalitá si ha quando
programma é un server a cui si vogliono inviare i comandi
definiti in argomento.
– p. 13

139. Shell: redirezione - 3
Si puó scegliere di redirezionare non lo standard output di
un programma ma il suo standard error.
$ programma 2> /dev/null esegue il programma inviando
lo standard error sul file /dev/null, ovvero senza mostrare a
video i messaggi di errore.
É possibile redirezionare due o piú tra standard input,
standard output e standard error in contemporanea:
$programma > risultato < argomenti 2> errori.
– p. 13

140. Shell: redirezione - 4
L’ultima e piú potente possibilitá é quella che prevede di
utilizzare l’output di un programma come l’input di un altro
programma.
$ programma1 | programma2 l’output del programma1
diventa l’input del programma programma2. E’ possibile
concatenare piú programmi in questo modo, ognuno con i
propri parametri.
– p. 14

141. Shell: esecuzione in background
Per eseguire un processo in background occorre terminare
la riga di comando con il simbolo &. In questo modo la
console continua ad essere disponibile per eseguire altri
programmi.
$ programma & esegue programma in background.
La redirezione non viene effettuata automaticamente,
quindi potrebbe essere necessario specificare l’output e
l’input, per non “sporcare” la console.
– p. 14

142. Shell: esecuzione con && e ;
Una riga del tipo:
$ programma1 && programma2
causerá l’esecuzione di programma1, e solo se questo
programma termina con successo verrá quindi eseguito
programma2.
$ programma1 ; programma2
causa l’esecuzione di programma1 e quindi di programma2.
– p. 14

143. Shell: umask
Con il comando umask si puó leggere od impostare la
modalitá con cui vengono creati i file. I valori restituiti sono
espressi secondo la stessa sintassi di chown.
umask mostra la modalitá di creazione standard dei file.
umask -S come sopra, ma in modo simbolico.
umask o-rwx toglie tutti i permessi al resto del mondo.
– p. 14

144. Utenti: /etc/passwd - 1
Il file /etc/passwd contiene l’elenco degli account presenti
nel sistema. La struttura del file é la seguente:
account password UID GID GECOS directory shell
L’utente root ha sempre UID e GID pari a 0.
Gli utenti con UID inferiore a 99 sono account di sistema.
– p. 14

145. Utenti: /etc/passwd - 2
Il significato dei campi é il seguente:
account identificativo dell’utente
password la password (se non si usano shadow
password)
UID lo User ID dell’utente
GID il Group ID del gruppo primario dell’utente
GECOS informazioni descrittive (es. nome completo)
directory l’home directory dell’utente
shell la shell attivata con il login
Se come shell é indicata /sbin/nologin, /bin/false o simili,
l’utente non puó mai accedere al sistema con un login.
– p. 14

146. Utenti: /etc/passwd - 3
Esempio di file /etc/passwd:
root: x: 0: 0: root: /root: /bin/bash
bin: x: 1: 1: bin: /bin: /sbin/nologin
daemon: x: 2: 2: daemon: /sbin: /sbin/nologin
...
ftp: x: 14: 50: FTP User: /var/ftp: /sbin/nologin
...
apache: x: 48: 48: Apache: /var/www: /bin/false
...
paolo: x: 500: 500: : /home/paolo: /bin/bash
mario: x: 501: 501: Mario Rossi: /home/mario: /bin/bash
(gli spazi sono stati aggiunti per chiarezza).
– p. 14

147. Utenti: /etc/passwd - 3
Nell’esempio precedente le password cifrate sono indicate
con delle x. Questo perché é presente il meccanismo delle
shadow password: le password (cifrate) sono riportate nel
file /etc/shadow, in modo da impedire attacchi a forza bruta
per decifrare le password ( /etc/passwd deve essere
leggibile a tutti, mentre /etc/shadow è accessibile solo a
pochi processi).
É fortemente consigliato attivare il meccanismo delle
shadow password.
– p. 14

148. Utenti: passwd
Con il comando passwd si puó definire la propria password,
oppure modificare quella di un dato utente il cui username
é passato come parametro (avendo i permessi per farlo).
– p. 14

149. Utenti: su
Il comando su (Set User) permette di cambiare la propria
identitá con quella di un altro utente, specificato su linea di
comando come parametro. Se non c’é alcun parametro si
intende root. Occorre fornire la password dell’utente
desiderato perché l’operazione possa compiersi.
Con su user si chiede di assumere l’identitá dell’utente
user, mentre con su - user si esegue inoltre tutta la fase di
login.
– p. 14

150. Utenti: /etc/group - 1
Il file /etc/group contiene l’elenco di tutti i gruppi presenti nel
sistema. Per ogni gruppo viene riportato l’elenco degli
utenti che ne fanno parte.
groupname password GID user-list
– p. 15

151. Utenti: /etc/group - 2
Il significato dei campi é il seguente:
groupname il nome del gruppo
password la password associata al gruppo (se presente e
se non si usano le shadow password)
GID il Group ID
user-list l’elenco, separato da virgole, degli account che
fanno parte del gruppo.
– p. 15

152. Utenti: /etc/group - 3
Esempio di un file /etc/group:
root: x: 0: root
bin: x: 1: root,bin,daemon
...
wheel: x: 10: root
paolo: x: 500:
In caso di shadow password le password dei gruppi sono
riportate cifrate in /etc/gshadow.
(tipicamente non si usano password per i gruppi).
RedHat usa, per ogni utente non di sistema, un gruppo che
ha l’utente come unico partecipante, e con GID uguale
all’UID.
– p. 15

153. Utenti: useradd
Il comando useradd consente di aggiungere un utente al
sistema.
useradd <-s shell> <-d home_dir> <-u UID> <-p
passwd> account
– p. 15

154. Utenti: userdel
Il comando userdel rimuove un utente dal sistema.
userdel account
Se si aggiunge lo switch -r viene rimossa anche la home
directory dell’utente e la mailbox.
– p. 15

155. Utenti: groupadd
Il comando groupadd aggiunge un gruppo al sistema.
groupadd <-g GID> group-name
– p. 15

156. Utenti: groupdel
Il comando groupdel rimuove un gruppo dal sistema, se non
ci sono piú utenti nel sistema appartenenti a quel gruppo.
groupdel <group-name>
– p. 15

157. L’ambiente grafico: X
La gestione dell’ambiente grafico viene realizzata mediante
piú programmi. Alla base c’é l’X Server, che realizza
l’astrazione dall’hardware grafico e mette a disposizione di
ulteriori programmi delle primitive come la gestione di
finestre a video.
L’ambiente si chiama X Window System, o anche X11, o
X11R6.
– p. 15

158. L’ambiente grafico: X server e X client
X é progettato per operare su rete, con un server che
accetta le richieste dell’utente inviandole a dei programmi
client di cui mostra l’output.
Il server puó operare su piattaforme diverse da Linux.
– p. 15

159. L’ambiente grafico: desktop manager
Sulle funzionalitá offerte da X sono poi definiti dei desktop
manager, come ad esempio Gnome e KDE. Ne esistono
molti altri, che hanno ad esempio richieste di memoria e di
processore meno esose.
É importante ricordare che il kernel, X, il desktop manager
sono tutte componenti distinte tra loro: gli ultimi due sono
solo degli insiemi di programmi applicativi a cui il kernel
offre dei servizi come a tutti gli altri.
– p. 15

160. L’ambiente grafico: /etc/X11/XF86Config
Il file /etc/X11/XF86Config contiene la configurazione di X,
specificando informazioni quali la scheda video, il monitor, i
dispositivi di input, e l’uso o meno di alcune funzionalità
come ad esempio i caratteri freetype.
– p. 16

161. L’ambiente grafico: xf86config
E’ il programma che permette di generare il file di
configurazione per X. Le schede disponibili sono riportate
nella directory /usr/share/hwdata.
– p. 16

162. Stampare: /etc/printcap e printtool
Questo file contiene la descrizione di tutte le stampanti
collegate al sistema, insieme ad un loro nome simbolico da
utilizzare per indicarle.
Questo file puó essere modificato sia a mano che tramite
redhat-config-printer (printtool).
– p. 16

163. Stampare: CUPS
Il Common Unix Printing System é il nuovo sistema di
configurazione delle stampanti, che gestisce molto meglio
le stampanti non laser rispetto a printtool. La sua
configurazione avviene tramite una interfaccia web.
– p. 16

164. Stampare: lpr
Una volta che si é configurata la stampante, per stampare
da linea di comando si puó utilizzare il comando lpr, che
opera anche come uno spooler di stampa.
lpr -P laser file.ps stampa il file file.ps utilizzando la
stampante di nome laser.
– p. 16

165. Stampare: lpq
Il comando lpq mostra lo stato della coda di stampa per una
specificata stampante.
lpq -P laser mostra la coda di stampa per la stampante di
nome laser.
– p. 16

166. Stampare: lprm
Il comando lprm consente di rimuovere un dato job dalla
coda di stampa di una stampante.
lprm -P laser 2 Rimuove il secondo job dalla coda.
lprm -P laser all Rimuove tutti i job dalla coda.
– p. 16

167. Stampare: lpd
Il demone lpd é il processo che si occupa della gestione
della stampa, gestendo lo spool di stampa.
Tramite i suoi file di configurazione si puó stabilire chi ha
diritto di stampare e su quali stampanti, gestire l’accounting
delle stampe, ecc..
– p. 16

168. Interoperabilitá: SCP
Per trasferire file da e verso una macchina Linux su cui si
ha un account si puó usare il comando scp:
scp file user@host:percorso
Esistono implementazioni di scp per tutti i sistemi operativi.
Inoltre per Windows esiste una versione grafica, WinScp:
http://winscp.sourceforge.net, che é open source.
– p. 16

169. Interoperabilitá: FTP e ssh
Se sulla macchina Linux é installato un server FTP é
possibile prelevare (ed eventualmente depositare) file
adottando un qualsiasi client FTP.
Un client SSH per Windows open source é ad esempio
PUTTY.
– p. 16

170. Interoperabilità: VNC - 1
Se sulla macchina Linux viene installato e configurato un
server VNC, si puó accedere in modalitá grafica con un
client VNC, utilizzando ad esempio:
RealVnc, http://www.realvnc.com
TightVnc, http://www.tightvnc.com
– p. 17

171. Interoperabilitá: VNC - 2
Il vantaggio principale di VNC é che il client è di dimensioni
minime (100 Kb). Il limite principale é rappresentato dal
fatto che tutti i dati viaggiano in chiaro!
VNC non deve mai essere usato in un ambiente di
produzione o per controllare un server non in una rete
locale.
– p. 17

172. Interoperabilitá: VNC - 3
Per utilizzare VNC occorre specificare sia l’hostname della
macchina remota che l’utente con cui ci si vuole collegare.
La sintassi adottata in genere é host:utente, per cui
10.2.3.60:0 potrebbe essere l’utente X della macchina
10.2.3.60, mentre 10.2.3.60:1 potrebbe essere l’utente Y.
Ciascuno di questi utenti ha una propria password ed un
proprio desktop.
– p. 17

173. Interoperabilitá: Server X - 1
E’ possibile installare un server X che consenta quindi di
avere una modalitá grafica e di avere il traffico cifrato con
SSH.
Non esistono server X per Windows gratuiti. Tra quelli a
pagamento citiamo HummingBird Exceed.
– p. 17

174. Interoperabilitá: Server X - 2
Per attivare una sessione X sotto Windows occorre
tipicamente:
1. Attivare il server X sotto Windows, eventualmente
specificando che deve accettare connessioni dalla
macchina Linux (remota);
2. Collegarsi via SSH alla macchina Linux, ed impostare
la variabile di ambiente DISPLAY in questo modo:
export DISPLAY=<ip-macchina-windows>:0.0;
3. Comunicare al server X (locale) che si accettano
connessioni da remoto, ad esempio con il comando
xhost +
4. Lanciare l’applicazione richiesta, o l’intero ambiente
grafico (ad esempio con gnome-session);
– p. 17

175. Data ed ora: date
Il comando date riporta che ora é. É possibile specificare
diversi formati con cui visualizzare l’ora, cosí come
chiedere di visualizzare una data ora in un certo formato.
date Mostra l’ora corrente
date - -date=”08:00:00 PST” mostra l’ora passata come
parametro nell’ora corrente
– p. 17

176. Data ed ora: hwclock - 1
Per determinare che ora é, Linux utilizza una struttura a
livelli. Alla base c’é l’hardware clock, ovvero l’orologio
aggiornato dalla batteria tampone. Il comando hwclock
permette di leggere od impostarne il valore.
L’unica funzione di questo orologio hardware é di tenere
conto dell’ora quando Linux non é in funzione.
– p. 17

177. Data ed ora: hwclock - 2
L’orologio hardware non é molto accurato, ma la maggior
parte degli errori che compie sono predicibili: va avanti od
indietro di una quantitá quasi costante, che puó essere
calcolata e di cui il kernel puó tenere conto per correggere
l’ora.
Questa correzione viene eseguita con l’opzione - -adjust
– p. 17

178. Data ed ora: Timezone
All’ora contenuta nell’hwclock bisogna aggiungere le
quantitá dovute al fuso orario e all’ora legale: in questo
modo quando cambia l’ora legale non occorre intervenire
sul clock hardware.
La timezone é configurabile tramite il programma
redhat-config-date
– p. 17

179. Data ed ora: NTP
É spesso necessario che tutti i computer presenti in rete
abbiano la stessa ora. Per questo esiste un protocollo di
sincronizzazione apposito, il Network Time Protocol.
Il protocollo NTP si basa sull’utilizzo di server NTP, che
forniscono l’ora, e su client NTP, che vi si adeguano.
– p. 17

180. Data ed ora: ntpdate
Il comando ntpdate regola l’ora secondo quella riportata da
un server ntp passato come parametro. L’adeguamento é
immediato.
ntpdate ntp.ien.it Usa il server dell’Istituto Elettrotecnico
Nazionale (l’ora ufficiale italiana). Altri server sono:
ntp2.ien.it
ntps.net4u.it
ntpdate 10.16.0.62 (Fastweb)
ntpdate 10.96.0.62 (Fastweb)
É sempre consigliato (e dovuto) utilizzare i server NTP del
proprio provider.
– p. 18

181. Data ed ora: ntpd
Il demone ntpd sincronizza costantemente l’ora con quella
di uno o piú server NTP, e puó a sua volta operare come
client. La sua configurazione é riportata nel file
/etc/ntp.conf. Gli aggiornamenti che effettua sono
progressivi, quindi conviene procedere una prima volta con
ntpdate e poi lasciare il compito delle correzioni minime a
ntpd.
– p. 18

182. Hardware: lspci
Il comando lspci mostra l’elenco dei dispositivi presenti sul
bus pci.
lspci -v riporta piú informazioni.
lspci -vv riporta ulteriori informazioni.
– p. 18

183. Hardware: /proc/cpuinfo
Il file /proc/cpuinfo contiene informazioni su tutti i processori
presenti nel sistema.
cat /proc/cpuinfo
processor : 0
vendor id : GenuineIntel
cpu family : 5
model : 4
model name : Pentium MMX
stepping : 3
cpu MHz : 200.458
...
– p. 18

184. Hardware: /proc/interrupts
Il file /proc/interrupts riporta, per ogni IRQ di ogni
processore presente nel sistema, quante volte é scattato e
a quale dispositivo é associato.
CPU0
0: 3152659 XT-PIC timer
1: 135243 XT-PIC keyboard
2: 0 XT-PIC cascade
4: 327829 XT-PIC serial
5: 1 XT-PIC soundblaster
8: 1 XT-PIC rtc
12: 0 XT-PIC eth0
...
– p. 18

185. Controllare il sistema: df
Il comando df (disk free) mostra per ogni partizione montata
quanto spazio é stato usato, quanto é ancora disponibile
(tutto in blocchi da 1 KB) e il mount point.
df riporta lo spazio utilizzato
df -i riporta quanti inode sono stati usati e quanti sono liberi.
df -h usa MB E GB come abbreviazioni.
– p. 18

186. Controllare il sistema: free
Il comando free riporta informazioni sull’occupazione della
memoria.
$ free
total used free shared buffers cached
Mem: 94964 88188 6776 0 8708 43308
-/+ buffers/cache: 36172 58792
Swap: 532268 7164 525104
– p. 18

187. Controllare il sistema: whereis
Il comando whereis ricerca i sorgenti, i binari e le pagine di
manuale per un dato comando. Non considera il PATH
corrente! Il suo scopo é quello di mostrare se un comando
é installato nella locazione standard.
$ whereis ls
ls: /bin/ls /usr/share/man/man1/ls.1.gz
– p. 18

188. Controllare il sistema: which
Il comando which ricerca, nel PATH corrente, il/i parametri
passato come argomento, permettendo quindi di vedere
cosa viene invocato in caso di esecuzione dell’argomento
stesso. Se non trova nulla mostra il PATH corrente.
$ which ls
alias ls=’ls –color=tty -a -F -v’
/bin/ls
Ovvero il comando eseguito é /bin/ls e sono
automaticamente aggiunti i parametri riportati nell’alias.
– p. 18

189. Controllare il sistema: ps - 1
Il comando ps mostra i processi in corso di esecuzione sul
sistema. Sono possibili diverse opzioni combinabili tra loro,
sia per selezionare i processi da mostrare che per le
modalitá di visualizzazione.
ps mostra i processi interattivi associati alla console
dell’utente
ps -A oppure ps -e mostra tutti i processi del sistema.
ps a mostra tutti i processi del terminale corrente.
ps x seleziona solo i processi senza terminale (i demoni).
– p. 18

190. Controllare il sistema: ps - 2
ps -f Output esteso.
ps -v Mostra la quantitá di memoria usata.
ps -e Mostra l’ambiente usato dal comando.
ps - -cols 100 pone a 100 la dimensione di una riga
(mostra solo i primi 100 caratteri per riga)
Combinazioni tipiche:
ps acxfu
ps -ef
– p. 19

191. Controllare il sistema: top
Il comando top mostra lo stato del sistema e i processi in
esecuzione, ordinati per quantitá di CPU utilizzata. I dati
sono aggiornati ogni 5 secondi. Lanciato il comando si puó:
cambiare l’intervallo di aggiornamento con s
ordinare per memoria usata con M
uccidere un processo con k
ottenere l’help con h
uscire con q
– p. 19

192. Controllare il sistema: w e whoami
Il comando w (Who) riporta l’elenco degli utenti collegati al
sistema.
Il comando whoami riporta l’identitá dell’utente che lo
lancia.
– p. 19

193. Controllare il sistema: watch
Il comando watch permette di eseguire un comando
(passato come parametro) periodicamente, mostrandone
l’output a schermo.
watch ls /var/log esegue ogni 2 secondi il comando ls
/var/log
watch -n 10 - -differences esegue ogni 10 secondi il
comando uptime e enfatizza le differenze tra esecuzioni
consecutive.
Si termina il comando premendo Ctrl-c (con Ctrl-z si mette
il programma in background).
– p. 19

194. Controllare il sistema: nice
Il comando nice esegue un programma con una prioritá
impostata. (ogni programma viene per default eseguito con
la stessa prioritá del programma che l’ha lanciato).
nice -20 program esegue program con la massima prioritá.
nice 19 program esegue program con la prioritá minima.
nice Mostra la prioritá corrente.
nice program Esegue il programma con un aggiustamento
pari a 10 (ovvero con meno prioritá!)
– p. 19

195. Controllare il sistema: renice
Il comando renice permette di cambiare la prioritá di uno o
piú processi in esecuzione. I processi sono specificati per
PID, gruppo o utente.
renice +1 1234 Riduce la prioritá del processo con PID pari
a 1234.
renice -2 -u root Aumenta di 2 la prioritá dei processi con
owner pari a root.
– p. 19

196. Controllare il sistema: kill - 1
Il comando kill invia un segnale ad un dato processo. Se il segnale
viene omesso il segnale é TERM (terminazione dolce). Questo
comando é localizzato in /bin/kill, molte shell hanno una funzione
kill interna che viene eseguita al posto del comando se non viene
specificato il PATH completo. Ad esempio, la shell Bash ha una
funzione kill che accetta anche il nome del programma a cui inviare
il segnale, mentre il programma kill vuole il PID.
kill program Esegue il kill della shell (se presente), altrimenti il
programma /bin/kill mandando in entrambi i casi il segnale TERM al
programma program.
– p. 19

197. Controllare il sistema: kill - 2
/bin/kill -9 program Invia il segnale KILL (terminazione
immediata) al programma programma. Se l’utente é
autorizzato ad inviare questo segnale il risultato é che il
programma program termina immediatamente, tutte le
risorse (di memoria, di processore ecc) ad esso associate
sono rilasciate.
É opportuno inviare prima un kill senza parametri, in modo
da permettere al programma di terminare dolcemente
(chiudendo i file aperti, svuotando i buffer). Se il
programma, dopo qualche secondo, non termina, lo si puó
ammazzare.
– p. 19

198. Controllare il sistema: kill - 3
Spesso questo comando puó essere usato per forzare un
server (ovvero un demone in esecuzione) a leggere un file
di configurazione che é stato cambiato, senza riavviare il
demone stesso.
kill -SIGUSR2 xinetd Forza il programma xinetd a rileggere
la configurazione.
– p. 19

199. Controllare il sistema: nohup - 1
Il segnale HUP (Hang UP) viene inviato ad un programma
quando il processo padre é terminato oppure il terminale
che lo controlla viene rilasciato, quindi ad esempio quando
un utente fa il logout. Se si vuole che il programma continui
a girare (in background) lo si deve lanciare con il comando
nohup.
nohup program param1 ... paramN Esegue il comando
program con parametri param1 ... paramN immunizzandolo
agli hang-up.
– p. 19

200. Controllare il sistema: nohup - 2
nohup wget -t 0 -c -q ftp://URL Preleva il file ftp://URL in
modalitá silenziosa (-q), continuando ogni volta da dove si
era interrotto (-c) finché non lo ottiene tutto (-t 0). Se
l’utente che ha lanciato il programma effettua il logout il
trasferimento prosegue.
– p. 20

201. Controllare il sistema: jobs
É un comando di shell che mostra quali processi sono in
background. I processi in background, oltre ad essere
comunque identificati dal loro PID, sono identificati da
numero intero progressivo dalla shell, preceduto dal segno
%.
$ jobs
[1]+ Stopped watch ls
– p. 20

202. Controllare il sistema: fg
Il comando di shell fg (foreground) riporta in primo piano il
processo in background indicato.
fg %1 riporta in background il processo indicato dalla shell
come %1.
– p. 20

203. Controllare il sistema: bg
Il comando di shell bg (background) manda in background il
processo indicato.
bg %1 manda in background il processo indicato dalla shell
come %1. Se il processo é quello che controlla il terminale
corrente, si ottiene (in genere) lo stesso effetto premendo
Ctrl-Z.
– p. 20

204. Controllare il sistema: uname
Il comando uname riporta una serie di informazioni sul
sistema.
uname Riporta il nome del sistema operativo (Linux).
$ uname -a
Linux my.computer.tld 2.4.22 #8 Wed Oct 15 13:17:49
CEST 2003 i586 unknown
– p. 20

205. Controllare il sistema: swapon e swapoff
Questi due comandi attivano (swapon) e disattivano
(swapoff) una o piú partizioni di swap. Le partizioni di swap
sono attivate all’avvio del sistema. Con il flag -s si
ottengono informazioni sull’uso delle partizioni medesime.
– p. 20

206. Controllare il sistema: vmstat
Il comando vmstat mostra informazioni sull’uso della
memoria virtuale ( principale e di swap).
vmstat
Sotto le colonne si ed so sono riportati (in KB/s) i dati di
swap in (da disco) e swap out (su disco). La descrizione di
tutti i dati mostrati é nella pagina di manuale.
vmstat n ricalcola e mostra i dati ogni n secondi.
– p. 20

207. Controllare il sistema: dmesg
Il comando dmesg riporta quanto stampato dal sistema
durante l’ultimo boot. Puó quindi essere usato per vedere
se tutto l’hardware é stato rilevato e configurato
correttamente.
– p. 20

208. Controllare il sistema: /var/log/messages
Il file /var/log/messages contiene numerose informazioni
sull’attivitá del sistema, come ad esempio il login e il logout
degli utenti, l’installazione e rimozione di moduli del kernel,
la partenza di alcuni programmi.
– p. 20

209. Networking: ping
Il comando ping permette di verificare se un host o un
router (specificato per nome o per indirizzo IP sulla riga di
comando) é raggiungibile o meno.
ping hostname-or-address
– p. 20

210. Networking: traceroute
Il comando traceroute mostra il percorso seguito dai
pacchetti per raggiungere un host.
/usr/sbin/traceroute hostname-or-address
– p. 21

211. Networking: telnet
Il comando telnet apre una connessione TCP con l’host
specificato sulla linea di comando e sulla porta specificata;
se la porta non viene specificata si intende la 23 (remote
shell o telnet).
telnet hostname-or-address <port>
É il modo piú semplice di verificare se un certo servizio di
rete é attivo o meno (porta 110 per POP3, 80 per HTTP, 25
per SMTP, 21 per FTP...)
– p. 21

212. Networking: ssh - 1
I dati spediti via telnet sono tutti in chiaro, e questo rende il
protocollo non sicuro (ed é il motivo per cui l’accesso in
remoto via telnet é di solito disabilitato).
Il programma ssh consente di accedere in remoto ad una
macchina via il protocollo SSH, quindi con tutto il traffico
cifrato.
ssh username@macchina
– p. 21

213. Networking: ssh - 2
Il nome della macchina remota deve essere sempre
specificato. Se lo username non viene specificato si utilizza
lo stesso della sessione della macchina locale.
ssh -X username@macchina esporta la modalità grafica.
Sulla macchina locale deve essere presente un client X.
– p. 21

214. Networking: scp
Il comando scp (secure cp) consente di copiare file da/su
una macchina remota, cifrando il traffico. Puó essere usato
come alternativa sicura (e piú facilmente configurabile) di
un ftp server e client.
scp sorgente destinazione
Se sorgente o destinazione sono locali si usa la normale
sintassi per i nomi di file. Altrimenti occorre specificare
anche lo username e la macchina sorgente/destinazione:
username@macchina:percorso-file
– p. 21

215. Networking: ftp
Il comando ftp apre una sessione FTP con un’host remoto.
ftp hostname-or-address
Una volta aperta la sessione occorre autenticarsi
(tipicamente con username uguale ad anonymous e
password un indirizzo di e-mail). Ciò fatto si naviga nel
server FTP con i comandi ls, cd, pwd analoghi a quelli di
Unix, e si preleva un file con get <nomefile>.
– p. 21

216. Networking: whois
Il comando whois interroga un database whois, e permette
quindi di ottenere informazioni sui gestori di un dominio o
sul proprietario di un indirizzo IP.
whois <-h whois-server> domain-or-address
– p. 21