gnu/linux debian/ubuntu - ferrazzi · gnu/linux proprio per questo motivo. the gnu general public...

Dott.Ing.Ivan Ferrazzi

GNU/LINUXDEBIAN/UBUNTU

Amministrazione

1/108


2/108


Copyright ©2012 Dott.Ing. Ivan FerrazziPermission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.

3/108


Indice generaleINTRODUZIONE....................................................................................................6

La storia di Linux e GNU..................................................................................6The GNU General Public License......................................................................7Debian: una delle distribuzioni di Linux...........................................................8

INSTALLAZIONE DEL SISTEMA.............................................................................9Lavorare con i dischi rigidi...............................................................................9Struttura base delle cartelle di Linux.............................................................10Installazione di Debian...................................................................................11

NOZIONI BASE SU LINUX...................................................................................16I caratteri “jolly” (wildcards) e gli intervalli...................................................16

MANAGEMENT DEI FILE......................................................................................17Utilizzare i comandi cd e pwd (print work directory).....................................18Utilizzare il comando ls..................................................................................19Utilizzare il comando touch............................................................................21Utilizzare il comando cp.................................................................................22Utilizzare il comando mv................................................................................24Rimuovere file o directory con i comandi rm e rmdir.....................................25Creare delle directory con il comando mkdir.................................................26Creare link su files.........................................................................................27

COMANDI BASE PER OPERARE SU FILE DI TESTO..............................................29Il ridirezionamento.........................................................................................29Utilizzando “Pipes”.........................................................................................30L'irrepressibile cat.........................................................................................30Visualizzare una parte o tutto il file con nl, head e tail..................................32I comandi cut e paste....................................................................................34Ordinare, contare, formattare e trasformare file di testo..............................36

EFFETTUARE RICERCHE IN FILE DI TESTO.........................................................40La familia dei comandi grep e le “regular expression”..................................40Come utilizzare il comando sed ....................................................................44

UTENTI E GRUPPI...............................................................................................49Il comando su.................................................................................................49I file di sistema /etc/passwd, /etc/shadow e /etc/group.................................50Creare un nuovo utente.................................................................................52Eliminare un utente.......................................................................................53Modificare l'account di un utente...................................................................53Aggiungere un nuovo gruppo........................................................................54Eliminare un gruppo......................................................................................54Modificare un gruppo.....................................................................................54Visualizzare l'appartenenza ad un gruppo.....................................................55Modificare la parola chiave............................................................................55

PERMESSI...........................................................................................................56Permessi simbolici e numerici........................................................................56Cambiare il proprietario di un file o una directory.........................................57Cambiare il gruppo di un file o di una directory.............................................58Modificare i permessi.....................................................................................58Assegnazione di permessi default per nuovi file............................................60

4/108


SUID e SGID...................................................................................................60Sticky bit........................................................................................................61

COMUNICAZIONE AGLI UTENTI..........................................................................62/etc/issue.......................................................................................................62/etc/issue.net.................................................................................................62/etc/motd.......................................................................................................63

RUNLEVELS........................................................................................................64GESTIONE DEI PROCESSI...................................................................................66

Gestire i processi...........................................................................................66Modificare la priorità dei processi..................................................................69

LA GESTIONE E LA MANUTENZIONE DELLE PARTIZIONI E DEI FILESYSTEM.......71Creare e formattare una partizione...............................................................71Rendere un'unità visibile al sistema..............................................................72Mantenere l'integrità di un filesystem...........................................................74Utilizzare il comando dd.................................................................................75

UTILIZZARE DOCUMENTAZIONI.........................................................................77Aiutarsi con le MAN PAGES............................................................................77Localizzare le MAN PAGES.............................................................................78Ricerca all'interno delle sezioni di man pages...............................................79Effettuare ricerche con whatis.......................................................................80Effettuare ricerche con apropos.....................................................................80Configurazione degli accessi alle man pages................................................81Utilizzare documentazioni presenti in /usr/doc..............................................81

LA GESTIONE DEI PACCHETTI DEBIAN...............................................................82Il programma dpkg........................................................................................82Il programma apt-get.....................................................................................83Il programma alien.........................................................................................85

INSTALLARE PROGRAMMI E LE SHARED LIBRARIES...........................................86Installazione dei programmi da sorgente.......................................................86Le shared libraries.........................................................................................87

INSTALLAZIONE DEL BOOTMANAGER................................................................89L'installazione di grub....................................................................................90Il file di configurazione /boot/grub/menu.lst..................................................90

GESTIONE DEL KERNEL E DEI SUOI MODULI......................................................92Lista dei moduli caricati.................................................................................93Caricare singoli moduli..................................................................................93Caricare moduli e dipendenze con un unico comando..................................94Rimuovere moduli caricati.............................................................................94Quali parametri utilizzare con un modulo......................................................94Il comando uname.........................................................................................95

LA CONFIGURAZIONE, LA COMPILAZIONE E L'INSTALLAZIONE DI UN KERNEL. .96Configurare il proprio Kernel..........................................................................96Compilazione del Kernel e dei suoi moduli....................................................97Attivazione del Kernel....................................................................................98

AMBIENTE SHELL E SEMPLICI SCRIPT................................................................99Ambiente shell...............................................................................................99Le variabili di ambiente...............................................................................100Semplici script.............................................................................................102

5/108


6/108


INTRODUZIONE

La storia di Linux e GNU

Il sistema operativo UNIX è stato creato a Bell Labs nei primi anni '70. E' stato creato come ambiente di lavoro in multiutenza. UNIX è probabilmente uno dei più noti sistemi operativi che risalgono ai primi tempi dei sistemi computerizzati. Il costo molto elevato e la necessità di macchine molto potenti non hanno permesso la diffusione di questo sistema. Sono state create delle versioni di UNIX compatibili anche con l'hardware dei comuni personal computer, ma anche qui il costo ha inciso molto sulle vendite. Questi problemi hanno portato allo sviluppo di Linux.

Molte persone associano Linux a Linus Torvalds. Linus ha inizialmente sviluppato il kernel ed è ancora il capo tecnico, ma il resto del sistema di Linux è stato sviluppato da altre persone.

Uno studente dell'Università di Helsinki in Finlandia di nome Linus Torvalds ha creato il kernel di Linux. Il seguente annuncio originale venne spedito alla newsgroup comp.os.minix:

From: [email protected] (Linus Benedict Torvalds)Newsgroups: comp.os.minixSubject: What would you like to see most in minix?Summary: small poll for my new operating systemMessage-ID: <[email protected]>Date: 25 Aug 91 20:57:08 GMTOrganization: University of HelsinkiHello everybody out there using minix -I'm doing a (free) operating system (just a hobby, won't be big and

7/108

mailto:[email protected]



professional like gnu) for 386(486) AT clones. This has been brewing since april, and is starting to get ready.I'd like any feedback on things people like/dislike in minix, as my OS resembles it somewhat (same physical layout of the file-system (due to practical reasons) among other things).I've currenctly ported bash(1.08) and gcc(1.40), and things seem to work. This implies that I'll get something practical within a few months, and I'd like to know what features most people would want. Any suggestions are welcome, but I won't promise I'll implement them :-)Linus ([email protected])PS. Yes – it's free of any minix code, and it has a multithreaded fs. It is NOT portable (uses 386 task switching etc), and it probably never will support anything other than AT-harddisks, as that's all I have :-(.

Linus lavorava con Minix, un altro piccolo sistema operativo UNIX libero. Linux è partito come progetto scolastico per creare una versione di UNIX che potessere essere utilizzato su sistemi basati su hardware IBM. Mentre Linux ha creato il kernel ed è tuttora attivo nello sviluppo di esso, i tool di supporto, i compilatori, le utilities ed i programmi vennero sviluppati da altre persone che aderirono al progetto GNU. Si parla spesso anche di GNU/Linux proprio per questo motivo.

The GNU General Public License

Linux viene rilascito con la GNU General Public License (Licenza pubblica generale), oppure GPL. Questa licenza è molto differente dalle solite licenze commerciali che si conoscono.

Una copia completa della licenza GNU si trova al link http://www.gnu.org/copyleft/gpl.html. Linux si orienta al movimento del software libero, che esisteva molto prima dell'inizio di Linux. Il progetto GNU è stato fatto partire per aiutare lo sviluppo del software come beneficio della communità, per il quali il software venne utilizzato principalmente. Partendo da questo oggetto si arrivò alla GPL, che è la licenza con la quale viene distribuito il software Linux ancora oggi.

La GPL è stata realizzata per mantenere libero il software libero. La Free Software Foundation (Fondazione per il Software Libero) è un'organizzazione che aiuta a promuovere ed a distribuire il software libero. Utilizzando un metodo conosciuto come copyleft, la Free Software Foundation e i autori utilizzano il copyright come una difesa contro coloro che prendono il codice scritto da altri per utilizzarlo all'interno di propri prodotti proprietari. Il copyleft infatti stabilisce che nessuno può mettere delle nuove restrizioni su software coperto da GPL se modificato o redistribuito.La GPL stabilisce inoltre che insieme al software venga fornito anche il codice sorgente per avere la possibilità di modificarlo in base alle proprie

8/108

http://www.gnu.org/copyleft/gpl.html



esigenze o ai propri desideri. Questo non vuol dire che il software viene distribuito gratuitamente, ma solo che va consegnato anche il codice sorgente. Se un software coperto dalla licenza GPL viene modificato e poi ridistribuito, l'autore è costretto a rilasciare anche il codice modificato.

Le distribuzioni di Linux

Una distribuzione Linux è un pacchetto che contiene il kernel, delle GNU utilities ed applicazioni, e spesso anche un programma di installazione. Le distribuzioni, come Debian, Ubuntu, Red Hat, Mandrake, SuSE, Slackware, Caldera, ecc., si differenziano dal software incluso, il programma di installazione e dai tool legati alla distribuzione stessa.

La distribuzione sulla quale si basa il contenuto di questo fascicolo è la distribuzione Debian, della quale Ubuntu è derivato. I mantainer della distribuzione Debian sono pienamente convinti dell'idea del software libero, mentre per la distribuzione Ubuntu questo concetto è andato un po' perso. Per questo motivo Debian fornisce una distribuzione completamente libera che non contiene assolutamente software non-libero, mentre in Ubuntu possiamo trovare anche software proprietari (ad esempio i driver grafici).

9/108


INTRODUZIONE AL SISTEMA

Lavorare con i dischi rigidi

Per poter utilizzare un disco rigido sotto Linux, come in tutti gli altri sistemi operativi, il disco deve contenere almeno una partizione. Una partizione è una parte del disco (o il disco intero) formattato in maniera tale da poter contenere dei dati. Ogni disco deve avere una partizione primaria. Prima di poter utilizzare le partizioni bisogna formattarle.

Una partizione primaria (solamente una) può essere suddivisa in partizioni estese, meglio conosciute come dischi logici. Utilizzando partizioni di stile DOS, da una partizione primaria si possono creare fino a quattro disci logici, ma nessuna di queste può essere vista come bootabile dal sistema operativo.

(...)mettere SATA al posto di scsi

Il limite teorico è di 15 partizioni su dischi SCSI (Small Computer System Interface) e di 63 partizioni su dischi IDE (Integrated Drive Electronics). Questi limiti vengono dati dalla tabelle delle partizioni di stile DOS.

Tutte le partizioni vengono riferenziate all'interno della cartella di sistema /dev. La prima partizione del primo disco per ogni tipo di disco è la seguente:• hda1 – per IDE• sda1 – per SCSI

10/108


Il nome è composto da quattro parti:• Il tipo di disco – h per IDE e s per SCSI• Il tipo di unità – d per disco (disk)• Il numero del disco espresso in formato alfabetico – a per il primo

(primary master su IDE), b per il secondo (primary slave su IDE), e così via

• Il numero della partizione – I numeri da 1 a 4 identificano le partizioni primarie, mentre i dischi logici partono dal 5 in su

Il disco dovrebbe avere sempre un minimo di due partizioni: il filesystem stesso (spesso chiamo semplicemente root) e una partizione swap. La swap contiene la memoria su disco rigido. La partizione swap è di solito grande quanto una parte della memoria installata nel nostro computer. Una partizione swap più grande della memoria installata viene chiamata anche memoria virutale.

Struttura base delle cartelle di Linux

Le cartelle di un sistema Linux sono organizzate ad albero. La cartella /, conosciuta come cartella root, contiene diverse cartelle di sistema. Ogni cartella può a sua volta contenere altre cartelle come i rami di un albero che si estendono verso l'esterno a partire dal tronco.Segue una lista di considerazioni importanti su directory e partizioni:

• La partizione root / deve sempre contenere fisicamente /etc, /bin, /sbin, /lib e /dev, altrimenti non sarete in grado di avviare il sistema.

• /etc – contiene gran parte degli script e dei file di configurazione utilizzati dal sistema.

• /etc/skel – contiene i file da copiare all'interno delle cartelle create per i nuovi utenti.

• /bin – contiene software relativo al sistema operativo utilizzato dagli utenti.

• /sbin – contiene software relativo al sistema operativo utilizzato dall'amministratore.

• /dev – contiene i riferimenti alle periferiche di Linux gestite come singoli file.

• /lib – contiene le librerie utilizzate all'interno del sistema.

• /root – homedirectory dell'amministratore.

• /tmp – se un programma crea dati temporanei, molto probabilmente li metterà in /tmp. Attenzione, perché questa directory viene cancellata da Debian automaticamente.

• /var – tutti i dati variabili, come le news, le email, i siti web, la cache di

11/108


APT ecc. verranno posti in questa directory. La sua dimensione dipende molto dell'uso dell'elaboratore, ma nella maggior parte dei casi il fattore da tenere in considerazione sarà il carico di lavoro del programma di gestione dei pacchetti.

• /boot – contiene tutti i file che servono all'avvio del sistema ad esempio i file immagine, i file di configurazione del bootlog ecc.

• /home – i singoli utenti metteranno i propri dati in una sottodirectory di questa directory. La dimensione da assegnarle dipende quindi da quanti utenti utilizzeranno il sistema e da quanti file verranno memorizzati nelle loro directory personali.

• /usr – in questa directory risiedono tutti i programmi utente (/usr/bin) e le relative librerie (/usr/lib), documentazione (/usr/share/doc), ecc. Questa parte del file system ha bisogno della maggior parte dello spazio necessario.

• /proc – contiene i file creati dagli stessi processi lanciati dal sistema.

• /media – in questa directory vengono create delle cartelle temporanee nel momento in cui aggiungiamo un dispositivo al computer (es. chiavetta usb).

• /mnt – questa directory è inizialmente vuota. Il sistema ce la mette a disposizione come punto di mount per dispositivi rimovibili non riconosciuti automaticamente dal sistema.

• /opt – in questa directory risiedono tutti i programmi optionali, ossia quelli che non hanno un punto di destinazione ben preciso all'interno del contesto di Linux.

12/108


NOZIONI BASE SU LINUX

Lavorare con i terminali

Il sistema ci mette a disposizione sette terminali che possiamo utilizzare per amministrare il nostro sistema. Per passare da un terminale all'altro premiamo ALT+CTRL e i tasti da F1 a F7 rispettivamente per i terminali da 1 a 7. I terminali da 1 a 6 sono terminali testuali, mentre il 7 è quello utilizzato per l'eventuale interfacciamento grafico.

Per poter lavorare in un terminale testuale ci viene richiesto il nome utente e la password. Ad autenticazione avvenuta ci troviamo all'interno del sistema e vediamo prima del cursore una riga con il seguente formato:

{nome utente}@{nome computer}:{attuale percorso}$

L'ultimo segno della riga (nel nostro caso il dollaro $) indica il tipo di utente che stiamo attualmente utilizzando. Il dollaro $ indica l'utilizzo di un utente normale, mentre il cancelletto # indica l'utente root (amministratore principale del sistema).

Per poter eseguire comandi da amministratore come utente normale bisogna iniziare ogni sequenza di comandi con il comando sudo. In questo caso il sistema chiedere le credenziali di amministratore e solo in questo caso si potrà procedere.

13/108


Autocompilazione dei nomi

Il terminale mette a disposizione la funzione di autocompilazione dei nomi di file o cartelle. La funzione si attiva inserendo le lettere iniziali del file o della cartella che ci interessa e premendo il tasto di tabulazione. Nel caso in cui premendo il tasto di tabulazione una volta non dovesse apparire nulla vorrebbe dire che ci sono più file o cartelle che iniziano con le stesse lettere inserite. Per vedere i file o le cartelle in questione possiamo premere due volte sul tasto di tabulazione.

Storico dei comandi

Il terminale tiene in memoria tutti i comandi utilizzati dall'utente. Questo può quindi scorrere all'interno dell'elenco dei comandi con il semplice utilizzo dei tasti cursore verso l'alto oppure verso il basso.

I caratteri “jolly” (wildcards) e gli intervalli

I caratteri chiamati “jolly” sono dei caratteri speciali che la shell riempirà in base al carattere utilizzato.

L'asterisco (*) viene utilizzato per identificare nessuno, uno o più altri caratteri messi in sequenza. Esempio:

ls p*p pi pip pippo pippo.gif

La shell infatti elenca sia il file p che tutti gli altri file che iniziano per p.

Se invece utilizziamo il punto di domanda (?) come carattere “jolly” la shell cercherà di rimpiazzare ogni punto di domanda con un carattere normale. Esempio utilizzano l'elenco visualizzato precedentemente:

ls p?pi

In questo caso la shell elenca solamente il file pi (p viene dato dall'utente, mentre i rimpiazza il carattere “jolly”).

Linux permette anche l'utilizzo di parentesi quadre ([]) per identificare i caratteri che possono trovarsi in una determinata posizione del nome di un file. Esempio:

ls [pt]*

14/108


Questo comando elenca tutti i file all'interno della directory di lavoro che iniziano con il carattere p oppure t con un qualsiasi numero di caratteri collegati in sequenza.Volendo elencare tutti i file che iniziano con una qualsiasi lettera minuscola dell'alfabeto il valore da inserire all'interno delle parentesi sarebbe [abcdefghijklmnopqrstuvwxyz]. Quest'ultimo inserimento si può semplificare notevolmente utilizzando degli intervalli.Linux ci permette di utilizzare degli intervalli ponendo fra due caratteri il meno (-). Per semplificare l'esempio appena citato basta scrivere:

ls [a-z]*

Se si vuole elencare i file che iniziano con un carattere che va da d a g si può scrivere [defg] oppure [d-g], per includere anche le lettere maiuscole si può scrivere [DEFGdefg] oppure [D-Gd-g].

Altri esempi sono:• Tutte le lettere (maiuscole e minuscole): [A-z]• Tutti i numeri: [0-9]• Tutte le lettere e tutti i numeri: [A-z0-9]• Non un numero: [!0-9]• Non una lettera: [!A-z]

15/108


MANAGEMENT DEI FILE

In questo capitolo vedremo diversi comandi utilizzati in linux per l'amministrazione dei file e delle directory.

Utilizzare i comandi cd e pwd (print work directory)Il comando cd viene utilizzato per modificare la directory nella quale si sta lavorando. Inserendo questo comando senza l'utilizzo di parametri vi sposterà all'interno della cartella dichiarata nella variabile HOME (una delle variabili di ambiente utilizzate in Linux). Un eventuale parametro inserito in combinazione con questo comando identifica invece la cartella di lavoro alla quale ci vogliamo spostare.

Alcuni caratteri di enorme importanza quando si utilizza questo comando sono il punto singolo (.) ed il punto doppio (..). Il primo identifica la directory nella quale ci si trova attualmente, il secondo invece identifica il livello superiore della medesima.

Il comando pwd visualizza l'attuale directory nella quale ci troviamo. Lo stesso valore lo ritroviamo all'interno della variabile di ambiente PWD.

In Linux spesso e volentiere si utilizza lo stesso nome per diversi elementi. Di regola si utilizzano elementi scritti in maiuscolo come variabili e non esecutibili; tutti gli elementi scritti in minuscolo sono file o

16/108


comandi e raramente identificano una variabile.

Di seguito vediamo alcuni esempio come poter utilizzare i comandi apena citati:

pwd/usr/binecho $HOME/home/ferrazzicdpwd/home/ferrazzi

Questa sequenza visualizza “/usr/bin” come directory di lavoro attuale mentre la variabile HOME equivale alla directory “/home/ferrazzi”. Inserendo cd senza parametri aggiuntivi il sistema si sposta all'interno della directory identificata dalla variabile HOME.

Nel seguente esempio invece la prima modifica è lo spostamento all'interno della directory di root (/):

pwd/home/ferrazzicd /pwd/cd /home/ferrazzipwd/home/ferrazzicd ..pwd/home

La seconda modifica ha fatto diventare “/home/ferrazzi” come directory di lavoro. Utilizzando il punto doppio (..) il sistema sposta la directory di lavoro al livello superiore, quindi “/home”.

I percorsi che vengono utilizzati come parametro possono essere relativi o assoluti. Si parla di percorso assoluto quando il percorso inizia con uno slash (/). Indipendentemente dalla directory di lavoro attuale il sistema inizia a scorrere il percorso dalla posizione di root (/). Nel esempio appena visto la directory “home” si deve trovare all'interno della directory root (/), mentre “ferrazzi” si trova all'interno di “home”.Percorsi che non iniziano con lo slash (/) vengono chiamati percorsi relativi, perchè si basano sulla directory di lavoro attuale. Trovandoci nella directory “/home” basterebbe utilizzare il comando cd ferrazzi per passare alla directory di lavoro “/home/ferrazzi”.

17/108


Utilizzare il comando lsL'abilità di visualizzare un elenco di file e directory è una delle più essenziali per un sistema operativo. Linux utilizza il comando ls.ls visualizza la lista dei file contenuti all'interno di una directory in forma tabellare e ordinata alfabeticamente. Esempio:

Desktop emmett filethree junk2 questionsTestPro errors filetwo mischief samplebrio example Friday myfile sample of the worlddulaney example2 garbage numbers simplesimoneRRors fileone junk1 pull snapshot01.gif

Come si può notare la lista è in ordine alfabetico cominciando dagli elementi che iniziano con una lettera maiuscola.

Uno dei parametri più utilizzati con questo comando è il parametro -F che indica il tipo di elemento elencato:

Desktop/ emmett filethree junk2 questionsTestPro errors filetwo mischief* samplebrio example Friday myfile sample of the worlddulaney example2 garbage numbers simplesimoneRRors fileone junk1 pull snapshot01.gif

Elementi senza carattere aggiuntivo identificano file normali. Gli elementi ai quali viene aggiunto il segno slash (/) sono delle directory, mentre l'asterisco (*) identifica un file eseguibile.

Un'altro parametro molto utilizzato è -a, che visualizza la lista di tutti file presenti all'interno di una directory, quindi anche quelli nascosti che per default non vengono elencato. I file nascosti sono tutti i file che iniziano con un punto (.).

. Desktop/ emmett filethree junk2

.. TestPro errors filetwo mischief*

.bash_history brio example Friday myfile

.bash_logout dulaney example2 garbage numbers

.fileone.swp eRRors fileone junk1 pull(l'ultima colonna dell'elenco non è stata scritta per motivi di spazio)

Un punto (.) può comparire all'interno del nome di un file quante volte vuole, ma se messo all'inizio del nome di un file identifica un file nascosto.Utilizzando -A al posto di -a evita di elencare gli elementi (.) e (..).

Il parametro sicuramente più utilizzato con questo comando è -l, che visualizza un elenco dettagliato dei file presenti all'interno di una directory. Esempio:

18/108


drwx------ 5 root root 1024 Aug 30 11:12 Desktop-rw-r--r-- 1 root root 548 Aug 23 22:01 TestPro-rw-r--r-- 1 root root 28 Aug 22 10:26 brioecc.

Le singole colonne hanno il seguente contenuto:• I permessi del file. I permessi vengono descritti più avanti, ma per

adesso può essere interessante sapere che il primo carattere identifica il tipo di elemento: - indica un file, mentre una d identifica una directory. Altri caratteri utilizzati sono c come file speciale (ad esempio un terminale), b per un'unità a blocchi (ad esempio un'unità a nastro) o l per un link simbolico.

• Il numero dei link. Se l'elemento è una directory questo numero identifica il numero dei file all'interno di essa. Se l'elemento è un file questo numero identifica il numero delle vie con le quali si può accedere a questo file (ad esempio il numero di link simbolici su di esso).

• Il nome dell'utente che ha creato l'elemento o ne è il proprietario.• Il nome del gruppo al quale appartiene questo file.• La dimensione del file.• La data di creazione o modifica del file.• Il nome del file.

Di seguito viene visualizzata una tabella che contiene tutte le opzioni che si possono utilizzare con il comando ls.

Parametri per il comando lsParametri Descrizione

-c-d-G-i-n

-o-r-R

-S-u-w-x-X

Elenca in ordine di modifica infece che alfabeticamenteElenca solamente le directorySe utilizzato con -l non visualizza i gruppiVisualizza gli inode (pointer) di ogni elementoVisualizza l'identificativo numerico dell'utente e del gruppo invece del nomeUguale a -lGInverte l'ordine di visualizzazioneVisualizza recursivamente anche il contenuto delle directory presentiOrdinaOrdina in base all'ultima ora di accesso dell'elementoSpecifica la larghezza dello schermoVisualizza linee al posto di colonneAlfabeticamente in base all'estensione del file

19/108


Utilizzare il comando touchIl comando touch permette di modificare l'ora e la data di modificazione del file. Esempio:

ls -l brio-rw-r--r-- 1 root root 28 Aug 22 10:26 briotouch briols -l brio-rw-r--r-- 1 root root 28 Aug 30 16:01 brio

I parametri che si possono utilizzare con questo comando sono elencati nella seguente tabella.

Parametri per il comando touchParametri Descrizione

-a-m-r

Modifica solamente la data e l'ora di accessoCambia solamente la data e l'ora dell'ultiima modificaUtilizza la data e l'ora di un'altro file al posto della data e dell'ora attuale

Un altro esempio utilizzando l'ultimo parametro elencato nella tabella:

ls -l tuesday wednesday-rw-r--r-- 1 root root 28 Aug 22 10:26 tuesday-rw-r--r-- 1 root root 28 Aug 29 13:08 wednesdaytouch tuesday -r wednesdayls -l tuesday wednesday-rw-r--r-- 1 root root 28 Aug 29 13:08 tuesday-rw-r--r-- 1 root root 28 Aug 29 13:08 wednesday

Utilizzando questo comando con il nome di un file che non esiste ha come conseguenza la creazione del file con la data e l'ora attuale e con una dimensione pari a zero.

Utilizzare il comando cpIl comando cp può essere utilizzato sia con i file che con le directory per creare delle copie di file o directory esistenti. Con questo comando va prima specificato il file sorgente e poi il nome da utilizzare come file di destinazione.

ls -l pippo plutols: pippo: No such file or directory-rw-r--r-- 1 root root 85 Aug 22 10:26 pluto

20/108


cp pluto pippols -l pippo pluto-rw-r--r-- 1 root root 85 Aug 22 10:26 pluto-rw-r--r-- 1 ferrazzi users 85 Aug 30 16:18 pippo

Il nuovo file creato ha come utente e gruppo il nome dell'utente e del gruppo che ha eseguito la copia e come data e ora la data e l'ora di quando il comando è stato eseguito.Per poter effettuare la copia di un file l'utente ha bisogno dei diritti di lettura sul file sorgente.

Possiamo utilizzare il parametro -p per cercare di mantenere invariato il numero più alto di caratteristiche del file copiato. Esempio:

ls -l pippo topolinols: topolino: No such file or directory-rw-r--r-- 1 root root 85 Aug 22 10:26 pippo

cp pippo topolinols -l pippo topolino-rw-r--r-- 1 root root 85 Aug 22 10:26 pippo-rw-r--r-- 1 ferrazzi users 85 Aug 22 10:26 topolino

Ora, infatti, anche la data e l'ora è la stessa del file sorgente.

Si può utilizzare il comando -i (per interattività) per chiedere comunque conferma all'utente in caso il file di destinazione esista. Esempio:

ls -l pippo1 pippo2-rw-r--r-- 1 root root 85 Aug 22 10:26 pippo1-rw-r--r-- 1 root root 16432 Aug 28 13:43 pippo2

cp -i pippo1 pippo2cp: overwrite 'pippo2'?

Si possono anche copiare più file da una directory ad un'altra. L'ultimo nome elencato nella riga di comando deve essere però il nome di una directory valida. Esempio:

ls -l /home/ferrazzi-rw-r--r-- 1 root root 85 Aug 22 10:26 pippo1

cd /home/examplesls -l p* t*-rw-r--r-- 1 root root 585 Aug 23 12:16 pippo2-rw-r--r-- 1 root root 1985 Aug 24 15:17 pippo3-rw-r--r-- 1 root root 8501 Aug 25 18:30 topolinocp s* q* /home/ferrazzicd ../ferrazzils -l-rw-r--r-- 1 root root 85 Aug 22 10:26 pippo1-rw-r--r-- 1 root root 585 Aug 23 12:16 pippo2

21/108


-rw-r--r-- 1 root root 1985 Aug 24 15:17 pippo3-rw-r--r-- 1 root root 8501 Aug 25 18:30 topolino

Altri parametri che si posson utilizzare sono elencati nella seguente tabella.

Parametri per il comando cpParametri Descrizione

-r o -R

-f-u

-v-P

Permette di copiare il tutto il contenuto di una directory (file e sottodirectory comprese)Per forzare la copia (contrario di -i)Copia solamente se il file sorgente è più recente del file di destinazioneVisualizza i singoli passaggi sullo schermoRiproduce lo stesso percorso in un file in un'altra posizione

Utilizzare il comando mvIl comando mv può essere utilizzato per varie operazioni. Queste operazioni sono:

• Rinominare un file• Rinominare una directory• Spostare un file da una directory ad un'altra• Spostare una sottodirectory da una directory ad un'altra• Spostare un'intera entità ad un'altra partizione o unità

Il modo più semplice di utilizzare questo comando è quello di rinominare un file all'interno della directory di lavoro:

ls -l pi*-rw-r--r-- 1 root root 85 Aug 01 12:30 pippo1-rw-r--r-- 1 root root 185 Aug 10 13:30 pippo2

mv pippo1 pippo3ls -l pi*-rw-r--r-- 1 root root 85 Aug 01 12:30 pippo3-rw-r--r-- 1 root root 185 Aug 10 13:30 pippo2

Tutte le caratteristiche del file rimangono invariate tranne il nome del file stesso.Se con il comando mv si cerca di rinominare un file in un nome di file già esistente i dati relativi a quest'ultimo andranno persi.

22/108



mv pippo1 pippo2ls -l pi*-rw-r--r-- 1 root root 85 Aug 01 12:30 pippo2

I parametri che possiamo utilizzare con questo comando sono elencati nella tabella seguente.

Parametri per il comando mvParametri Descrizione

-f

-u

-v-b

Per forzare lo spostamento o la rinomina di un file o di una directory (contrario di -i)Sposta o rinomina solamente se il file sorgente è più recente del file di destinazioneVisualizza i singoli passaggi sullo schermoIn caso il file di destinazione esista viene creato un backup di esso aggiungendo un tilde (~) al nome del file

Esempio:


mv -b pippo1 pippo2ls -l pi*-rw-r--r-- 1 root root 85 Aug 01 12:30 pippo2-rw-r--r-- 1 root root 185 Aug 10 13:30 pippo2~

Rimuovere file o directory con i comandi rm e rmdirI file che non vengono più utilizzati all'interno del nostro sistema si possono rimuovere utilizzando il comando rm (remove). Una volta eliminato un file non ci sarà più la possibilità di ripristinarlo come in altri sistemi operativi. Esempio:

ls -l pi*-rw-r--r-- 1 root root 85 Aug 01 12:30 pippo1-rw-r--r-- 1 root root 185 Aug 10 13:30 pippo2rm pippo1ls -l pi*-rw-r--r-- 1 root root 185 Aug 10 13:30 pippo2

23/108


Utilizzando il parametro -i il sistema chiede la conferma per la cancellazione di un file prima di eseguire il comando. Esempio:

ls -l pi*-rw-r--r-- 1 root root 85 Aug 01 12:30 pippo1-rw-r--r-- 1 root root 185 Aug 10 13:30 pippo2rm -i pippo1rm: remove 'pippo1'?

Nella seguente tabella vediamo altri parametri che si possono utilizzare con questo comando.

Parametri per il comando rmParametri Descrizione

-i-f-v-r o -R

Richiesta di conferma prima di eliminare un fileForza l'eliminazione di un fileVisualizza i singoli passaggi sullo schermoElimina una directory ed il contenuto (sottodirectory e contenuti compresi)

Per poter eliminare un file l'utente deve avere il permesso di scrittura sulla cartella all'interno della quale si trova il file da eliminare e non sul file stesso.

Un comando molto più sicuro è rmdir, perchè permette di eliminare solamente directory vuote. L'unico parametro utilizzabile con questo comando è -p che permette di cancellare anche le cartelle di un livello superiore se queste sono vuote.

ls -R ferrazziferrazzi:esempi

ferrazzi/esempi:pippo1

cd ferrazzirmdir ferrazzirmdir: ferrazzi: Directory not empty

Per poter cancellare la directory esempi si può procedere come segue:

cd esempirm pippo1rmdir -p

24/108


Creare delle directory con il comando mkdirIl comando mkdir viene utilizzato per creare delle directory. I parametri che si possono utilizzare con questo comando si trovano nella tabella seguente.

Parametri per il comando mkdirParametri Descrizione

-m-p

Permette di specifare diritti diversi da quelli di defaultCrea una directory con sottodirectory con un comando

Di seguito alcuni esempi:

pwd/homemkdir ferrazzi

Questo esempio crea la directory ferrazzi all'interno di /home.

pwd/homemkdir ferrazzi/esempimkdir: cannot make directory 'ferrazzi/esempi': No such file or directorymkdir -p ferrazzi/esempicd ferrazzicd esempi

Creare link su files

Quando si lavora con files può essere necessario avere lo stesso file in due posti diversi. Questo può essere utile per molti motivi. Si possono avere diversi permessi in base alla locazione attuale del file, oppure si vuole spostare un file da una parte all'altre senza interrompere l'eventuale esecuzione di un altro utente. Un programma potrebbe cercare un file all'interno di una directory non troppo conveniente dal punto di vista della sicurezza. Un link permette di rendere disponibile un file da directory diverse. Esistono due tipo di links: hard links e soft links.

Un hard link mantiene gli stessi permessi e tempi di accesso del file originale. In effetti entrambi hanno la stessa inode. Un hard link può

25/108


essere semplicemente visualizzato con un altro nome e/o un'altra locazione. La modifica del hard link o del file originale comporta automaticamente la modifica dell'altro. Se esaminato un hard link viene rappresentato come file normale.

Gli hard link hanno però delle limitazioni. Un utente normale non ha il permesso di creare degli hard link su delle directory. Per creare un hard link viene utilizzato il comando ln. Il prossimo esempio mostra come creare un hard link con il nome doc2 su /home/ferrazzi/doc:

ln doc2 /home/ferrazzi/docls -al-rw-r--r-- 2 root root 89002 Aug 10 2002 doc-rw-r--r-- 2 root root 89002 Aug 10 2002 doc2

Come si può notare dall'esempio questi file hanno la stessa dimensione. Il numero 2 dopo i permessi identificano i due hard link presenti per questo file.

L'altro tipo di link è il symbolic oppure soft link. Questo link permette un grado più alto di flessibilità. Gli utenti possono creare link simbolici anche sulle directory. Questo tipo di link può essere addirittura creato su file che non esistono. Il link simbolico ha una propria gestione dei permessi indipendentemente da quelli del file originale. Cancellando il file originale non ha come conseguenza la cancellazione del file simbolico, ma solamente l'eliminazione del file stesso. Dopo la cancellazione il link simbolico non è più funzionante.

Per creare un link simbolico si utilizza nuovamente il comando ln utilizzando però il parametro -s. Utilizziamo i dati dell'ultimo esempio per creare un link simbolico:

ln -s doc2 /home/ferrazzi/doc

I link simbolici sono identificabili mostrando in dettaglio il contenuto di una directory come mostrato nel prossimo esempio:

ls -allrwxrwxrwx 1 ferrazzi ferrazzi 7 Mar 10 17:06 doc2 -> /home/ferrazzi/doc

E' molto importante capire che aprire, leggere o scrivere su un link simbolico è come farlo direttamente sul file originale. Rimuovere il link significa rimuovere solamente il link, ma non il file originale. Quando viene copiato un link simbolico è il file originale che finisce all'interno della directory di destinazione. Questa diventerebbe una copia indipendente dal file originale e una modifica di questo non comporterebbe la modifica del file originale.

26/108


COMANDI BASE PER OPERARE SU FILE DI TESTO

In questo capitolo verranno descritte alcune delle utility più comuni per la processione di testi. Due dei concetti base che vanno affrontati prima di spiegare i vari comandi sono il ridirezionamento e le pipes.

Il ridirezionamento

Linux lavora principalmente con tre flussi di dati standard: lo standard input, lo standard output e lo standard error. I dati che arrivano ad un determinato programma o alla shell (che sia utilizzando la tastiera o l'output di un altro comando) Linux lo interpreta come standard input anche noto come stdin. Lo stdin viene ridirezionato utilizzando il simbolo (<). Molte utility che vedremo in seguito utilizzano le informazioni che passano attraverso lo stdin o derivano da un file, ma si possono mandare dei dati a queste utility utilizzando anche il sistema di ridirezionamento.Uno dei comandi che utilizza questo sistema è il comando sort che permette di ordinare una lista di dati. Per ordinare il contenuto del file “nomi” possiamo scrivere:

sort < nomi

27/108


In questo caso il risultato viene visualizzato su schermo.I dati che vengono mandati sullo schermo Linux li interpreta come standard output, oppure anche stdout. Anche in questo caso abbiamo la possibilità di effettuare il ridirezionamento utilizzando il simbolo (>). Per scrivere il risultato del comando sort all'interno di un altro file basterebbe quindi utilizzare il seguente comando:

sort nomi > ordinati

In questo caso l'eventuale contenuto del file “ordinati” va perso. Abbiamo però anche la possibilità di utilizzare il ridirezionamento “append” ossia utilizzando il simbolo (>>). In questo modo il contenuto di “ordinati” non andrà perso. Il nuovo risultato verrà aggiunto (append) al contenuto attuale.

sort nomi >> ordinati

Tutti gli errori che vengono generati dai comandi in esecuzione vengono spediti allo standard error, un canale che viene utilizzato solamente per la visualizzazione degli errori (stderr). Anche questi dati possono essere ridirezionati utilizzando il seguente sistema:

sort nomi 2> listaerrori

Gli eventuali errori verranno ora scritti all'interno del file “listaerrori”.

Utilizzando “Pipes”

In certi casi diventa indispensabile poter utilizzare lo standard output di un comando con un altro comando. In questo caso possiamo utilizzare il simbolo (|).

sort nomi | nl

Questo esempio ordina il contenuto del file “nomi” (sort) e poi manda il risultato allo standard input del comando nl (che numera le righe). Lo standard output di nl viene visualizzato sullo schermo.

L'irrepressibile catL'utility più semplice per la processione di testi è sicuramente cat, che visualizza su schermo il contenuto di un file di testo.

Per gli esempi che seguiranno verrà utilizzato un file dal nome “esempio” con il seguente contenuto:

28/108


Questa è la prima rigaQuesta è la seconda rigaQuesta è la terza rigaQuesta è la quarta riga

I parametri che si possono utilizzare in combinazione a questo comando sono visualizzate nella seguente tabella.

Parametri per il comando catParametri Descrizione

-b-E

-T-v

-A

Aggiunge i numeri delle righeVisualizza il simbolo del dollaro ($) alla fine di ogni rigaVisualizza tutti i tab come ^IVisualizza i caratteri non stampabili tranne tab e nuova rigaStesso risultato di -v combinato con -E e -T

Per visualizzare il contenuto del file basta scrivere:

cat esempioQuesta è la prima rigaQuesta è la seconda rigaQuesta è la terza rigaQuesta è la quarta riga

Per visualizzare il contenuto del file con il numero delle righe bisogna scrivere:

cat -b esempio 1 Questa è la prima riga 2 Questa è la seconda riga 3 Questa è la terza riga 4 Questa è la quarta riga

Uno degli usi più comuni di cat è quello per la creazione di file di testo in maniera molto rapida. Per creare ad esempio il nuovo file di testo “esempio” basta scrivere:

cat > esempioQuesto è il nuovo contenuto del file 'esempio'.Anche qui abbiamo una seconda riga.{premere Ctrl+D}

Dopo aver inserito la riga di comando possiamo iniziare a scrivere un testo a piacere. Dopo aver terminato il testo premiamo i tasti Ctrl+D per

29/108


terminare l'inserimento.Riutilizzando il comando cat in maniera normale possiamo andare a verificare il contenuto del nuovo file.

Utilizzando il “>” un eventuale file già esistente verrebbe sovrascritto, il “>>” invece equivale ad una continuazione di scrittura.

In combinazione al comando cat troviamo il comando tac che permette di visualizzare il contenuto di un file di testo all'incontrario, ossia iniziando dall'ultima riga per arrivare alla prima.

tac esempioAnche qui abbiamo una seconda riga.Questo è il nuovo contenuto del file 'esempio'.

Visualizzare una parte o tutto il file con nl, head e tailIl comando nl viene utilizzato per numerare le righe di un file di testo, praticamente è simile al comando cat -b. I parametri utilizzabili con questo comando sono elencati nella seguente tabella.

Parametri per il comando nlParametri Descrizione

-i-v-n

-nln-nrn-nrz

-s

Cambia il passo di incrementazione (default è 1)Cambia il numero iniziale (default è 1)Cambia l'allineamento della visualizzazioneAllineamento a sinistraAllineamento a destraUtilizza zeri inizialiUtilizza un carattere specifico tra numero e riga (default è spazio)

Il comando head invece permette di visualizzare un determinato numero di righe partendo dalla prima utilizzando il meno (-) seguito dal numero di righe che si voglio visualizzare. Se viene utilizzato senza parametro viene visualizzato l'intero contenuto del file di testo. Esempio:

head numeriunoduetrequattrocinque

head -2 numeriuno

30/108


due

Il comando tail ha una serie di modalità. Principalmente questo comando è l'opposto di head, ossia utilizza le ultime righe di un file di testo. Se utilizziamo questo comando senza parametri vengono visualizzate le ultime 10 righe del file di testo. Esempio:

head numeriunoduetrequattrocinqueseisetteottonovedieciundicidodicitrediciquattordiciquindici

tail numeriseisetteottonovedieciundicidodicitrediciquattordiciquindici

tail -3 numeritrediciquattordiciquindici

Le potenzialità di tail però non si limitano a questo. Utilizzando come parametro un più (+) seguito da un numero il sistema inizierà la visualizzazione a partire dalla riga specificata arrivando fino alla fine del file di testo. Esempio:

tail +10 numeridieciundicidodicitredici

31/108


quattordiciquindici

Un parametro molto utile da utilizzare con questo comando è -f. In questo modo tail visualizzera le ultime 10 righe di un file di testo, ma poi continua a leggere il file. Questo vuol dire che le modifiche apportate al file di testo vengono visualizzate direttamente anche sullo schermo.Per interrompere tail nella lettura del file bisogna premere i tasti di interruzione che per default sono Ctrl+c.

I comandi cut e paste

Il comando cut ha l'abilità di separare colonne all'interno di un file di testo che di default vengono separate dal tab. Il parametro -f permette di scegliere la colonna da elencare. Prendiamo ad esempio in considerazione il file nomi che contiene i seguenti dati:

ID UTENTE LAVORO1 Marco Operaio2 Giorgio Operaio3 Franca Segretaria

Per visualizzare solamente la seconda colonna bisogna utilizzare il seguente comando:

cut -f2 nomiUTENTEMarcoGiorgioFranca

Il seguente comando invece restituisce il risultato contrario:

cut -f1,3 nomiID LAVORO1 Operaio2 Operaio3 Segretaria

Altri parametri che si possono utilizzare con questo comando sono visualizzati nella seguente tabella.

Parametri per il comando cutParametri Descrizione

-c-d

Permette di specificare caratteri al posto di colonnePermette di specificare il carattere separatore

32/108


Per vedere come funzionano gli altri parametri possiamo utilizzare il comando ls. ls -l infatti visualizza i permessi, il numero dei link, il proprietario, il gruppo proprietario, la dimensione, la data ed il nome del file. Tutti questi campi sono separati da spazi con due caratteri tra i permessi ed il numero dei link. Se si vuole vedere solamente chi salva dei file all'interno della directory senza visualizzare il resto dei dati possiamo inserire il seguente comando:

ls -l | cut -d” “ -f5

L'esempio ignora i permessi (prima colonna), i due spazi (seconda e terza colonna) ed il numero dei link (quarta colonna) visualizzando solamente la quinta colonna, ossia la colonna dei proprietari.

Il seguente esempio visualizza solamente il sedicesimo carattere, ossia la prima lettera del nome del proprietario:

ls -l | cut -c16

Un intervallo di caratteri si specifica come segue:

ls -l | cut -c16-24

Per iniziare la visualizzazione del file a partire da un determinato numero di carattere bisogna invece scrivere:

ls -l | cut -c55-

Il comando paste permette di concatenare due file di testo. Questo comando prende una riga del file sorgente di testo e lo concatena alla medesima riga del file di testo di destinazione. Se ad esempio abbiamo i due file di testo pippo1 e pippo2 che hanno rispettavamente i seguenti dati:

topolinopaperinoCip

e

topolinapaperinaCiop

Per concatenare i due file di testo possiamo utilizzare il seguente comando:

33/108


paste pippo1 e pippo2topolino topolinapaperino paperinaCip Ciop

Il carattere di default utilizzato per separare le due colonne è il tab. Per modificare questo carattere possiamo utilizzare il parametro -d.

paste -d”,” pippo1 pippo2topolino,topolinapaperino,paperinaCip,Ciop

Utilizzando invece il parametro -s il comando elenca su una riga prima i dati contenuti nel primo file di testo e nella seconda quelli contenuti nel secondo.

paste -s pippo1 pippo2topolino paperino Ciptopolina paperina Ciop

Ordinare, contare, formattare e trasformare file di testo

Il comando che viene utilizzato per ordinare un file è sort. Pensiamo ad esempio di avere il seguente file di testo 'pippo':

cat pippoPaperinoMinniPluto789101112

Dopo aver eseguito il comando sort il risultato sarà il seguente:

sort pippo101112789MinniPaperino

34/108


Pluto

I parametri che si possono utilizzare con questo comando sono visualizzati nella seguente tabella.

Parametri per il comando sortParametri Descrizione

-b-d-f

-i-g-r

Evita di ordinare righe vuoteManiera classico (come nel precedente esempio)Non viene fatta differenza tra lettere maiuscole e minuscoleIgnora i caratteri al di fuori dai codici ASCIIPer ordine numerico al posto di alfabeticoInverte l'ordine di visualizzazione

Esempio:

sort -n pippoMinniPaperinoPluto789101112

In caso di righe vuote queste vengono posizionate all'inizio della lista visualizzata. Per evitare di prendere in considerazione le righe vuote si può utilizzare il parametro -b.

Il comando wc sta per “word count” (in italiano “conta parole”) e visualizza il numero delle righe, le parole e il numero dei carratteri di un file di testo. Esempio:

wc pippo9 9 27 pippo

Anche questo comando ha a disposizione alcuni parametri che permettono di visualizzare solamente alcuni dei dati elencati. L'unico dato che viene visualizzato sempre è il nome del file.

Parametri per il comando wcParametri Descrizione

35/108


-c-l-w

Solo il numero dei byte o dei caratteriSolo il numero delle righeSolo il numero delle parole

Esempio:

wc -c pippo27 pippo

Una delle possibilità di evitare la visualizzazione del nome del file è quello di utilizzare il ridirezionamento dello standard input come segue:

wc -c pippo27

Il comando fmt formatta il testo in modo tale da ottenere una visualizzazione con una larghezza ben precisa. Di default questa larghezza è pari a 75 caratteri, ma il parametro -w ci permette di adattare questo valore alle nostre esigenze. Righe più corte vengono combinate assieme per crearne di più lunghe a meno che non venga utilizzato il parametro -s. Lo spazio invece viene giustificato se non viene utilizzato il parametro -u. L'ultimo parametro garantisce l'uniformità e piazza uno spazio tra due parole e due spazi alla fine di ogni frase.

Vediamo il prossimo esempio:

fmt -40 mydocLinux offers a variety of tools touser for processing and filtering text.These tools enable you to search fordata and then manipulate it dependingon the tool you use. The tools can beused from the command line or placed inscripts, which are executed to performthe needed tasks. The output is theneither sent to standard output, whereit can be redirected or piped into

Il comando che viene utilizzato per convertire parti di un file di testo è tr (translate – in italiano “tradurre”). Questo comando funziona utilizzando le possibili definizioni di intervalli che abbiamo già conosciuto nel capitolo 'I caratteri “jolly” (wildcards) e gli intervalli' ed il ridirezionamento dello standard input. Vediamo il seguente esempio per capire meglio il funzionamento:

36/108


tr '[a-z]' '[A-Z]' < pippoMINNIPAPERINOPLUTO

Dall'esempio vediamo che il comando cerca di convertire le lettere minuscole in maiuscole. La particolarità di questo comando è che non si può fornire il nome del file direttamente come parametro ma bensì utilizzando il ridirezionamento.Con questo comando non si possono solamente utilizzare gli intervalli come appena visto, ma anche un numero di valori predefiniti come:

• lower – tutti i caratteri minuscoli• upper – tutti i caratteri maiuscoli• print – tutti i caratteri stampabili• punct – tutti i caratteri di punteggiatura• space – tutti gli spazi• alnum – tutti i caratteri alfanumerici• digit – solo numeri• cntrl – caratteri di controllo• alpha – solo lettere• graph – tutti i carratteri stampabili tranne gli spazi

Esempio:

tr '[:lower:]' '[:upper:]' < pippoMINNIPAPERINOPLUTO

37/108


EFFETTUARE RICERCHE IN FILE DI TESTO

In questo capitolo verranno citate le nozioni base delle “regular expression” e l'utilizzo dei comandi grep e sed per la ricerca all'interno di file di testo.

La familia dei comandi grep e le “regular expression”

La familia dei comandi grep è composta da grep ed egrep dove grep viene visto come acronimo di: Globally look for Regular Expressions and then Print the results (Ricerca globale di regular expressions e poi stampa il risultato). Questi comandi infatti filtrano parti di file di testo in base alle regular expressions date.

Le otto regole più importanti che identificano una regula expression sono le seguenti:

• Ogni carattere non speciale è uguale a se stesso.• Ogni carattere speciale è uguale a se stesso se preceduto dal back

slash (\).• Il simbolo (^) indica l'inizio di una righa, il dollare ($) la fine.• Le espressioni sono intervalli all'interno di parentesi quadre ([]).• Il simbolo (^) utilizzato all'interno di parentesi quadre viene utilizzato

38/108


come negazione.• Il punto (.) significa ogni carattere singolo.• L'asterisco (*) significa ogni sequenza di caratteri o nessun carattere.• Le virgolette (“) non vengono sempre utilizzate prima e dopo una

stringa di ricerca, ma in gran parte dei casi si, quindi conviene utilizzarli sempre.

La seguente tabella contiene degli esempi che possono essere utili a capire meglio l'utilizzo delle regular expressions.

Esempi per le regular expressions

Regola Caratteri Risultato

1c (ogni carattere senza funzione speciale)

Trova “c” all'interno della riga.

1 gatto Trova “gatto” all'interno della riga.

2$ Ogni riga che contiene il simbolo di INVIO

(ogni riga).

2\$ Ogni riga che contiene il simbolo del

dollaro.

3 ^c Ogni riga che inizia con il carattere “c”.

4[gatto] Ogni riga che contiene il carattere “g”, “a”,

“t”, o “o” (le parentesi identificano un area di ricerca).

4 [a-z] Ogni lettera minuscola.

4[:lower:] Ogni lettera minuscola. Altri possibili valori

sono [:alnum:], [:alpha:], [:digit:], e [:upper:].

5 [^a-z] Tutto tranne lettere minuscole.

5 [^0-9] Tutto tranne numeri.

6 c. Parole di due lettere che iniziano con “c”.

6c..$ Parole di tre lettere alla fine della riga che

iniziano con “c”.

7c* Ogni parole che inizia con “c” (anche solo

“c”)

8 “c*” Come sopra.

8 “c gatto” “c” seguito da uno spazio e poi “gatto”.

Per illustrare al meglio le capacità del comando grep prendiamo come esempio il file di testo “gatto” con il seguente contenuto:

39/108


Allora per catturare la mosca il gatto saltasull'armadio, perchè non riesce aprenderla stando perterra.

Per trovare tutte le righe che contengono la parola “per” basta scrivere come segue:

grep “per” gattoAllora per catturare la mosca il gatto saltasull'armadio, perchè non riesce aprenderla stando perterra.

Come risultato vengono visualizzate tutte le righe perchè tutte le righe contengono la sequenza di caratteri “per”, ossia “per”, “perchè” e “perterra”.

grep “per[^c]” gattoAllora per catturare la mosca il gatto saltaprenderla stando perterra.

In questo esempio la riga contenente la parola “perchè” non viene più visualizzata perchè non corrisponde alla regular expression, ossia: la seguenza dei caratteri “per” seguita da una qualsiasi lettera tranne la “c”.Il seguente esempio, invece ci permette di estrarre tutte le parole “per” seguite da uno spazio:

grep “per ” gattoAllora per catturare la mosca il gatto salta

Un'altra possibilità sarebbe quella di eliminare la sequenza di caratteri “per” seguita da una “c” e da una “t” per evitare di estrarre anche le parole “perchè” e “perterra”:

grep “per[^sn]” gattoAllora per catturare la mosca il gatto salta

Questo comando viene molto utilizzato a livello di amminstrazione di sistema. E' infatti molto semplice tenere sotto controllo i file di log eseguendo periodicamente questo comando andando alla ricerca di eventuali tentativi di login non andati a buon fine.

Le seguenti opzioni sono disponibili per questo comando.

40/108


Parametri per il comando grepParametri Descrizione

-c-f-H

-i-L

-n-q

-s-v-w

-x

Conta le righe che contengono la stringa.Utilizza un file per trovare le stringhe da cercare.Include il nome del file nel quale è stata trovata la stringa (-h è il parametro di default).Ignora minuscolo-maiuscolo.Estrae il nome dei file che non contengono la stringa cercata, -l invece estrae il nome dei file che contengono la stringa cercata.Visualizza anche il numero della riga estratta.Evita l'output e viene utilizzato di solito per effettuare dei test nelle condizioni.Evita la visualizzazione dei messaggi di errore.Viene utilizzato come negazione.Cerca la parola intera (nel caso di “per” non troverebbe i derivati, es. “perchè” e “perterra”).Vede la stringa di ricerca come un'intera riga.

Il più delle volte questo comando viene utilizzato assieme al sistema di pipe (|) che permette di inviare lo standard output ad un'altro comando. Se per esempio volessimo visualizzare solamente le directory (e quindi non i file) contenute all'interno della directory attuale di lavoro si potrebbe scrivere:

ls -l | grep “^d”

Qui bisogna fare particolare attenzione al fatto che non vengono utilizzate le parentesi quadre. Nel caso di utilizzo di parentesi quadre in fatti questo comando verrebbe interpretato come un negazione. Non avendo le parentesi il sistema riconosce il simbolo (^) come inizio riga. In questo caso verranno quindi estratte tutte le righe derivanti dal comando ls -l che iniziano con la lettera “d”.

Una versione un po' più aggiornata di grep e il comando egrep. E' possibile con questo comando effettuare delle ricerche multiple, ossia con più parole alla volta, utilizzando il simbolo pipe (|). Il prossimo esempio visualizza la possibilità di effettuare una ricerca con più nomi all'interno di un file che contiene il nome ed il cognome di più persone. Esempio:

cat nomiMarco RossiAndrea RossinGiacomo RossiniGiorgio Andreis

41/108


Valerio AndersenLuca PippoMassimo Andrei

egrep “Marco|Massimo” nomiMarco RossiMassimo Andrei

Come utilizzare il comando sed

Il nome sed è un acronimo di “stream editor” (in italiano editore di flusso) ed è proprio quello che fa questo comando. Questo comando infatti elabora un flusso di input (testo) in base ai parametri utilizzati. La sintassi di questa utilità è la seguente:

sed {parametri} {comandi} nome_del_file

Il numero dei parametri è limitato ma i comandi sono numeri. I parametri sono visualizzati nella seguente tabella.

Parametri per il comando grepParametri Descrizione

-e-f

-n

Specifica un comando da eseguire.Specifica un file nel quale trovare i comandi da eseguire.Viene eseguito in modalità silenziosa.

Il modo più semplice per comprendere il funzionamento di questo comando è quello di esaminare una serie di esempi. Il comando più semplice per sed, o per tutti gli editor, è quello di sostituire una serie di caratteri con un'altra serie di caratteri. Questo si ottiene utilizzando il comando s (per substitute – in italiano sostituisci), seguito da uno slash (/), la stringa da trovare, uno slash (/), la stringa che deve sostituire la serie di caratteri trovata ed in fine un'altro slash (/). L'intero comando viene scritto tra apici come segue:

's/stringa vecchia/stringa nuova/'Un esempio può essere:

echo Ho comprato una macchina blu | sed 's/blu/rossa/'Ho comprato una macchina rossa

Questo comando esamina riga dopo riga. Se all'interno di una riga non viene trovata la stringa il comando passa alla riga successiva. Se però

42/108


all'interno della riga viene trovata la stringa desiderata questa viene modificata e la ricerca parte dalla riga successiva. Questo comportamento potrebbe portare ad un risultato inaspettato. Se ad esempio volessimo cambiare la parola “nuova” in “vecchia”:

echo Ho una macchina nuova e una bicicletta nuova | sed 's/nuova/vecchia/'

il risultato non sarebbe quello corretto:

Ho una macchina vecchia e una bicicletta nuova

La seconda parola non viene modificata perchè sed termina la ricerca all'interno della stessa frase dopo la prima operazione di sostituzione positiva. Se vogliamo evitare questo inconvenienete dobbiamo effettuare una ricerca globale utilizzando una g alla fine del comando:

echo Ho una macchina nuova e una bicicletta nuova | sed 's/nuova/vecchia/g'

Ora il risultato è corretto:

Ho una macchina vecchia e una bicicletta vecchia

Il parametro globale costringe sed ad arrivare alla fine della riga prima di passare alla riga successiva. Questo ci permette di sostituire più volte la stessa stringa all'interno di una frase, ma per effettuare più sostituzioni contemporaneamente dobbiamo utilizzare il parametro -e. Questo parametro ci permette di utilizzare più comandi che vengono eseguiti in sequenza (il secondo comando viene eseguito dopo che il primo è stato eseguito su tutto il contenuto del file). Esempio:

echo La macchina è nuova | sed -e 's/macchina/bicicletta/' -e 's/nuova/vecchia/'

Come risultato si ottiene:

La bicicletta è vecchia

L'altra possibilità che abbiamo è quella di inserire i comandi da utilizzare all'interno di un file e richiamarlo poi con il parametro -f. Esempio:

cat comandis/macchina/bicicletta/s/nuova/vecchia/

echo La macchina è nuova | sed -f comandiLa bicicletta è vecchia

43/108


Entrambi i metodi vi portano allo stesso risultato, ma utilizzare un file vi permette di modificare i criteri in maniera molto più pratica.

Il comando sed ci permette anche di selezionare in base a dei criteri ben precisi le righe nelle quali effettuare la sostituizione. Una possibilità è quella di sostituire una parola all'interno di una riga che contiene una precisa parola. La sintassi utilizzata è la seguente:

/stringa di criterio/ {operazione}Proviamo ad eseminare il seguente esempio. Abbiamo un file “numeri” che ha il seguente contenuto:

uno 1due 1tre 1tre 1due 1uno 1

Dopo aver eseguito il comando sed il risultato deve essere il seguente:

uno 1due 2tre 3tre 3due 2uno 1

Quindi dobbiamo far trovare al comando la righe che contiene la parola “due” per sostituire poi il valore “1” con “2”. La medesima cosa va fatta anche per le righe che contengono la parola “tre” per passare dal valore “1” al valore “3”. Utilizziamo i seguenti comandi:

cat comandi/due/ s/1/2//tre/ s/1/3/

sed -f comandi numeri uno 1due 2tre 3tre 3due 2uno 1

Abbiamo anche la possibilità di delimitare la sostituzione delle righe all'interno di un file utilizzando il numero che identifica la riga dalla quale

44/108


partire ed il numero che identifica la riga alla quale terminare la sostituzione. La sintassi che dobbiamo aggiungere prima della sintassi di sostituzione è la seguente:

prima riga, ultima rigaPer cambiare ad esempio le parole “due” e “tre” in “uno” possiamo scrivere:

cat comandi1,5 s/due/uno/1,5 s/tre/uno/sed -f comandi numeriuno 1uno 1uno 1uno 1uno 1uno 1

Il comando sed permette anche di modificare il numero delle righe da visualizzare sullo schermo. Questo diventa possibile utilizzando il comando q.

sed 75000q /usr/dict/words

Questo esempio elenca tutte le righe presenti all'interno di questo file perchè meno di 75.000. Per visualizzare le prime 60 righe del file bisogna scrivere:

sed 60q /usr/dict/words

Il parametro -n non visualizza le righe che normalmente verrebbero stampate su schermo. Questo vuol dire che utilizzato con un qualsiasi comando sed il risultato sarebbe sempre vuoto. A che cosa serve avere un parametro che non visualizza il risultato del comando. Detto così assolutamente a niente. Per questo utilizziamo il parametro -n in combinazione al parametro -p che invece obbliga il comando a visualizzare determinate righe.La combinazione di questi due parametri ci permette di spegnere tutto il risultato (-n) e di attivare solamente le parti che ci interessano (-p). Per visualizzare su schermo solamente le righe che sono state modificate si possono utilizzare i comandi utilizzati nel seguente esempio:

cat comandi/due/ s/1/2/p/tre/ s/1/3/p

45/108


sed -nf comandi numeridue 2tre 3tre 3due 2

Per stampare su schermo solamente le righe che vanno dalla posizione 200 alla posizione 300 si utilizza sed come segue:

sed -n '200,300p' /usr/dict/words

Per eliminare una riga dalla visualizzazione su schermo (e non dal file originale) si può utilizzare il comando d. La sintassi è la seguente:

{stringa di criterio} dPer eliminare tutte le righe che contengono la parola “tre” basta scrivere come segue:

sed '/tre/ d' numeriuno 1due 1due 1uno 1

Per eliminare invece le righe 1, 2 e 3 si può utilizzare:

sed '1,3 d' numeritre 1due 1uno 1

In ogni caso questo comando vi permette di eliminare solamente l'intera riga e non una parte di essa. Per poter eliminare una parte di una frase si può utilizzare il comando per la sostituzione:

sed 's/parola//'

46/108


UTENTI E GRUPPI

Questo capito è dedicato agli utenti, ai gruppi ed ai file di configurazione più noti legati a questi concetti.

Il comando suCome precedentemente spiegato l'utente root è l'utente che può fare all'interno del sistema quello che vuole. Per motivi di sicurezza è quindi molto importante effettuare il login come utente normale e utilizzare l'utente root solamente in casi specifici.Se dopo aver effettuato il login diventa indispensabile modificare alcuni dati del sistema (ad esempio la creazione di nuovi utenti) ci si dovrebbe disconnettere come utente normale per effettuare nuovamente il login da root.Per evitare questa procedura Linux ci mette a disposizione il comando su che ci permette di cambiare utente in maniera molto semplice. Per passare da utente normale a root bisognerà solamente digitare il comando, premere INVIO e digitare la parola chiave di root.

su

Per passare nuovamente all'utente normale basta digitare il comando seguito dal nome dell'utente con il quale ci si vuole connettere. In questo caso non viene richiesta la parola chiave (l'utente root può fare tutto).

47/108


su ivan

I file di sistema /etc/passwd, /etc/shadow e /etc/groupDurante l'installazione Linux aggiunge almeno un utente al sistema (l'utente root). Questo è l'utente più potente all'interno del sistema e può praticamente fare qualsiasi cosa. Dopo l'installazione è spesso necessario aggiungere altri utenti, oppure modificare variabili associate ad utente attualmente presenti.

Per capire quello che succede all'interno del sistema è utile conoscere i file che il sistema operativo gestisce in relazione con gli utenti. Il primo file importante è il file /etc/passwd. I campi di ogni riga sono divisi da due punti (:) come mostrato nel seguente esempio:

root:x:0:0:root:/root:/bin/bashbin:x:1:1:bin:/bin:daemon:x:2:2:daemon:/sbin:adm:x:3:4:adm:/var/adm:lp:x:4:7:lp:/var/spool/lpd:sync:x:5:0:sync:/sbin:/bin/sync...ferrazzi:x:501:100:ivan:/home/ferrazzi:/bin/bash

I sette campi presenti all'interno di questo file contengono le seguenti informazioni:

• Il nome di login dell'utente.• La parola chiave – Questo campo può contenere un codice criptato (di

solito in md5) oppure una “x”. La “x” identifica che le parole chiave sono custodite all'interno del file /etc/shadow.

• L'identificatore numerico dell'utente – Questo è il numero con cui il sistema identifica effettivamente l'utente. L'utente root ha sempre 0 come identificativo, mentre gli utenti normali partono dal numero 500. Un numero identificativo identifica esattamente un utente.

• L'identificatore numerico del gruppo – Il gruppo di root è sempre 0, mentre il numero che viene assegnato agli utenti incomincia con il valore contenuto nel file di sistema /etc/login.defs.

• Testo utilizzato a scopo di descrizione dell'utente.• La home directory dell'utente.• Il tipo di shell da utilizzare per questo utente.

Il file /etc/shadow contiene le parole chiavi ed altri parametri relativi all'account dell'utente. Esempio:

root: awYeiEwzMpfo6:11144:0::7:7::

48/108


bin:*:10547:0::7:7::...ferrazzi:aw0VvUAsWpigo:11144:0::7:7::

Gli otto campi contengono le seguenti informazioni:

• Il nome di login dell'utente – Questo è l'unico campo che deve combaciare con l'inserimento all'interno di /etc/passwd.

• Un hash criptato della parola chiave – L'asterisco identifica l'assenza di parola chiave.

• La data di quando è stata modificata la parola chiave – Espresso in numero di giorni a partire dal 1/1/1970.

• L'età minima di una parola chiave – Quanto l'utente deve aspettare prima di poter modificare la parola chiave.

• L'età massima di una parola chiave – Quanto l'utente ha il permesso di tenere la stessa parola chiave.

• Il numero dei giorni prima che la parola chiave perda validità dopo che all'utente viene richiesto di modificare la propria parola chiave.

• Il numero dei giorni da attendere prima che venga disabilitato l'account dopo che la parola chiave ha perso validità.

• La data di validità della parola chiave – In giorni dal 1/1/1970.

Il file che contiene le informazioni riguardo i gruppi è /etc/group. Qui di seguito un esempio:

root::0:wheel::10:bin::1:bin,daemondaemon::2:bin,daemon...nobody::65534:users::100:

Ogni riga (quindi ogni gruppo) è composta da quattro campi:

• Nome del gruppo – Un testo di massima otto caratteri utilizzato ad esempio per il comando ls -l.

• Contiene una parola chiave – Di default la parola chiave sui gruppi non viene richiesta, ma in caso sia necessario questa viene registrata in questo campo.

• Identificativo del gruppo – Questo numero viene utilizzato dal sistema e deve essere unico.

• I membri del gruppo – Questo campo può essere utilizzato per elencare i membri del gruppo separati da una virgola.

49/108


Creare un nuovo utente

Il comando useradd crea un nuovo account (quindi un nuovo utente) utilizzando i valori specificati nella riga di comando e i valori di default del sistema. Il nuovo utente viene inserito all'interno dei file di sistema, la home directory viene creata e i file iniziali vengono copiati, tutto dipendentemente dai parametri utilizzati con questo comando. I parametri utilizzabili con questo comando sono visualizzati nella seguente tabella.

Parametri per il comando useraddParametri Descrizione

-c commento-d /home_dir

-e data

-f giorni

-g gruppo

-G gruppo-k file-m

-n

-r

-p passwd

-s-u -uid

Riempie il campo che contiene il commento.Permette di specificare la home directory da creare. Di default questa corrisponde al nome dell'utente.La data di quando la parola chiave viene disabilitata. La data va inserita con il formato AAAA-MM-GG.Il numero dei giorni che passano prima che la parola chiave venga eliminata dopo essere stata disabilitata. 0 elimina la parola chiave quando viene disabilitata, -1 disabilita questa funzione.Il nome o l'identificativo del gruppo da assegnare all'utente.Una lista di gruppo ai quale appartiene l'utente.Permette di rimpiazzare l'utilizzo di /etc/skel.Crea la home directory dell'utente se questa non è presente.Evita di creare il gruppo utilizzando il nome dell'utente.Crea un account di systema con privilegi speciali.La parola chiave criptata utilizzando il metodo di hash.Specifica l'account shell dell'utente.L'identificatore numerico dell'utente.

Vediamo ora come creare un utente utilizzando alcuni dei parametri appena elencati. In questo esempio cerchiamo di creare un account con 722 come identificatore numerico, /ivan come home directory e utente come gruppo di default.

useradd ivan -u 722 -d /ivan -g utente

50/108


Eliminare un utente

Il comando userdel viene utilizzato per eliminare l'utente dai file di sistema /etc/passwd e /etc/shadow. Per poter eliminare un utente questo non deve essere connesso al sistema. Il parametro -r viene utilizzato per eliminare anche la home directory e tutti i file contenuti in essa.

Cerchiamo ora di eliminare l'utente che abbiamo precedentemente creato:

userdel ivan -r

Modificare l'account di un utente.

Il comando usermod ci permette di modificare l'account di un utente. Abbiamo anche per questo comando una serie di parametri a disposizione per effettuare le modifiche necessarie, e molti sono gli stessi visualizzati già per il comando useradd. Come il comando userdel anche usermod non può essere utilizzato in caso l'utente sia connesso.

Parametri per il comando useraddParametri Descrizione

-c commento-d /home_dir

-e data

-f giorni

-g gruppo

-G gruppo-l name-m

-s-u -uid-L

-U

Riempie il campo che contiene il commento.Permette di specificare la home directory da creare. La data di quando la parola chiave viene disabilitata.Il numero dei giorni che passano prima che la parola chiave venga eliminata dopo essere stata disabilitata.Il nome o l'identificativo del gruppo da assegnare all'utente.Una lista di gruppo ai quale appartiene l'utente.Permette di modificare il nome utente.Crea la home directory dell'utente se questa non è presente. Se esiste sposta l'intero contenuto.Specifica l'account shell dell'utente.L'identificatore numerico dell'utente.Blocca la parola chiave di un utente disabilitandolaSblocca la parola chiave di un utente.

Il segunte esempio mosta come è possibile sbloccare la parola chiave di un utente precedentemente bloccata:

51/108


usermod ivan -U

Aggiungere un nuovo gruppo

Il comando groupadd viene utilizzato per aggiungere nuovi gruppi al sistema. I parrametri che si possono utilizzare con questo sistema sono elencati nella seguente tabella.

Parametri per il comando groupaddParametri Descrizione

-g gid-r-f

-o

Specifica il numero ID del gruppo.Specifica la creazione di un account di sistema.Costringe il sistema ad eseguire questo comando anche in caso di eventuali errori.Permette di creare gruppi con ID uguali.

Nel prossimo esempio cerchiamo di creare un nuovo gruppo linuxgroup con GID pari a 721:

groupadd -g 721 linuxgroup

Eliminare un gruppo

I gruppi vengono eliminati utilizzando il comando groupdel. Questo comando è simile al comando userdel ed elimina il gruppo dal file di sistema /etc/group. Questo programma non permette l'eliminazione di gruppi primari. E' importante controllare che nessuno utente abbia la necessità di dover accedere al gruppo che si vuole eliminare.

Nel seguente esempio vediamo come è possibile eliminare il gruppo appena creato:

groupdel linuxgroup

Modificare un gruppo

Le impostazioni di un gruppo vengono modificate utilizzando il comando groupmod. Questo comando viene utilizzato con il parametro -g per modificare il GID del gruppo.Il comando groupmod funziona come il comando usermod. Il prossimo esempio mostra come utilizzare questo comando per modificare la GID di un gruppo:

52/108


groupmod linuxgroup -g 400

Visualizzare l'appartenenza ad un gruppo

Gli utenti possono visualizzare il gruppo o i gruppi ai quali appartengono utilizzando il comando groups. L'utente root ha invece la possibilità di utilizzare lo stesso comando per visualizzare i gruppi di appartenenza di un qualsiasi utente.

Modificare la parola chiave

L'utente root ha la possiblità di modificare una qualsiasi parola chiave utilizzando il comando passwd come segue:

passwd utente

Ogni utente può utilizzare questo comando (senza indicare l'utente) per modificare la propria parola chiave.

53/108


PERMESSI

In questo capitolo vedremo come funzionano i permesse nel sistema operativo Linux.

Permessi simbolici e numerici

I permessi possono essere espressi in maniera simbolica o numerica. I permessi più comuni utilizzati con file e directory sono read (leggi), write (scrivi) e execute (esegui). Queste possono essere espresse utilizzando le lettere r, w e x, o in formato binario rispettivamente con 4, 2 e 1. E' veramente molto importante conoscere sia la rappresentazione simbolica che numerica.

Questi permessi possono essere combinati. I permessi di lettura e scrittura vengono visualizzati come rw- in formato simbolico, e con il valore 6 in formato numerico. Il trattino utilizzato come terzo carattere identifica il permesso negato nell'esecuzione di questo file. I permessi di lettura, scrittura e esecuzione vengono rappresentati come rwx in formato simbolico e 777 in formato numerico.

Con il comando ls abbiamo la possiblità di visualizzare i permessi di ogni file presente all'interno del nostro sistema. Vediamo il seguente esempio:

ls -l nomi

54/108


-rw-rw-r-- 1 ivan ivan 244 Dec 22 11:00 nomi

Precedentemente abbiamo detto che il primo simbolo della stringa dei permessi identifica il tipo di file (“d” per directory e “–“ per un file normale). Il resto di questa stringa (quindi i restanti nove caratteri) identificano tre blocchi di permessi:

• permessi per l'utente proprietario• permessi per il gruppo del proprietario• permessi per gli altri utenti

Ogni blocco è composto dai permessi per la lettura, scrittura ed esecuzione (rwx).Il permesso di lettura su una directory permette all'utente di visualizzare il contenuto di essa. Un permesso di lettura su un file normale permette la visualizzazione del contenuto stesso. I diritti di scrittura permettono su una directory di eliminare o creare file all'interno di essa, su un file di modificare il contenuto. I diritti di esecuzione su una directory invece permettono l'accesso ad essa per farla diventare la nostra pwd, mentre sui file normali permette la loro esecuzione.

Cambiare il proprietario di un file o una directory

Il camando che viene utilizzato per cambiare il proprietario di un file o di una directory è chown. Questo comando viene utilizzato con la seguente sintassi:

chown -parametri proprietario:gruppo file

Il proprietario rimane invariato se questo parametro non viene utilizzato. La stessa cosa succede anche con il gruppo. Se lasciato vuoto anche questo valore non viene modificato. Utilizzando il punto (.) come valore di questo parametro verrà assegnato al file o alla cartella il gruppo di default. Questo comando può essere utilizzato con vari parametri visualizzati nella seguente tabella.

Parametri per il comando chownParametri Descrizione

-c-f-R

-v

Visualizza l'eventuale cambiamento.Modifica senza visualizzare messaggi.Modifica il proprietario su file e directory recursivamente.Visualizza messaggi per ogni file processato.

55/108


Vediamo subito alcuni esempio. Il primo assegna recursivamente il proprietario filippo alla cartella documenti.

chown -R filippo documenti

Nel secondo esempio vogliamo assegnare a tutti i file che iniziano per anti il proprietario filippo:

chown -v filippo anti*owner of antistress.zip retained as filippoowner of antistress1.zip retained as filippoowner of antistress2.zip retained as filippo

Cambiare il gruppo di un file o di una directory

Anche il comando chgrp può essere utilizzato per cambiare il gruppo di appartenenza di un file o di una directory. Questo comanda va a verificare la presenza del gruppo all'interno del file /etc/group prima di effettuare la modifica. La sintassi utilizzata per questo comando è la seguente:

chgrp nuovo_gruppo file

I parametri che si possono utilizzare con questo comando sono visualizzati nella seguente tabella.

Parametri per il comando chgrpParametri Descrizione

-c-h

-f-R

-v

Visualizza l'eventuale cambiamento.Cambia link simbolici senza modificare il file di riferimento.Modifica senza visualizzare messaggi di errore.Modifica il proprietario su file e directory recursivamente.Visualizza messaggi per ogni file processato.

56/108


Modificare i permessi

Il comando più importante per la modifica di permessi su file è chmod. Questo comando può essere utilizzato per modificare i permessi degli utente, dei gruppi e di altro. Solamente il proprietario di un file o l'utente root (superuser) hanno la possibilità di modificare i permessi di un file. La sintassi utilizzata è la seguente:

chmod -parametri mode file

I permessi specificati come mode possono essere assegnati utilizzando i valori simbolici o numerici. Come precedentemente spiegato i permessi vengono assegnati utilizzando i numeri binari, dove 4 identifica i permessi per la lettura, 2 per la scrittura e 1 per l'esecuzione.Per poter dare in riferimento al file mioprog all'utente i permessi per la lettura, la scrittura e l'esecuzione (7), al gruppo i permessi per la lettura e la scrittua (6) e agli altri solamente il permesso di lettura (1) possiamo utilizzare il comando come segue:

chmod 764 mioprog

La stessa cosa si può ottenere anche utilizzando dei valori simbolici, ma in questo caso diventa indispensabile l'utilizzo di questo comando per più volte.

chmod u=wrx mioprogchmod g=rx mioprogchmod o=r mioprog

Quando vengono utilizzati i valori simbolici a può essere utilizzato per tutti gli utenti (all users), u per il proprietario del file, g come il gruppo e o per gli altri utenti (others).I permessi possono essere aggiunti o tolti, oppure è possibile assegnare contemporaneamente i permessi all'utente ed al gruppo, ma solo se questi devono ricevere gli stessi permessi. Esempio:

chmod ug=wrx mioprog

Nel seguente esempio togliamo il permesso di esecuzione a tutti gli altri utenti:

chmod o-x mioprog

Oppure possiamo aggiungere il permesso di lettura a tutti gli altri utenti senza modificare però i permessi di scrittura ed esecuzione:

chmod o+r mioprog

57/108


Questo comando permette l'utilizzo di vari parametri per modificare l'output di esecuzione.

Parametri per il comando chmodParametri Descrizione

-c-h

-f-R

-v

Visualizza l'eventuale cambiamento.Cambia link simbolici senza modificare il file di riferimento.Modifica senza visualizzare messaggi di errore.Modifica il proprietario su file e directory recursivamente.Visualizza messaggi per ogni file processato.

Assegnazione di permessi default per nuovi file

Il comando umask può essere utilizzato per definire i permessi di default che vengono assegnati ai nuovi file creati. Questo comando funziona utilizzando i valori numerici per la definizione dei permessi.

umask002

Questo valore viene spesso assegnato tramite l'utilizzo di script di profilo e può essere visualizzato utilizzando il sempre il comando umask. Il file di sistema che contiene il valore umask a livello globale è /etc/profile.Il comando umask lavora come filtro dei permessi su nuovi file creati. Il valore visualizzato nell'esempio (002) blocca il permesso di scrittura per gli altri utenti.E' possibile modificare questa impostazione utilizzando umask, ma al prossimo login i parametri di default verrebbero ripristinati. Per mantere le impostazioni desiderate bisognerebbe cambiare questo valore direttamente all'interno del file di profilo.Questo valore è esattamente l'opposto dei permessi. I permessi visualizzati con umask sono quelli che vengono filtrati dai permessi utilizzati sui file.

SUID e SGID

E' possibile configurare un file in maniera tale da far utilizzare i permessi

58/108


dedicati all'utente proprietario o al gruppo ad un qualsiasi utente che lo esegui. Questo può essere rischioso perché permette ad un utente di utilizzare un comando come altro utente. Ci sono delle situazioni dove una tale funzione diventa indispensabile.Possiamo, ad esempio, obbligare il sistema a creare nuovi file all'interno di una cartella utilizzando sempre il gruppo proprietario della cartella stessa settando su di essa il flag SGID. SUID non ha alcun effetto se utilizzato su una cartella, ma viene normalmente utilizzato per file eseguibili.SUID identifica l'ID di utente, SGID quella del gruppo e si utilizza sempre il comando chmod per assegnare i rispettivi valori. Il bit SUID viene assegnato come segue:

chmod u+s mioprog

Il bit GUID invece utilizzando il seguente chmod:

chmod g+s mioprog

Questi valori possono essere assegnati anche utilizzando valori numerici. I valori speciali SUID e SGID hanno i seguenti valori binari: SUID 4, SGID 2 e sticky bit 1 (spiegato successivamente). Il prossimo esempio mostra come assegnare SUID e SGID utilizzando i valori numerici:

chmod 4755 mioprogchmod 2755 mioprog

Prima di modificare i permessi relativi ad un qualsiasi file bisogna essere sicuri di conoscere la funzione del file stesso ed i permessi dell'utente proprietario.

Sticky bit

Un altro bit speciale che può essere assegnato ad un file è lo sticky bit. Questo bit viene spesso utilizzato su directory condivise per consentire una gestione più semplice. In caso di diritti di scrittura su una cartella, questo bit infatti permette ad un utente di scrivere all'interno di una directory, ma solo il proprietario del file o della cartella può eliminarlo. Questo sistema permette la condivisione di documenti, ma evita la cancellazione di file che non appartengono ad un altro utente. Lo sticky bit utilizza un 1 come valore numerico e t come valore simbolico. Anche questo valore viene assegnato mediante il comando chmod come visualizzato nel seguente esempio:

chmod o+t mioprogchmod 1777 mioprog

59/108


Anche se assegnato all'interno del blocco dei diritti “others” lo sticky bit funziona solamente in combinazione ai diritti di scrittura assegnati.

60/108


COMUNICAZIONE AGLI UTENTI

Linux ci mette a disposizione dei file che ci permettono di mandare delle comunicazioni agli utenti che si collegano al nostro computer sia in remoto che in locale. I file che si possono utilizzare sono /etc/issue, /etc/issue.net e /etc/motd.

/etc/issue

Il contenuto di questo file viene visualizzato dal sistema prima della richiesta di login, ma solamente sul computer locale. Tipici inserimenti sono:

Debian GNU/Linux testing/unstable pippo

oppure

Welcome to Debian Linux 3.1 (i386) – Kernel 2.4.18

/etc/issue.net

Il contenuto di questo file viene visualizzato dal sistema prima della richiesta di login, ma solamente su connessioni remote e dove in remoto venga richiesto il login.

61/108


/etc/motd

Questo file è un'abbreviazione di “message of the day” e ci permette di effettuare delle comunicazioni a login effettuato. Il testo inserito in questo file viene visualizzato quindi solamente dopo aver effettuato il corretto login. Possiamo utilizzare questo file per inviare delle comunicazioni solamente agli utenti del nostro sistema.

62/108


RUNLEVELS

Linux mette a disposizione più modalità di funzionamento, ossia dei runlevel. All'interno di ogni runlevel vengono fatti partire alcuni programmi mentre altri vengono fatti arrestare.

Il primo processo che viene fatto partire all'interno di un sistema linux è il processo init (id di processo 1). Questo processo fa a sua volta partire tutti gli altri processi all'interno del sistema, ossia i processi di utenza e tutti i processi privi di terminale. Linux ci permette quindi di configurare dei runlevel all'interno dei quali possiamo far partire dei processi.

Principalmente abbiamo a disposizione i runlevel che vanno da 0 a 6 più un runlevel di sistema S. I runlevel 0,6 e S sono dei runlevel predefiniti gli altri possono essere configurati a piacere. Il runlevel 0 equivale alle operazioni da eseguire per effettuare un arresto di sistema, il runlevel 6 effettua un riavvio, mentre il runlevel S contiene le operazioni da eseguire in single user mode, ossia in modalità dove solamente l'amministratore può accedere al sistema.

Per saltare manualmente da un runlevel all'altro l'amministratore può utilizzare il comando init seguito dal runlevel al quale vogliamo passare

init S

oppureinit 3

63/108


Invece di utilizzare i comandi init 0 oppure init 6 consigliamo di utilizzare l'apposito comando shutdown.

64/108


GESTIONE DEI PROCESSI

In questo capitolo vedremo le utility utilizzate per la visualizzazione e la gestione dei processi all'interno del sistema operativo Linux.

Gestire i processi

Ogni volta che un comando o un'operazione viene eseguita all'interno di una shell viene creato un processo. Ad ogni processo iniziato viene assegnato un numero di processo univoco chiamato anche PID. Questi processi e PID possono essere visualizzate mediante il comando ps. Questo comando fornisce lo stato dei processi presentando la situazione al momento del esecuzione del comando dei processi all'interno del sistema. Le informazioni visualizzate con il comando ps possono essere modificate utilizzando i parametri presenti all'interno della seguente tabella.

65/108


Parametri per il comando psParametri Descrizione

atxx

u

ls

mx

S

Visualizza i processi di tutti gli utenti.Visualizza i processi controllando il terminale txx.Visualizza le informazioni dell'utente per il processo.Visualizzazione dettagliata.Visualizza le informazioni con il formato a segnali.Visualizza informazioni riguarda la memoria.Visualizza informazioni senza controllare un terminale.Visualizza il tempo del CPU e le pagine di sottoprocessi.

Per visualizzare tutti i processi attualmente in esecuzione all'interno del nostro sistema viene utilizzato il seguente comando:

ps -auxUSER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMANDroot 1 0.0 0.2 1120 372 ? S 18:26 0:05 init [3]...

Questo comando è molto utile per avere un quadro di quella che è la situazione attuale all'interno del nostro sistema. Ci sono però delle situazioni dove è indispensabile avere un'informazione in tempo reale di quella che è la situazione dei processi. In questi casi viene utilizzato il comando top. Visto comunque l'intenso utilizzo del CPU da parte di questo comando è consigliabile utilizzaro solamente se necessario. Le informazioni fornite da questo comando possono essere organizzate in base all'utilizzo della CPU, della memoria e della runtime. Il metodo più semplice per eseguire questa utility è scrivere top nella riga di comando. All'interno di top potete utilizzare il comando s per poi specificare l'opzione che si vuole utilizzare. I parametri utilizzabili per questo comando sono visualizzati nella seguente tabella.

66/108


Parametri del comando topParametri Descrizione

dq

Ssic

Per specificare i secondi tra un update e l'altro.Determina il non utilizzo di tempi di attesa tra un update e l'altro.Include i sottoprocessi nella visualizzazione.Esegue il comando in modalità sicura.Non visualizza processi al minimo.Visualizza la completa riga di comando del processo.

Questa utility può essere abbandonata premendo il tasto q.

A volte può succedere che un processo non risponda più e diventi quindi necessario terminarlo. Per fare questo bisogna utilizzare il comando kill. Questo comando viene utilizzato con la seguente sintassi:

kill -s signal processo

Il processo viene specificato utilizzando la PID o il nome del processo. Solamente l'utente root ha la possbilità di terminare processi relativi ad altri utenti. Il segnale default che viene inviato con il comando kill è il segnale TERM. E' possibile specificare altri segnalli utilizzando sempre questo comando. I livelli dei segnali più comuni ed i loro significati sono visualizzati all'interno della seguente tabella.

Livelli di segnale comuni

Segnale Descrizione

1915

SIGHUP. Ferma e fa ripartire il processo.SIGKILL. Termina il processo istantaneamente.SIGTERM. Termina il processo facendoli terminare alcune operazioni.

Una lista dei segnali utilizzabili con questo comando viene visualizzata utilizzando il parametro -l. Nel seguente esempio facciamo terminare e poi ripartire il programma con PID 444:

kill -1 444

Alcuni processi occupano la shell fino a quando hanno terminato la propria esecuzione. Questo processi vengono fatti girare in foreground (ossia in superfice). Altri processi non possono partire dall'interno della stessa shell fino a quando il processo in foreground non è terminato.Altri processi invece vengono fatti partire in background (nel retro). Se un processo viene fatto partire in background la stessa shell rimane libera

67/108


per l'esecuzione di altri processi, nonostante il primo non abbia ancora terminato la propria esecuzione. L'esecuzione in foreground o in background è dipendente dal processo stesso e da come viene fatto partire. I comandi che eseguita dalla riga di comando vengono normalmente eseguiti in foreground. Per eseguire un comando in background dalla riga di comando bisogno piazzare il simbolo & alla fine del comando. Nel seguente esempio vediamo come eseguire il processo mozilla in background:

mozilla &

Eseguendo il processo in questa maniera la shell rimane libera per far partire altri comandi.

Per spostare un processo in esecuzione dal foreground nel background viene utilizzato un altro sistema. Il comando ^Z ferma un comando eseguito in foreground. Una volta fermato lo si può spostare in background utilizzando il comando bg jobnumber. Il numero utilizzato (jobnumber) lo si può identificare utilizzando il comando jobs. Questo comando visualizza tutti i processi attualmente in background come anche i processi fermati. Esempio:

mozilla^Zjobs[2] Stopped mozillabg 2

Nel precedente esempio facciamo partire il processo mozilla fermandolo poi con il comando ^Z. Poi viene utilizzato il comando jobs per identificare il numero del job. Dopodichè utilizziamo il comando bg per mandare il processo in background.

E' anche possibile spostare un processo dal background in foreground utilizzando il comando fg jobnumber come segue:

fg 2

Modificare la priorità dei processi

Quando un processo viene fatto partire il sistema assegna un livello di priorità. Di default questo valore è pari a zero (0). La priorità di un processo può essere un numero compreso tra il -20 e 19. Più alto il numero di priorità e più lenta è l'esecuzione del processo. I valori negativi possono essere assegnati solamente dall'utente root. Il livello di priorità viene visualizzato mediante il comando top precedentemente introdotto.

68/108


Il livello di priorità di un processo da eseguire può essere modificato utilizzando il comando nice. Questo comando utilizza la seguente sintassi:

nice priorità comando

Per eseguire mozilla con una priorità di 10 bisogna utilizzare il seguente comando:

nice -10 mozilla oppure

nice –-5 mozilla (per valori nice negativi da root)

Per modificare la priorità di un processo attualmente in esecuzione bisogna utilizzare il comando renice. Questo comando utilizza i seguenti parametri.

Parametri del comando reniceParametri Descrizione

-g

-u

-p

Priorità utilizzata per comandi eseguiti da utenti appartenenti il gruppo specificato.Priorità utilizzata per comandi eseguiti dal utente specificato.Priorità utilizzata dal processo specificato.

Il seguente esempio permette di modificare la priorità del processo 444 attualmente in esecuzione:

renice -10 -p 444444: old priority 15, new priority

69/108


LA GESTIONE E LA MANUTENZIONE DELLE

PARTIZIONI E DEI FILESYSTEM

In questo capitolo vedremo quali strumenti abbiamo a disposizione per creare delle partizioni, formattarli in maniera tale da poter essere utilizzati e come poi effettuare un'adeguata manutenzione.

Creare e formattare una partizione

Il programma che viene utilizzato per creare le partizioni è cfdisk. Su una lista completa di tutte le partizioni o dischi fissi vuoti presenti all'interno del nostro sistema ci permette di effettuare tutte le operazioni legate ad una giusta creazione delle partizioni necessarie.

Una volta creata la partizione diventa indispensabile formattarla in base al filesystem che vogliamo utilizzare. Il programma che ci mette in grado di eseguire una formattazione è mkfs che alla fine non è altro che un front-end di altri programmi creati per la formattazione di ogni tipo di filesystem, come mkfs.ext2, mkfs.minix, mkfs.msdos, oppure mkfs.xiafs.

mkfs [-t tipo_di_filesystem] [opzioni] device_file [blocchi]

70/108


Alcuni dei tipi di filesystem che si possono creare sono ext2, ext3, reiserfs, oppure vfat. Per quanto riguarda le opzioni queste possono cambiare in base al filesystem che andiamo a creare. Alcune delle opzioni a disposizione per il filesystem ext2 sono:

• -b dimensione_blocchiIdentifica la dimensione dei blocchi in byte.

• -cEffettua un check del disco per identificare eventuali blocchi difettosi

• -i bytes_per_inodePermette di identificare l'ammontare di bytes utilizzati da un singolo inode

• -N numero_dei_inodePermette di inserire il numero assoluto degli inode da utilizzare

Dopo aver creato una o più partizioni nuove all'interno di un disco fisso, e dopo averlo formattato correttamente il sistema di linux non è ancora in grado di riconoscerlo. Per questo motivo abbiamo bisogno di comandi che ci permettano di montare la o le nuove partizioni.

Rendere un'unità visibile al sistema

Il programma utilizzato per montare un qualsiasi tipo di unità è mount. Questo programma non viene utilizzato solamente per montare dischi fissi o partizioni di questi, ma anche per montare un CD-Rom inserito nell'apposito lettore, un floppy inserito nel floppy disk drive, oppure una chiavetta usb.Il comando viene utilizzato come segue:

mount [-t filesystem] [-o opzioni] [device_file] [mount point]

Per montare un'unità è quindi molto importante sapere quale device file la identifica. Il floppy viene identificato dal device file /dev/fd0, la chiavetta usb (visto l'utilizzo della simulazione SCSI) /dev/sdxy dove x e y dipendono da come la chiavetta viene identificata dal sistema (es. /dev/sda1), una partizione ed il CD-Rom vengono identificati dalla rispettiva posizione hardware con /dev/hdxy dove x identifica il collegamento fisico dell'unità e y la partizione (con il CD-Rom la partizione viene lascita via).All'interno del comando possiamo lasciare via il filesystem data la capacità di riconoscere automaticamente il tipo di filesystem che verrà montato. Il comando di solito viene utilizzato senza filesystem ne opzioni, ma semplicemente come segue:

mount /dev/fd0 /floppy

71/108


Il mount point è molto importante. Questo non è altro che una cartella messa a disposizione come punto di mount. Se la cartella dovesse contenere degli altri file a unità montata non sarebbe possibile utilizzarli. Diventerebbero nuovamente disponibili una volta smontata l'unità.

Per smontare un'unità precedentemente montata possiamo utilizzare il comando umount seguito dal device file oppure il mount point in questione, es.

umount /floppy

Il comando mount può essere utilizzato anche singolarmente, ossia senza l'aggiunta di parametri. In questo caso viene visualizzata su schermo la lista di tutte le unità attualmente montate all'interno del sistema. La lista delle unità montate viene estratte dal file /etc/mtab che ne contiene sempre una situazione aggiornata.

Montare un'unità ad ogni avvio potrebbe diventare una cosa abbastanza noiosa, soprattutto se vogliamo lavorare con le nuove partizioni aggiunte quotidianamente. Per questo motivo possiamo utilizzare il file di configurazione di mount che ci permette di inserire tutte le partizioni che il sistema deve riconoscere subito all'avvio, senza dover montare le unità manualmente ogni volta. Il file di configurazione è /etc/fstab ed ha il seguente formato:

/dev/hda2 / ext2 defaults 1 1/dev/hdb /cdrom auto ro,noauto,user 0 0/dev/fd0 /floppy auto defaults,noauto,user 0 0

Le colonne a partire da sinistra identificano il device file, il mount point, il filesystem, le opzioni di mount, la verifica dump ed il filesystem check automatico.

Le opzioni che abbiamo a disposizione sono le seguenti:

• asyncLe operazioni input/output vengono eseguite in maniera asincrona

• atimeLe timestamp di accesso ad ogni inode vengono registrate

• autoI mount point che come opzione hanno auto vengono montate all'avvio o quanto si utilizza mount -a

• defaultsVengono settate le seguenti opzioni: rw, suid, dev,exec,auto,nouser e async

• devdevice file sono permessi e vengono identificati

• exec

72/108


permesso di eseguire file binari eseguibili sul sistema• noatime

Le timestamp di accesso alle inode non vengono registrate• noauto

Non viene montato automaticamente con mount -a• nodev

device file non vengono interpretati• noexec

file binari eseguibili non possono essere eseguiti• nosuid

SUID e SGID bit vengono ignorati• nouser

Un utente normale non può montare questa unità• remount

Utilizzato per rimontare un'unità con nuove opzioni• ro

Modalità ReadOnly• rw

Modalità Read and Write• suid

SUID e SGID bit vengono interpretati• sync

Le operazioni input/output vengono sincronizzate• user

Un utente normale può montare la unità• uid=valore

L'unità montata viene montata con valore come proprietario• gid=valore

L'unità montata viene montata con valore come gruppo proprietario

La colonna del dump permette di identificare tutte le unità sulle quali si può utilizzare questo comando. Il filesystem check automatico permette di effettuare un controllo automatico dell'unità direttamente dopo un numero preciso di avvi del sistema.

Mantenere l'integrità di un filesystem

Linux mette a disposizione vari programmi che ci permettono di mantenere e di controllare l'integrità del nostro filesystem.

fsck opzioni device_file

Questo programma ci permette di eseguire un filesystem check. I parametri che possiamo utilizzare sono i seguenti:

• -f

73/108


force – il filesystem check viene eseguito anche se l'unità ha il Valid-Flag settato

• -ppreen – se necessario viene eseguita riparazione senza prima chiedere conferma

• -nno – l'unità viene montata in ReadOnly e a tutte le domande che vengono fatte durante il filesystem check viene automaticamente risposto no.

• -yCome -n, ma alle domande viene risposto si.

Per controllare lo spazio disponibile sul nostro sistema possiamo invece utilizzare il comando df (disk free). Questo comando ci permette di visualizzare sullo schermo il device_file, l'ammontare di spazio, quello utilizzato, quello disponibile, lo spazio utilizzato in percentuale ed il mount point.Es.

Filesystem 1k-blocks Used Available Use% Mounted on/dev/hda2 2071328 1051656 914448 53% //dev/hda5 3099108 1737096 1204580 59% /usr

Questo comando può essere utilizzato anche direttamente con il device file desiderato, ad esempio

df /dev/hda2

Il comando du (disk usage) ci permette di verificare quanti kilobyte vengono utilizzati per una determinata cartella o sottocartelle.

du /opt

oppure

du -s /opt

dove -s ci permette di visualizzare solamente la somma dell'intero spazio utilizzato.

Utilizzare il comando ddIl comando dd (direct dump) viene utilizzato per copiare e confertire dei file in tipi di file diversi simultaneamente. La sintassi di questo comando è la seguente:

dd [parametri]

74/108


Questo comando scrive per default dati che arrivano dallo standard input allo standard output. I parametri possono essere utilizzati per modificare questo comportamento. I parametri da utilizzare con questo comando sono visualizzati nella seguente tabella.

Parametri per il comando ddParametri Descrizione

If=FILE

of=FILE

ibs=BYTES

obs=BYTES

bs=BYTES

cbs=BYTES

skip=BLOCKS

seek=BLOCKS

count=BLOCKS

Permette di specificare un file sorgente al posto dello standard input (input file).Permette di specificare un file di destinazione al posto dello standard output (output file).Specifica il numero di BYTES da leggere come unico blocco.Specifica il numero di BYTES da scrivere come unico blocco.Specifica il numero di BYTES da leggere e scrivere come unico blocco.Specifica il numero di BYTES da convertire per volta.Specifica i blocchi da saltare nel file di input prima di copiare.Specifica i blocchi da saltare nel file di output prima di iniziare a scrivere.Specifica i blocchi nel file di input da copiare invece di copiare l'intero file.

75/108


UTILIZZARE DOCUMENTAZIONI

In questo capitolo vedremo come poter utilizzare al meglio le documentazioni messe a disposizione all'interno del sistema.

Aiutarsi con le MAN PAGES

Le pagine di manuale di Linux comunemente chiamate man pages sono il posto migliore per trovare informazioni riguarda la sintassi e parametri da utilizzare con i comandi o le utility all'interno del sistema. I documenti all'interno delle man pages vengono archiviate in maniera compressa. Il comando man decomprime le pagine di documentazione e le visualizza su schermo in maniera formattata. Si accede alle pagine desiderate utilizzando man seguito dal nome del comando per il quale si cerca le informazioni:

man ls

La barra spaziatrice viene utilizzata per scorrere la documentazione pagina per pagina, il tasto q per abbandonare la visualizzazione. Per cercare una stringa all'interno della documentazione possiamo utilizzare la struttura delle regular expressions. Per cercare la parola “option” basta scrivere:

76/108


/option

Localizzare le MAN PAGES

Le man pages di Linux sono archiviate all'interno del sistema. La variabile di ambiente MANPATH contiene la locazione di questi file. Di default le man pages vengono archiviate all'interno delle seguenti directory:

• /usr/man/man1• /usr/man/man2• /usr/man/man3• /usr/man/man4• /usr/man/man5• /usr/man/man6• /usr/man/man7• /usr/man/man8• /usr/man/man9

Il significato di queste directory viene spiegato successivamente.

L'utente può modificare il contenuto di MANPATH. Questo permette l'utilizzo di man pages situate in altre directory. Questo è molto comodo perchè alcune man pages potrebbero non essere presenti all'interno delle directory di default. In alternativa si possono utilizzare dei parametri con il comando man che permettono la ricerca in altre directory. I parametri utilizzabili con questo comando sono:

Parametri del comando manParametri Descrizione

-C config-file

-M path

-P pager

-S section-list

Specifica un file di configurazione differente dal file /etc/man.conf.Specifica la directory per la ricerca di man pages.Specifica il programma da utilizzare per la visualizzazione delle man pages. Il programma default è specificato dalla variabile di ambiente PAGER. I programmi più utilizzati sono more e less.Specifica una lista di sezioni separate da una virgola nelle quali effettuare le ricerche.

77/108


-a

-c

-d

-f-h

-k-K-m system

-w

Specifica che tutti i risultati trovati vengano visualizzati e non solo il primo.Specifica la riformattazione delle pagine sorgente.Specifica la visualizzazione di informazioni di debug al posto nelle man pages attuali.Specifica l'utilizzo di man come whatis.Visualizza le informazioni di aiuto per il programma stesso.Specifica l'utilizzo di man come apropose.Effettua una ricerca utilizzando la stringa fornita.Specifica un set di man pages alternativo basato sul nome di sistema.Specifica la visualizzazione del percorso alle man pages piuttosto del contenuto stesso.

Il seguente esempio visualizza l'utilizzo del parametro -a. In questo caso vengono visualizzate tutte le man pages relative al comando indicato iniziando dalla prima:

man -a crontab

Il parametro -w invece è comodo per trovare la locazione di man pages. Utilizzando questo parametro con il comando crontab visualizzerebbe il seguente risultato:

man -w crontab/usr/man/man1/crontab.1.gz

Ricerca all'interno delle sezioni di man pages

Le informazioni relative alle man pages di Linux sono presenti all'interno del sistema come una collezione di files. Questi files sono raggruppati in sezioni, dove ogni sezione identifica un tipo di informazione ben precisa. La seguente tabella contiene la descrizione delle singole sezioni.

Le sezioni delle man pages

Sezione Descrizione

1234567

Comandi degli utenti e applicazioni.Richiami di sistema e errori del kernel.Richiami di librerie.Unità disco e protocolli di rete.Formati standard dei files.Giochi e dimostrazioni.File e documentazioni varie.

78/108


89

Comandi per l'amministrazione del sistema.Specificazioni e interfacce oscure del kernel.

Quando il comando man deve effettuare la ricerca di un argomento la sequenza di ricerca all'interno di queste sezioni è ben precisa. La sequenza di default è la seguente: 1, 8, 2, 3, 4, 5, 6, 7 e 9.

E' però anche possibile specificare direttamente all'interno del comando man la sezione da ricercare per l'argomento fornito. Se ad esempio si vuole effettuare la ricerca solamente all'interno della sezione 5 in base all'argomento crontab si può scrivere:

man 5 crontab

Effettuare ricerche con whatisIl comando whatis ci permette di effettuare una ricerca all'interno del database whatis. E' possibile creare questo database utilizzando il comando /usr/bin/makewhatis. Questo database contiene delle brevi informazioni trovate all'interno del man pages dei comandi di sistema. Esempio:

whatis passwdpasswd (1) – update a user's authentification tokens(s)passwd (1ssl) – compute password hashespasswd (5) – password filepasswd.nntp [passwd] (5) – passwords for connecting to remote NNTP servers

Come si può notare da questo esempio il comando passwd è inserito all'interno delle sezioni 1 e 5. Inoltre è presente all'interno della sezione 1 del comando ssl.L'esecuzione del comando man con il parametro -f estrae lo stesso risultato.

Effettuare ricerche con aproposAnche questo comando utilizza il database whatis. Questo comando viene utilizzato per effettuare la ricerca della stringa desiderata sia a livello di nome di comando che di descrizione interna. Per visualizzare lo stesso risultato si può utilizzare anche il comando man con il parametro -k.

79/108


Configurazione degli accessi alle man pages

Come citato precedentemente /usr/man è la directory di default delle man pages. La variabile di ambiente MANPATH può essere utilizzata per modificare questa directory. Dato che modificare questa variabile vorrebbe dire perdere il collegamento alla directory attuale è sempre meglio aggiungere le nuove directory senza escludere quelle già presenti. Il seguente esempio vi fa vedere l'utilizzo della variabile MANPATH all'interno del file di profile di un utente /home/user/.profile:

Export MANPATH=/usr/local/man:/usr/man/preformat:/usr/man:/usr/X11R6/man

La maggior parte dei documenti presenti nella directory /usr/man sono compressi e non formattati. Il comando man utilizza le informazioni presenti all'interno del file di configurazione /etc/man.config per la corretta visualizzazione dei documenti. Questo file contiene infatti informazioni su MANPATH, la compressione dei file, la formattazione e le impostazioni del programma di visualizzazione da utilizzare (pager). Con il parametro -C del comando man è possibile utilizzare un'altro file di configurazione.

Il comando man è situato all'interno della directory /usr/bin e deve essere quindi presente nel valore della variabile di ambiente PATH. Altrimenti bisogna far partire il comando con /usr/bin/man.

Utilizzare documentazioni presenti in /usr/docOltre alle man pages altre documentazioni possono essere presenti all'interno del sistema. La seguente tabella visualizza una lista di possibili directory che contengono altre documentazioni.

Directory per documentazioni

Posizione Descrizione

/usr/doc/program_name/usr/doc/FAQ/usr/doc/HTML/usr/doc/HOWTO/usr/info

Documentazione per program_nameFrequently Asked QuestionsDocumentazione in formato HTMLHOWTO filesDocumentazione utilizzando il comando info

80/108


LA GESTIONE DEI PACCHETTI .DEB

Debian, e così anche Ubuntu, utilizza per la distribuzione dei propri pacchetti dei file con estensione .deb. Per la gestione di questi ci mette a disposizione vari programmi.

Il programma dpkg

Questo programma viene utilizzato per installare tutti i pacchetti per i quali abbiamo il file .deb.

dpkg -i pacchetto.debPermette di installare il relativo pacchetto.

dpkg -R -i cartella_pacchettiPermette di installare tutti i file .deb presenti all'interno della cartella cartella_pacchetti.

dpkg -r pacchettoPermette di rimuovere il rispettivo pacchetto, dove come parametro non viene più inserito l'intero nome del file .deb, ma solamente il nome del pacchetto. Se il file del pacchetto installato era pippo_1.0.24_i386.deb per rimuoverlo dal sistema basta

81/108


inserire solamente il nome, ossia pippo. Con l'opzione -r viene eliminato il pacchetto, ma non i relativi file di configurazione.

dpkg -P pacchettoQuesto permette di eliminare il pacchetto ed i relativi file di configurazione.

dpkg -p pacchettoQuesto permette di visualizzare su schermo tutte le informazioni presenti all'interno del file /var/lib/dpkg/available del relativo pacchetto.

dpkg -l pacchettoPermette di visualizzare le informazioni del pacchetto desiderato.

dpkg -L pacchettoPermette di visualizzare la lista di tutti i file del rispettivo pacchetto.

dpkg -s pacchettoVisualizza su schermo lo stato del rispettivo pacchetto. Un pacchetto può essere installed, se il pacchetto è installato completamente, half-installed, se il pacchetto non è stato installato completamente, not-installed, se il pacchetto non è installato, unpacked, se il pacchetto è stato decompresso, ma non ancora configurato, half-configured, se il pacchetto è stato decompresso, la configurazione è iniziata, ma non terminata, oppure config-files, se sono presenti solamente i file di configurazione (normalmente dopo la disinstallazione di un pacchetto con -R).

dpkg-reconfigure pacchettoUtilizzato per effettuare nuovamente la configurazione del rispettivo pacchetto.

Il programma apt-get

Questo programma permette di installare pacchetti debian tenendo conto anche delle relative dipendenze con altri pacchetti e di gestirli. Per installare un pacchetto non è più necessario sapere esattamente il nome del file come con il programma dpkg, ma basta inserire solamente il nome del pacchetto (quindi senza la versione e l'architettura per il quale viene installato il pacchetto).Il programma apt ha bisogno di sapere però quale file scaricare (quindi esattamente la versione) e da dove scaricarlo in base al nome che noi forniamo come parametro. Tutte queste informazioni apt le prende da una o più sorgenti che possono essere dei CD-Rom, dei server http,

82/108


oppure dei server FTP.Le sorgenti che apt può utilizzare per richiedere tutte le informazioni che servono per la corretta installazione di un pacchetto sono elencati all'interno del file /etc/apt/sources.list.

La struttura delle sorgenti (chiamate repositories) viene inserita nel suddetto file come segue:

deb http://ftp.it.debian.org/debian/ stable main contrib non-free

La prima voce deb identifica la tipologia dei pacchetti che stiamo cercando (quindi pacchetti debian), poi l'indirizzo ftp del server da dove scaricare quanto serve, la voce stable identifica la distribuzione debian che ci interessa (quindi quella stabile), mentre con main, contrib e non-free si classificano i tipi di pacchetti che ci interessano.

Il comando apt-get viene utilizzato come segue:

apt-get updateVa ad aggiornare la tabella interna che contiene tutte le informazioni dei pacchetti disponibili per la propria distribuzione debian dalle sorgenti presenti in /etc/apt/sources.list. Le informazioni scaricate vengono mantenute all'interno della cartella /var/lib/apt/lists/ creando un file di testo per ogni repository specificato.

apt-get upgradeIn base alle informazioni recuperate con apt-get update il sistema effettua un aggiornamento dei pacchetti installati.

apt-get install pacchettoPermette di installare il pacchetto specificato e tutti relativi pacchetti dai quali questo dipende. Il parametro -s permette di effettuare una simulazione dell'installazione per verificarne l'eventuale esito senza apportare alcuna modifica all'attuale sistema.

apt-get remove pacchettoPermette di rimuovere un pacchetto.

apt-get source pacchettoPermette di installare il pacchetto con il sorgente del programma scaricato.

Tutti i pacchetti *.deb che vengono scaricati dal repository per l'aggiornamento del sistema o per un'installazione rimangono salvati all'interno della cartella /var/cache/apt/archives/.

83/108


Il programma alien

E' possibile che determinati pacchetti non si riescano a trovare nel formato richiesto da debian, ossia come file .deb, ma come file .rpm. Il programma alias infatti permette di convertire un qualsiasi pacchetto da un formato in un altro.

Le opzioni possibili per questo programma sono:

--to-debIl file dato come parametro viene convertito in .deb

--to-rpmIl file dato come parametro viene convertito in .rpm

--to-tgzIl file dato come parametro viene convertito in pacchetto Slackware

--to-slpIl file dato come parametro viene convertito in pacchetto Stampede

Questo programma può quindi essere utilizzato come nel seguente esempio:

alien --to-deb pippo-1.2.34_i386.rpm

che andrà a creare il file pippo_1.2.34_i386.deb ora installabile con il programma dpkg -i.

84/108


INSTALLARE PROGRAMMI E LE SHARED LIBRARIES

In questo capitolo vedremo come effettuare l'installazione di programmi da sorgente e di come gestire le shared libraries.

Installazione dei programmi da sorgente

Il sorgente dei programmi che vogliamo compilare ed installare lo troviamo di solito in file compressi .tar.gz oppure .bz2.

Prima di poter operare sui file che comprendono il programma bisogna decomprimere il file. Linux ci mette naturalmente a disposizione dei comandi per effettuare la compressione e la decompressione dei file.

Il programma gzip permette di creare file compressi .gz, mentre il comando bzip2 permette di creare file .bz2.

Il comando che di solito viene utilizzato e che mette a disposizione sia gli algoritmi utilizzati per .gz che quelli utilizzati per .bz2 è tar. Questo comando da solo permette solamente di creare degli archivi, ossia permette di raggruppare diversi file all'interno di un unico file (.tar). Se dopo aver raggruppato i file questi vengono compressi si ottiene un file con estensione .tar.gz, oppure .tar.bz2, dipendentemente dal sistema

85/108


utilizzato.

Il seguente comando ci permette di estrarre i file da un archivio compresso con gzip:

tar xzvf archivio.tar.gz

dove x sta per extract, z per l'utilizzo dell'algoritmo zip, v per il verbose mode e f identifica il file sul quale operare. Per questo motivo il parametro f deve sempre essere l'ultimo della lista.

Per decomprimere file in formato .tar.bz2 basta digitare:

tar xjvf archivio.tar.bz2

Dopo aver estratto il file possiamo spostarci all'interno della rispettiva cartella. All'interno di questa cartella è indispensabile il file Makefile che contiene tutte le impostazioni di compilazione ed installazione del programma. Se non presente troviamo all'interno della cartella i file configure e Makefile.in, dove il primo utilizza il secondo per creare il file Makefile.

Se quindi non dovesse essere presente il file Makefile bisognerebbe come prima cosa crearlo utilizzando

./configure

Dopodiché facciamo partire la compilazione del programma che andrà a creare i relativi file .o:

make

Ora non ci resta che installare i file creati concatenare

make install

In caso dovesse essere necessario ricompilare il programma possiamo utilizzare

make clean

per assicurarci che i file creati precedentemente vengano completamente ripuliti.

Le shared libraries

Le shared libraries sono delle librerie in formato di pezzi di programma

86/108


che possono essere utilizzate da più programmi. Per evitare che diversi programmi vadano a caricare più volte la stessa libreria all'interno della memoria di lavoro possiamo caricare le librerie un volta solamente ed effettuare un link per ogni altro programma che si aggiunge.Il programma gestito dal sistema che si occupa delle shared libraries è ld.so. E' lui che si occupa di verificare se delle librerie utilizzate sono già presenti all'interno della memoria oppure no.Questo programma controlla in seguito i seguenti punto per verificare l'esistenza di una libreria:

• Tutti i percorsi inseriti all'interno della variabile di ambiente LD_LIBRARY_PATH.

• Il contenuto del file binario /etc/ld.so.cache.• Le cartelle /usr/lib e /lib.

Per modificare la variabile di ambiente basta utilizzare le procedure spiegate precedentemente.

Per aggiornare il file binario /etc/ld.so.cache dobbiamo andare a modificare il file di configurazione /etc/ld.so.conf e far partire poi il comando ldconfig. In questa maniera il file binario /etc/ld.so.cache viene creato nuovamente in base alle impostazioni del file di configurazione.

Il programma che possiamo invece noi utilizzare per verificare di quali librerie a bisogno è ldd. Questo comando si utilizza come segue:

ldd /bin/ls

Come parametro va aggiunto il programma con il percorso completo.

87/108


INSTALLAZIONE DEL BOOTMANAGER

La procedura di BOOT di sistemi operativi a livello di hardware è molto chiaro. Il BIOS (Basic Input Output System) nei computer va a leggere il cilindro nr. 0 del disco dal quale deve essere effettuato il boot. Questo cilindro non fa parte delle partizioni presenti sul sistema, ma contiene ad esempio la tabella di partizionamento, che identifica l'inizio e la fine delle partizioni presenti. Ogni disco fisico ha all'interno della propria traccia 0 il Master Boot Record (MBR). All'interno del MBR (512 byte) troviamo normalmente un puntatore sulla prima partizione del disco e le relative informazioni di boot.

Ogni partizione del disco ha all'interno del proprio primo cilindro un settore di boot locale, che può contenere delle informazioni relative alla procedura di boot del sistema operativo contenuto in essa. Questa informazione è composta da un programma, il Bootstrag-Loader.

Se all'interno dello stesso sistema sono presenti più sistemi operativi possiamo installare sul MBR un piccolo programma che permette di scegliere all'utente con che sistema operativo partire. Questo programma è il Bootmanager.

Per anni Linux utilizzava il programma lilo (Linux Loader) che poi ha lasciato il posto al più noto grub (Grand Unified Bootloader) arrivato

88/108


attualmente alla versione 2.

L'installazione di grub

Il bootloader grub inserisce all'interno del MBR un puntatore che a sua volta indica sul programma di grub. Il programma grub si occupa poi di generare il rispettivo menù di partenza con le impostazioni presenti nel file di configurazione /boot/grub/grub.cfg. Questo file non va modificato manualmente, ma viene aggiornato automaticamente dal sistema nel momento in cui avvengono dei cambiamenti lato kernel, oppure se viene eseguito dall'utente il seguente programma

update-grub

Nel caso in cui non fosse presente la versione 2 di grub all'interno del sistema che stiamo utilizzando possiamo installarla con il pacchetto grub-pc.

I file di configurazione

Il file di configurazione del bootmanager grub è /boot/grub/grub.cfg che come detto precedentemente non va modificato manualmente. Questo file fa partire una serie di file di configurazione presenti all'interno della cartella

/etc/grub.d/

All'interno di questa cartella troviamo il file 40_custom che può essere utilizzato dall'utente per personalizzare e/o aggiungere punti di boot non riconosciuti automaticamente dal sistema.

Inoltre abbiamo a disposizione anche il file /etc/default/grub che permette di settare la configurazione dello stesso menu. Vediamo qui di seguito una serie di possibili impostazioni:

• GRUB_DEFAULT=0Identifica con quali delle voci all'interno del menù di avvio partire se non viene scelto altro da parte dell'utente. Può essere utilizzato anche GRUB_DEFAULT=saved per utilizzare l'ultima opzione di default utilizzata.

• GRUB_HIDDEN_TIMEOUT=3Se non è configurata la visualizzazione del menu questo parametro permette di definire per quanti secondi il bootmanager rimane in attesa di visualizzazione a schermo vuoto. Un eventuale countdown può essere visualizzato mediante GRUB_HIDDEN_TIMEOUT_QUIET.

89/108


• GRUB_TIMEOUT=10Per quanti secondi deve aspettare il bootmanager prima di far partire il sistema settato con il valore di default.

• root hdn,mCon la sigla hdn,m si identifica un disco fisso dove n indica il numero del disco fisso mentre m identifica il numero della partizione partendo dal numero 0 (/dev/hda2 diventerebbe hd0,1).All'interno del parametro root la voce hdn,m identifica la partizione che contiene la cartella /boot.

• kernel immagine_kernel parametriQuesta opzione identifica il file bzImage che contiene il Kernel. Come parametro possiamo inserire anche la voce root che ci permette di assegnare il device file all'interno del quale troviamo il root filesystem, es.kernel (hd0,1)/boot/bzImage-2.6.14 root=/dev/hda2

• initrd immagine_ramdiskPermette di inserire la ramdisk utilizzata dal Kernel. Se non utilizzata un'immagine ramdisk questa riga viene lasciata via completamente.

• GRUB_SAVEDEFAULT=truePermette di salvare l'opzione scelta come default.

• bootPermette di eseguire il boot delle opzioni scelte.

Personalizzare punti di boot

I punti di boot vengono inseriti manualmente dall'utente all'interno del file /etc/grub.d/40_custom. Ogni voce di menu è identificata dal blocco menuentry composta dal nome da visualizzare ed il blocco dei comandi tra parentesi graffe come segue:

menuentry “Mio personale” { set root='(hd0,1)' linux /boot/vmlinuz-3.2.0-24-generic root=UUID=dbd69ed2-530c-4409-8f5a-a3f1ea41fc67 ro initrd /boot/initrd.img-3.2.0-24-generic }

Nell'esempio vediamo i seguenti comandi:• set root='(hdn,m)'

Con la sigla hdn,m si identifica un disco fisso dove n indica il numero del disco fisso mentre m identifica il numero della partizione partendo dal numero 0 (/dev/hda2 diventerebbe hd0,1).All'interno del parametro root la voce hdn,m identifica la partizione che contiene la cartella /boot.

• linux immagine_kernel parametriQuesta opzione identifica il file bzImage che contiene il Kernel. Come parametro possiamo inserire anche la voce root che ci permette di assegnare il device file all'interno del quale troviamo il

90/108


root filesystem.• initrd immagine_ramdisk

Permette di inserire la ramdisk utilizzata dal Kernel. Se non utilizzata un'immagine ramdisk questa riga viene lasciata via completamente.

Punti di boot con nome utente e password

I punti di boot possono essere configurati in maniera tale da essere accessibili solamente da particolari utenti con dedicate password. Questi utenti non hanno a che fare con gli utenti del sistema, ma vengono inseriti manualmente all'interno del file /etc/grub.d/00_header aggiungendo le seguenti righe:

cat << EOFset superusers='user1'password user1 password1password user2 password2EOF

In questo caso abbiamo un utente amministratore, ossia user1, ed un altro utente mormale user2. Una volta configurati gli utenti definiti all'interno del sistema grub dobbiamo indicare quale utente ha la possibilità di accedere a quale punto di boot.

Al blocco del relativo menuentry dobbiamo quindi aggiungere il parametro --users con l'elenco degli utenti (separati da una virgola) che hanno accesso al punto di boot.

menuentry 'Punto prova' --users user2,user3 { ...}

In questo caso solo l'amministratore e i due utenti indicati potranno accedere al relativo sistema.

91/108


GESTIONE DEL KERNEL E DEI SUOI MODULI

Il Kernel Linux delle prime versioni (la versione 1.x.x) era strutturato in maniera monolitica. Il Kernel conteneva tutti i componenti software necessari al corretto funzionamento di una macchina. Non potendo modificare questi componenti a Kernel compilato era necessaria la ricompilazione ad ogni modifica hardware. I tentativi di creare dei Kernel molto grossi compresi di tutti i driver necessari per il funzionamento di qualsiasi architettura non è stata una soluzione utilizzabile a livello pratico.

Per questo motivo il Kernel è stato creato in maniera modulare. Questo vuol dire che non è più necessario riempire il Kernel di tutti i componenti utilizzati al momento della compilazione, ma che possono essere aggiunti o tolti a piacere anche a compilazione eseguita. In questo modo diventa più semplice la manutenzione dei componenti hardware. I driver possono essere aggiunti esternamente e rimpiazzati con i nuovi driver in caso di sostituzione del hardware. Tutti componenti software che possono essere aggiunti al Kernel anche dopo la compilazione vengono chiamati moduli del Kernel.

I moduli del Kernel di un sistema Linux vengono salvati nella cartella /lib/modules/[versione del Kernel] dove [versione del Kernel] è la versione del Kernel per il quale sono stati aggiunti dei moduli.

92/108


I moduli del Kernel fanno naturalmente parte del Kernel stesso. Nell'utilizzo dei moduli è molto importante tenere conto delle dipendenze dei moduli. Aggiungere il modulo che gestisce i SCSI-CDROM senza aggiungere anche il modulo che gestisce le connessioni SCSI non potrebbe funzionare. Proprio per questo motivo esiste il programma depmod che permette di analizzare le dipendenze di tutti i moduli.La funzione di questo comando è quella di creare il file /lib/modules/[versione del Kernel]/modules.dep che contiene le dipendenze di tutti i moduli attualmente disponibili per il relativo Kernel.Questo programma viene utilizzato anche all'avvio del sistema per essere sicuri delle dipendenze dei moduli utilizzati dal Kernel.

Lista dei moduli caricati

Il programma per visualizzare la lista dei moduli attualmente caricati è lsmod. Visualizza tutti i moduli caricati in formato nome, dimensione, numero delle volte che è stato utilizzato e la lista dei moduli dai quali il rispettivo dipende. Il programma lsmod viene utilizzato senza aggiunta di parametri.

Caricare singoli moduli

Per caricare singoli moduli può essere utilizzato il programma insmod. Questo programma utilizza come unico parametro il nome del modulo da caricare senza il .o finale ne indicazione sul percorso da utilizzare per trovare il medesimo. E' il programma stesso che sa esattamente dove andare a cercare il moduli richiesto. Se volessimo aggiungere il modulo per le stampanti usb basterebbe inserire il comando

insmod printer

che a sua volta caricherebbe il modulo /lib/modules/[versione del Kernel]/drivers/usb/printer.o. Per identificare la giusta posizione di un modulo viene utilizzato il contenuto di modules.dep creato con il programma depmod.

Se dovesse essere necessario caricare un modulo utilizzando dei parametri per il giusto funzionamento (es. schede ISA) possiamo aggiungerli direttamente con il programma insmod come segue

insmod ne io=0x300 irq=5

Questo programma viene quindi utilizzato per caricare i moduli desiderati. Quello che non viene fatto utilizzando questo programma è

93/108


caricare automaticamente eventuali moduli dai quali dipende il corretto funzionamento del modulo desiderato. Viene quindi solamente installato il modulo richiesto.

Caricare moduli e dipendenze con un unico comando

Il programma che viene utilizzato per caricare un modulo con tutti i moduli necessari al suo giusto funzionamento è modprobe. Questo ha infatti rimpiazzato completamente il programma insmod. Questo programma va a leggere tutte le dipendenze di un eventuale modulo da caricare dal file modules.dep caricandole a sua volta. Inoltre si ha la possibilità di utilizzare anche un file di configurazione per assegnare direttamente i parametri necessari per i moduli da caricare. Il file utilizzato è /etc/conf.modules (vecchie versioni) oppure /etc/modules.conf (nuove versioni)

All'interno di questo file di configurazione possiamo trovare la voce options, che permette di identificare i parametri necessari al caricamento di un modulo, alias, per identificare un modulo utilizzando un altro nome, pre-install, per eseguire dei comandi prima dell'installazione del modulo, post-install, per eseguire dei comandi dopo l'installazione del modulo, pre-remove, per eseguire dei comandi prima della rimozione del modulo e post-remove, per eseguire dei comandi dopo la rimozione del modulo.

Rimuovere moduli caricati

Per rimuovere dei moduli è possibile utilizzare il programma rmmod. Questo però non permette di eliminare moduli attualmente in esecuzione. Eseguendo il rmmod con il parametro -r si avrà l'effetto contrario di modprobe, ossia non verrà solamente rimosso il modulo desiderato, ma tutti quelli dai quali egli dipende.

Quali parametri utilizzare con un modulo

Per identificare tutti i parametri utilizzabili con un modulo si può lanciare il programma modinfo. Questo infatti ci permette di elencare determinate informazioni del relativo nome passato come parametro senza .o finale e senza percorso. Le informazioni che vengono elencate sono le seguenti:

• Nome del file e percorso (-n)• Descrizione (-d)• Autore (-a)

94/108


• Licenza (-l)• Parametri (-p)

Il comando uname

Questo programma viene utilizzato per identificare la versione del Kernel che si sta utilizzando. Il programma viene utilizzato come segue:

uname -r

Per spostarci direttamente all'interno della cartella dei moduli del Kernel che stiamo attualmente utilizzando possiamo scrivere:

cd /lib/modules/`uname -r`/kernel

Per visualizzare tutte le informazioni a disposizione possiamo utilizzare il parametro -a.

95/108


LA CONFIGURAZIONE, LA COMPILAZIONE E

L'INSTALLAZIONE DI UN KERNEL

Una delle caratteristiche di Linux, che lo differenzia da praticamente tutti gli altri sistemi operativi è la possibilità di scaricare da Internet anche tutto il sorgente del Kernel, che ci permette di compilare, se necessario, un Kernel adatto alle nostre esigenze.Il Kernel può essere scaricato dal sito http://www.kernel.org.

Configurare il proprio Kernel

Il Kernel scaricato da Internet nel formato .tar.gz oppure .bz2. deve essere come prima cosa decompresso utilizzando l'apposito comando (ad esempio tar) con relativi parametri.Per la corretta compilazione è indispensabile che il contenuto della cartella decompressa si trovi in /usr/src/linux. Possiamo quindi decomprimere la cartella e copiare poi il contenuto nella nuova cartella /usr/src/linux creata, oppure creare un link simbolico che punti sulla cartella che contiene il sorgente del Kernel che vogliamo compilare.

96/108

http://www.kernel.org/


Per poter iniziare la compilazione del Kernel ed eseguirla in maniera corretta e adeguata alle nostre esigenze dobbiamo naturalmente avere anche la possibilità di configurare quelli che saranno i moduli integrati nel Kernel e i moduli invece collegati e caricati dal Kernel in un secondo momento. I programmi che possiamo utilizzare per eseguire questo tipo di configurazione sono:

• make menuconfig: utilizzato per la configurazione del Kernel all'interno di una shell.

• make xconfig: utilizzato invece per la configurazione del Kernel sotto xwindow.

Entrambi i comandi leggono il file /usr/src/linux/.config (se esistente) e presentano in questo modo una configurazione standard per la compilazione del Kernel all'interno della quale possiamo attivare, disattivare o collegare esternamente determinati moduli. Al termine della configurazione i comandi vanno a sovrascrivere il medesimo file con le nuove impostazioni.Al termine della configurazione del Kernel avremo quindi il file /usr/src/linux/.config che conterrà le necessarie indicazioni per la compilazione del Kernel.

Il file di configurazione appena citato potrebbe variare dal punto di vista del formato o dei suoi contenuti in base alla versione del Kernel utilizzato. Nuovi Kernel infatti potrebbero utilizzare altre o diverse impostazioni rispetto a Kernel precedenti. Per questo motivo possiamo utilizzare il comando

make oldconfig

che ci permette di aggiornare vecchi file di configurazione per poterli riutilizzare nella compilazione di nuovi Kernel. Prima di eseguire questo comando però è indispensabile copiare il vecchio file di configurazione all'interno della cartella /usr/src/linux e rinominarlo in .config. Dopo aver fatto partire il comando sopra citato verranno effettuate delle domande in base alle novità presenti all'interno del nuovo Kernel.

Compilazione del Kernel e dei suoi moduli

Per iniziare la compilazione del Kernel utilizziamo il comando

make bzImage

che andrà a creare il Kernel compilato e compresso /usr/src/linux/arch/i386/boot/bzImage.

97/108


Dopo aver compilato il Kernel utilizziamo

make modules

per compilare anche tutti i moduli selezionati ed esterni al Kernel.

Ora non ci rimane che installare, ossia, copiare i moduli compilati all'interno della cartelle /lib/modules/[versione Kernel] con il comando

make modules_install

Questo comando avvia a sua volta il comando depmod per creare il file contenente le dipendenze dei moduli /lib/modules/[versione Kernel/modules.dep.

Attivazione del Kernel

Ora il Kernel ed i porpri moduli sono stati compilati ed installati, ma il sistema non è ancora in grado di riconoscere il nuovo Kernel che abbiamo creato. Per metterlo a disposizione dell'interno sistema dobbiamo ancora eseguire alcuni passi.

Come prima cosa dobbiamo copiare il file /usr/src/linux/arch/i386/boot/bzImage all'interno della cartella /boot e possiamo darli un nuovo nome, per esempio bzImage-[versione Kernel].

Poi copiamo anche il file /usr/src/linux/System.map mettendolo sempre all'interno della cartella /boot utilizzando il nome System.map-[versione Kernel]. Il nome di questo file è molto importante.

In fine non dobbiamo fare altro che creare una nuova voce all'interno del bootmanager che stiamo utilizzando inserendovi il percorso per raggiungere il nuovo Kernel che abbiamo creato, ossia /boot/bzImage-[versione Kernel].

98/108


AMBIENTE SHELL E SEMPLICI SCRIPT

Vedremo qui di seguito i file utilizzabile per la personalizzazione dell'ambiente shell di un utente o di tutti gli utenti presenti all'interno del nostro sistema. Infine vedremo alcune indicazioni necessarie per sviluppare dei piccoli script di shell.

Ambiente shell.

Login-shell oppure NoLogin-shell.Linux fa una differenza tra shell che vengono visualizzate direttamente dopo il login oppure shell che vengono fatte partire all'interno di un'altra shell. Le shell fatte partire direttamente dopo il login vengono chiamate login-shell, mentre le altre vengono chiamate NoLogin-shell.La distinzione viene fatta perché le login-shell necessitano di una configurazione iniziale, mentre le altre no. Una NoLogin-shell può ereditare le variabili settate all'interno della shell principale.

Il comando alias.Con il comando alias abbiamo la possibilità di identificare un nome alias per eseguire determinati comandi.

$ alias ls=”ls -al”

99/108


Dopo questa riga di comando inserendo ls verrebbe visualizzato il risultato di ls -al. Per liberare una sigla memorizzata con alias possiamo utilizzare il comando unalias seguito dalla sigla.

I file di configurazione della bash.Per settare dei parametri a livello di shell possiamo utilizzare i file di configurazione.

/etc/profileQuesto file ci permette identificare le impostazioni per ogni utente che effettua il login all'interno del nostro sistema. Questo file può essere modificato solamente dall'amministratore del sistema.

.bash_profile, .bash_login oppure .profileQuesti file possono essere presenti all'interno di ogni home directory. Ogni utente ha la possibilità mediante questi file di personalizzare la propria shell. Se presenti il sistema cerca di elaborarli a login effettuato.

.bashrcQuesto file, sempre presente all'interno della home directory, permette di impostare la situazione delle NoLogin-shell.

Le variabili di ambiente

Le variabili che vengono utilizzate all'interno della shell vengono chiamate “variabili di ambiente”. Il contenuto di ogni variabile di ambiente può essere visualizzato mediante il seguente comando:

echo ${nome della variabile}

La variabile di ambiente PATHLa variabile di ambiente forse più nota è PATH. Quando viene inserito un commando all'interno del prompt dei comandi e la shell non è in grado di trovarlo inizialmente, deve avere la possibilità di effettuare una ricerca per trovare la posizione del comando inserito. Effettuare una ricerca all'interno dell'intero sistema sarebbe un'operazione impegnativa ed inutile, dato che i comandi si trovano all'interno di directory ben precise.La shell utilizza quindi i vari percorsi elencati e separati dai due punti (:) all'interno della variabile PATH per trovare il comando che abbiamo inserito. Se la ricerca va a buon fine il programma viene eseguito altrimenti viene restituito un messaggio di errore (“command not found”).

Le cose importanti da sapere per quanto riguarda questa variabile sono

100/108


le seguenti:

• Questa variabile non include per default la directory presente. Se creiamo ad esempio un file eseguibile all'interno della nostra home directory e da qui vogliamo farlo partire la shell non sarà in grado di trovarla. Per poterlo eseguire sarà necessario l'inserimento dell'intero percorso prima del comando stesso in modo da comunicare alla shell l'esatta posizione del comando (o semplicemente aggiungere il punto (.) come identificativo della directory attuale), l'inserimento del percorso per arrivare alla nostra home directory direttamente all'interno della variabile di ambiente PATH, oppure spostare il comando all'interno di una directory già presente all'interno di PATH.

• I percorsi inseriti all'interno di questa variabile sono separati da due punti (:).

• E normale amministrazione elencare come primi i percorsi delle directory che contengono eseguibili più comuni (le directory bin) e come secondi i percorsi specifici utilizzati dagli utenti

Per aggiungere un nuovo percorso all'interno di questa variabile è possibile ridefinire l'intero contenuto o semplicemente aggiungere la parte nuova come segue:

PATH=$PATH:/home/ferrazzi

Questo comando aggiunge infatta la nuova directory /home/ferrazzi agli altri percorsi già presenti in PATH.

La variabile di ambiente MAILQuesta contiene la directory utilizzata per la posta elettronica.

La variabile di ambiente HOMEQuesta contiene la directory nella quale ci si trova dopo aver effettuato il login che è la stessa nella quale ci troviamo dopo aver utilizzato il comando cd senza parametri aggiuntivi.

La variabile di ambiente LINESQuesta contiene il numero delle righe che vengono visualizzate dal programma more (programma per la visualizzazione di file di testo) prima che venga bloccato lo scorrimento.

La variabile di ambiente LOGNAMEQuesta contiene il nome con il quale l'utente si è connesso al sistema.

La variabile di ambiente PWDQuesta contiene la directory nella quale ci si trova attualmente.

101/108


La variabile di ambiente SHELLQuesta contiene l'interprete che stiamo utilizzando.

La variabile di ambiente TERMQuesta contiene il tipo di terminale o il tipo di emulazione che si sta utilizzando.

Il contenuto di ogni variabile può essere modificato a piacere o si possono creare nuove variabili di ambiente utilizzando la seguente sintassi:

{nome della variabile}={nuovo contenuto}

Per creare ad esempio una nuova variabile TODAY basta digitare come segue:

TODAY=Sabato

Ora è naturalmente possibile visualizzare il contenuto utilizzando il comando:

echo $TODAY

Il risultato in questo caso è Sabato. Per render accessibile questa variabile anche da sottocicli (“subroutines”) e sottoprocessi (“child processes”) bisogna utilizzare il comando export:

export TODAY

Il contenuto di questa variabile sarà disponibili durante la durata della sessione. Una volta effettuato il logout questa variabile andrà persa.

Per modificare il contenuto di una variabile esportata la procedura è uguale a quella vista precedentemente:

TODAY=Lunedi

Data l'esportazione precedente della variabile il nuovo contenuto verrà immediatamento reso disponibile anche ai sottocicli ed ai sottoprocessi.

Se si dovesse presentare la necessita di eliminare una variabile di ambiente si può utilizzare il comando unset.

Semplici script.

Vedremo in breve quali caratteristiche hanno gli script di shell e quali comando possiamo utilizzare.

102/108


Principi di base.Uno scirpt di shell in principio non è niente altro che un file di testo che contiene dei comandi. Per far capire al sistema che si tratta di file script inseriamo come prima riga all'interno del file l'indicazione della shell che vogliamo utilizzare:

#!/bin/bash

Una volta salvato il nostro script dobbiamo ricordarci di modificare i permessi di esecuzione del file altrimenti non ci sarebbe possibile eseguire il file come script file.

chmod +x script1

I parametri a riga di comando.Uno script viene fatto partire come un normale programma. Dopo il nome dello script da eseguire possiamo aggiungere dei parametri da utilizzare all'interno dello script, per esempio:

$ ./somma 12 22

In questo caso somma è il nome dello script mentre 12 e 22 sono i parametri. All'interno dello script possiamo utilizzare le variabili $1, $2, ... per identificare il valore del primo, secondo, ... parametro inserito. $0 identifica il nome dello script che abbiamo eseguito.Il contenuto dello script file somma potrebbe essere il seguente:

#!/bin/bashlet totale=$1+$2echo $1 sommato a $2 è uguale a $totale

Questo script restituisce come risultato la somma di due numeri che vengono inseriti come parametri dello script.

Le variabili speciali che possono essere utilizzati all'interno di uno script sono:

$@ identifica tutti i parametri inseriti (“$1” “$2” “$3” ...)$* identifica tutti i parametri inseriti (“$1 $2 $3 ...”)$# identifica il numero dei parametri inseriti

Il comando shift.Questo comando sposta tutti i parametri di una posizione verso sinistra. Avendo quindi le variabili con i valori:

103/108


$1 = 0$2 = 1$3 = 2

Dopo il comando shift abbiamo:

$1 = 1$2 = 2

L'ultima variabile viene eliminata.

Controllo di flusso if.Questo comando ci dà la possibilità di andare a modificare il flusso del programma in caso si verifichino delle situazioni specifiche.

if comandothen azione azionefi

Se comando restituisce una situazione vera vengono eseguite le azioni altrimenti no. Come comando viene utilizzato di solito test che vediamo qui sotto.

Il comando test.Questo comando permette di eseguire determinati controlli restituendo poi un valore vero o falso che può essere interpretato ad esempio dal controllo di flusso if.

Questo comando può essere utilizzato in due modi diversi

if test ...

oppure

if [ ... ]

dove è molto importante mettere gli spazi vuoti dopo la '[' e prima della ']'.Le operazioni da utilizzare con il test sono le seguenti:

-r fileIl file esiste ed è leggibile

-w fileIl file esiste ed è scrivibile

-x file

104/108


Il file esiste ed è eseguibile-d file

Il file esiste ed è una cartella-s file

Il file esiste e non è vuoto-b file

Il file esiste e identifica un'unità a blocchi-c file

Il file esiste e identifica un'unità a caratteri -g file

Il file esiste e ha il SGID-Bit attivato-k file

Il file esiste e ha lo sticky-Bit attivato-u file

Il file esiste e ha il SUID-Bit attivato-e file

Il file esiste-f file

Il file esiste ed è un file regolare-L file

Il file esiste ed è un link simbolico-S file

Il file esiste ed è un socket-O file

Il file esiste e appartiene all'utente che ha fatto partire lo script-G file

Il file esiste e appartiene al gruppo che ha fatto partire lo scriptfile1 -nt file2

file1 è più nuovo di file2file1 -ot file2

file1 è più vecchio di file2file1 -ef file2

file1 e file2 hanno la stessa inode-z stringa

La stringa è nulla-n stringa

La stringa è diversa da nullstringa1 = stringa2

Le stringhe sono ugualistringa1 != stringa2

Le stringhe non sono ugualivalore1 -eq valore2

I valori sono ugualivalore1 -ne valore2

I valori non sono ugualivalore1 -gt valore2

valore1 è più grande di valore2valore1 -ge valore2

105/108


valore1 è più grande o uguale al valore2valore1 -lt valore2

valore1 è più piccolo di valore2valore1 -le valore2

valore1 è più piccolo o uguale al valore2

Controllo di flusso if-else.Il comando if si può utilizzare anche con una forma estesa, ossia

if [ operazione ]then comandielse comandifi

Se operazione è vera viene eseguito il primo blocco di comandi altrimenti viene eseguito il secondo blocco.

Controllo di flusso if-elif-else.Questa è un altro possibile utilizzo del comando if

if [ operazione ]then comandielif [ operazione ]then comandielse comandifi

Scelta multipla con case.Il blocco case permette di verificare lo stato di una variabile e comportarsi di conseguenza. La differenza tra if e case è che con case possiamo identificare più stati della variabile.

case variabile in controllo1) comando1 ;; controllo2) comando2 ;; controllo3) comando3 ;; ...esac

Se la variabile corrisponde a controllo1 viene eseguito comando1, se

106/108


corrisponde a controllo2 viene eseguito comando2, se corrisponde a controllo3 viene eseguito comando3. I comandi relativi ai controlli non corrispondenti vengono saltati.

Il ciclo while.Questo ciclo esegue i comandi fino a che l'operazione restituisce un valore vero.

while [ operazione ]do comandidone

Il ciclo for.Questo ciclo esegue i comandi dando alla variabile il valore degli elementi di una lista. Ad ogni ciclo il valore della variabile cambia acquistando il valore del prossimo elemento della lista. Il ciclo termina quando non ci sono più elementi all'interno della lista.

for variabile in listado comandidone

Esempio

#!/bin/bashfor i in Franco Toni Albertodo echo $idone

Questo script restituisce i tre nomi uno sotto l'altro.

Le funzioni.All'interno di uno script possono essere utilizzate anche delle funzioni. Le funzioni ci permettono di programmare dei blocchi richiamati da più parti dello stesso script evitando così di avere blocchi uguali all'interno dello stesso programma. Esempio:

#!/bin/bash

function scrivi(){ echo $1}

107/108


read -p “Valore: “ numeroscrivi $numero;

Con il comando read -p il programma ci chiede di inserire un valore. Il valore viene memorizzato all'interno della variabile numero e passato poi come parametro alla funzione scrivi. All'interno della funzione utilizziamo la variabile fissa $1 che ci permette di richiamare il valore del parametro mandato alla funzione (quindi non più il parametro dello script).

108/108

gnu/linux debian/ubuntu - ferrazzi · gnu/linux proprio per questo motivo. the gnu general public...

Documents