Gentoo Logo

Disclaimer : La versione originale di questo articolo è stata pubblicata da IBM developerWorks ed è di proprietà di Westtech Information Services. Questo documento è una versione aggiornata dell'articolo originale, e contiene numerosi miglioramenti apportati dal Gentoo Linux Documentation team.
Questo documento non è mantenuto attivamente.


Preparazione all'esame per la Certificazione LPI 101 (release 2), Parte 1

Indice:

1.  Prima di iniziare

Riguardo a questa introduzione

Benvenuti in "fondamenti di Linux", la prima di quattro brevi guide concepite per preparare il lettore all'esame 101 del Linux Professional Institute. In questa breve guida sarà data un'introduzione su bash (la shell predefinita in Linux) al lettore, verrà mostrato come ottenere pieno vantaggio da comandi di base in Linux come ls, cp e mv, saranno spiegati gli inodes e sia hard link che link simbolici e tanto altro ancora. Alla fine di questa introduzione, il lettore avrà una base solida sui fondamenti di Linux e sarà anche pronto per iniziare ad imparare alcuni processi basilari riguardo all'amministrazione di sistemi Linux. Al termine di questa serie di guide introduttive (otto in tutto), il lettore avrà la conoscenza necessaria per diventare un Amministratore di Sistema Linux e sarà pronto per raggiungere la Certificazione LPIC di Livello 1 del Linux Professional Institute se lo desidera.

Questa guida in particolare (Parte 1) è ideale per coloro che sono nuovi a Linux o per chi vuole rinfrescare o perfezionare la propria comprensione dei concetti fondamentali di Linux come la copia e lo spostamento di file, la creazione di hard link e link simbolici e l'uso di comandi di base per processare del testo insieme alle pipeline e la ridirezione. Lungo la strada, verranno forniti un gran numero di consigli, suggerimenti e trucchi per rendere questa introduzione carnosa e pratica, anche per coloro che hanno un buon numero di precedenti esperienze con Linux. Per i principianti, molto di questo materiale sarà nuovo, ma gli utenti Linux con più esperienza potrebbero trovare questa breve guida un bel modo per affinare le loro abilità sui fondamenti di Linux.

Per chi fosse già in possesso della versione di rilascio 1 di questa guida per altre ragioni oltre alla preparazione dell'esame del LPI, probabilmente non sarà necessario prendere anche questa. Comunque, se si pianifica di sostenere gli esami, dovrebbe essere decisamente presa in considerazione la lettura di questa versione rivista della guida.

Riguardo all'autore

Residente in Albuquerque, New Mexico, Daniel Robbins è l'Architetto Capo di Gentoo Linux, un'avanzata meta distribuzione Linux basata su sorgenti. Ha anche scritto articoli, brevi guide e suggerimenti nell'area dedicata a Linux dell'IBM developerWorks e per l'Intel Developer Services e ha anche preso parte come autore di contributi per diversi libri, incluso Samba Unleashed e SuSE Linux Unleashed. Daniel si diverte passando il proprio tempo con sua moglie, Mary, e sua figlia, Hadassah. È possibile contattare Daniel all'indirizzo Daniel Robbins

2.  Introduzione a bash

La shell

Chi ha usato un sistema Linux, saprà che al momento dell'accesso gli viene dato il benvenuto da un prompt che assomiglia in qualche modo al seguente:

Codice 2.1: Il prompt

$

Il particolare prompt che verrà mostrato a seconda dei casi potrebbe essere abbastanza diverso. Potrebbe contenere il nome dell'host dell'utente, il nome dell'attuale cartella di lavoro o entrambi. Ma comunque si presenti il proprio prompt, una cosa è certa: il programma che stampa il detto prompt è chiamato "shell" ed è molto probabile che questa particolare shell sia un programma chiamato bash.

Controllare se bash è in esecuzione

È possibile controllare se si sta eseguendo bash digitando:

Codice 2.2: La variabile SHELL

$ echo $SHELL
/bin/bash

Se la linea precedente restituisce un errore o non risponde in modo simile all'esempio, potrebbero essere in esecuzione una shell differente da bash. In questo caso, gran parte di questa breve guida potrebbe ancora essere applicabile ma sarebbe vantaggioso per il lettore passare a bash nell'interesse di prepararsi per l'esame 101.

Riguardo a bash

Bash, un acronimo per "Bourne-again shell", è la shell predefinita su molti sistemi Linux. Il compito della shell è quello di obbedire ai comandi dell'utente così che questo possa interagire col proprio sistema Linux. Quando termina l'inserimento dei comandi, è possibile istruire la shell per l'uscita o logout, nel qual caso sarà presentato nuovamente il prompt di login.

Tra l'altro, è possibile anche effettuare il logout premendo control-D nel prompt di bash.

Usare "cd"

Come qualcuno avrò probabilmente notato, fissare il prompt di bash non è la cosa più eccitante su questa terra. Quindi, è ora di iniziare ad usare bash per navigare all'interno del proprio filesystem. Al prompt, digitare quanto segue (senza il $):

Codice 2.3: Cambiare cartella

$ cd /

In questo modo bash viene informato del fatto che si desidera lavorare in /, anche conosciuta come cartella radice (o root); tutte le cartelle sul sistema formano un albero e / è considerata la cima di questo albero, o la radice. Il comando cd imposta la cartella dove l'utente andrà a lavorare al momento, detta anche "cartella di lavoro corrente".

Percorsi

Per scoprire la cartella di lavoro corrente di bash, basta digitare:

Codice 2.4: Cartella di lavoro attuale

$ pwd
/

Nell'esempio precedente, l'argomento / passato a cd è chiamato percorso (o path). Indica a cd dove l'utente vuole andare. In particolare, l'argomento / è un percorso assoluto, ovvero significa che questo specifica una locazione relativa alla radice dell'albero del filesystem.

Percorsi assoluti

Di seguito alcuni ulteriori percorsi assoluti:

Codice 2.5: Esempi riguardo ai percorsi

/dev
/usr
/usr/bin
/usr/local/bin

Come si può notare, una cosa che tutti i percorsi assoluti hanno in comune è il fatto che iniziano con /. Con il percorso /usr/local/bin, viene detto a cd di accedere alla cartella /, quindi la cartella usr all'interno di essa e poi local e bin. I percorsi assoluti sono sempre valutati partendo con / all'inizio.

Percorsi relativi

L'altro tipo di percorso è chiamato percorso relativo. Bash, cd e altri comandi interpretano sempre questi percorsi relativi dalla cartella corrente. I percorsi relativi non iniziano mai con un /. Quindi, se chi opera è in /usr:

Codice 2.6: Cambiare cartella con percorsi assoluti

$ cd /usr

Poi, sarà possibile usare un percorso relativo per passare nella cartella /usr/local/bin:

Codice 2.7: Cambiare cartella con percorsi relativi

$ cd local/bin
$ pwd
/usr/local/bin

Usare ..

I percorsi relativi possono anche contenere una o più cartelle .. . La cartella .. è una cartella speciale che punta alla cartella precedente (o parente). Perciò, continuando dall'esempio precedente:

Codice 2.8: Usare la notazione 'cartella parente'

$ pwd
/usr/local/bin
$ cd ..
$ pwd
/usr/local

Come si può notare, la cartella corrente è ora /usr/local. L'utente è così capace di andare "indietro" di una cartella, relativamente alla cartella in cui si trova attualmente.

In aggiunta, è possibile anche aggiungere .. ad un percorso relativo esistente, permettendo così di spostarsi in una cartella che è di fianco a quella in cui siamo già, per esempio:

Codice 2.9: Usare la notazione cartella parente nei percorsi relativi

$ pwd
/usr/local
$ cd ../share
$ pwd
/usr/share

Esempi di percorsi relativi

I percorsi relativi possono diventare abbastanza complessi. Di seguito vengono proposti alcuni esempi, tutti senza mostrare la cartella destinazione risultante. Il lettore è invitato a cercare di capire dove andrà a finire dopo aver digitato questi comandi:

Codice 2.10: Esempi di percorsi relativi

$ cd /bin
$ cd ../usr/share/zoneinfo


$ cd /usr/X11R6/bin
$ cd ../lib/X11


$ cd /usr/bin
$ cd ../bin/../bin

Ora, non resta che provarli e assicurarsi di avere indovinato.

Capire .

Prima di terminare la discussione in merito a cd, ci sono altre poche cose che meritano una menzione. Primo, c'è un'altra cartella speciale chiamata . , che indica "la cartella corrente". Mentre questa cartella non è usata con il comando cd, viene spesso utilizzata per eseguire alcuni programmi nella cartella corrente, come segue:

Codice 2.11: Eseuire un programma dalla posizione corrente

$ ./mio_prog

Nell'esempio precedente, l'eseguibile mio_prog che risiede nella cartella di lavoro corrente verrà eseguito.

Il comando cd e la cartella home

Per chi vuole spostarsi nella propria cartella home, può digitare:

Codice 2.12: Andare nella cartella HOME

$ cd

Senza argomenti, cd condurrà l'utente nella propria cartella home, che corrisponde a /root per l'utente principale (superuser) e tipicamente a /home/nome_utente per utenti normali. Vediamo come è possibile specificare un file all'interno della propria cartella home. Probabilmente per passare un file come argomento a mio_prog. Se il file risiede nella propria cartella home, basta digitare:

Codice 2.13: Eseguire un programma nella cartella corrente

$ ./mio_prog /home/drobbins/mio_file.txt

Comunque, usare un percorso assoluto come questo non è sempre conveniente. Fortunatamente, è possibile usare il carattere ~ (tilde) per fare la stessa cosa:

Codice 2.14: Usare la notazione 'cartella home'

$ ./mio_prog ~/mio_file.txt

Le cartelle home degli altri utenti

Bash espanderà da solo ~ per puntare alla cartella home dell'utente, ma è possibile anche usarlo per puntare alle cartelle home di altri utenti. Per esempio, volendo riferirsi al file chiamato fred_file.txt nella cartella home di Fred, dovrà essere digitato:

Codice 2.15: Esempio di uso della notazione 'cartella home'

$ ./mio_prog ~fred/fred_file.txt

3.  Usare comandi Linux

Introduzione a ls

Adesso, sarà data un'occhiata veloce al comando ls. Molto probabilmente, il lettore sarà già familiare con ls e saprà che digitandolo da solo mostrerà la lista dei contenuti della cartella di lavoro corrente:

Codice 3.1: Recuperare la lista dei file

$ cd /usr
$ ls
X11R6      doc         i686-pc-linux-gnu  lib      man          sbin   ssl
bin        gentoo-x86  include            libexec  portage      share  tmp
distfiles  i686-linux  info               local    portage.old  src

Specificando l'opzione -a, verranno mostrati tutti i file nella cartella, compresi i file nascosti: quelli che iniziano con . . Come evidenzia il seguente esempio, ls -a rivela i collegamenti alle cartelle speciali . e .. :

Codice 3.2: Recuperare la lista dei file, inclusi quelli nascosti

$ ls -a
.      bin        gentoo-x86         include  libexec  portage      share  tmp
..     distfiles  i686-linux         info     local    portage.old  src
X11R6  doc        i686-pc-linux-gnu  lib      man      sbin         ssl

Recuperare la descrizione estesa delle cartelle

Esiste la possibilità di specificare o o più file o cartelle come argomenti del comando ls. Se viene specificato un file, ls mostrerà il dato file solamente. Se viene specificata una cartella, ls mostrerà i contenuti della cartella. L'opzione -l risulta davvero pratica quando vi sia la necessità di vedere i permessi, possessore, ora di modifica e informazioni sulla dimensione nel resoconto della propria cartella.

Nell'esempio che segue, verrà usata l'opzione -l per stampare a video una lista completa in merito alla cartella /usr.

Codice 3.3: Recuperare la lista dei file con tutte le informazioni

$ ls -l /usr
drwxr-xr-x    7 root     root          168 Nov 24 14:02 X11R6
drwxr-xr-x    2 root     root        14576 Dec 27 08:56 bin
drwxr-xr-x    2 root     root         8856 Dec 26 12:47 distfiles
lrwxrwxrwx    1 root     root            9 Dec 22 20:57 doc -> share/doc
drwxr-xr-x   62 root     root         1856 Dec 27 15:54 gentoo-x86
drwxr-xr-x    4 root     root          152 Dec 12 23:10 i686-linux
drwxr-xr-x    4 root     root           96 Nov 24 13:17 i686-pc-linux-gnu
drwxr-xr-x   54 root     root         5992 Dec 24 22:30 include
lrwxrwxrwx    1 root     root           10 Dec 22 20:57 info -> share/info
drwxr-xr-x   28 root     root        13552 Dec 26 00:31 lib
drwxr-xr-x    3 root     root           72 Nov 25 00:34 libexec
drwxr-xr-x    8 root     root          240 Dec 22 20:57 local
lrwxrwxrwx    1 root     root            9 Dec 22 20:57 man -> share/man
lrwxrwxrwx    1 root     root           11 Dec  8 07:59 portage -> gentoo-x86/
drwxr-xr-x   60 root     root         1864 Dec  8 07:55 portage.old
drwxr-xr-x    3 root     root         3096 Dec 22 20:57 sbin
drwxr-xr-x   46 root     root         1144 Dec 24 15:32 share
drwxr-xr-x    8 root     root          328 Dec 26 00:07 src
drwxr-xr-x    6 root     root          176 Nov 24 14:25 ssl
lrwxrwxrwx    1 root     root           10 Dec 22 20:57 tmp -> ../var/tmp

La prima colonna mostra informazioni sui permessi per ogni elemento della lista. Verrà spiegato come interpretare questa informazione a breve. La colonna che segue mostra il numero di collegamento di ogni oggetto del filesystem, che ignoreremo al momento ma su cui torneremo in seguito. La terza e quarta colonna mostrano il possessore e il gruppo, rispettivamente. La quinta colonna mostra la dimensione dell'oggetto. La sesta colonna è l'ora di "ultima modifica" o "mtime" dell'oggetto. L'ultima colonna è il nome dell'oggetto. Se il file è un collegamento simbolico, sarà mostrato un -> di seguito e il percorso a cui il collegamento simbolico punta.

Uno sguardo alle cartelle

Talvolta, c'è la necessità di dare un'occhiata ad una cartella, piuttosto che al suo interno. In questi casi, basterà specificare l'opzione -d, che dirà a ls di guardare ad ogni cartella di cui normalmente considererebbe il contenuto:

Codice 3.4: Recuperare informazioni sulle cartelle

$ ls -dl /usr /usr/bin /usr/X11R6/bin ../share
drwxr-xr-x    4 root     root           96 Dec 18 18:17 ../share
drwxr-xr-x   17 root     root          576 Dec 24 09:03 /usr
drwxr-xr-x    2 root     root         3192 Dec 26 12:52 /usr/X11R6/bin
drwxr-xr-x    2 root     root        14576 Dec 27 08:56 /usr/bin

Recupero delle informazioni ricorsivo e sugli inode

Quindi l'opzione -d può essere usata per rivolgersi ad una cartella, ma esiste anche l'opzione -Rper fare l'opposto: non limitarsi ad esplorare una cartella ma ricorsivamente visitare tutti i file e le cartelle in essa contenuti. Non sarà incluso alcun esempio di risultato per questa opzione (in quanto è normalmente voluminoso) ma il lettore potrebbe voler provare qualche comando come ls -R e ls -Rl per avere un'idea di come questi operano.

Infine, l'opzione -i di ls può venire usata per mostrate il numero di inode associato nel filesystem agli oggetti:

Codice 3.5: Recuperare informazioni sugli inode

$ ls -i /usr
   1409 X11R6        314258 i686-linux           43090 libexec        13394 sbin
   1417 bin            1513 i686-pc-linux-gnu     5120 local          13408 share
   8316 distfiles      1517 include                776 man            23779 src
     43 doc            1386 info                 93892 portage        36737 ssl
  70744 gentoo-x86     1585 lib                   5132 portage.old      784 tmp

Capire gli inode

Ogni oggetto su un filesystem è assegnato ad un indice unico, chiamato numero di inode. Questo può sembrare insignificante ma capire gli inode è fondamentale per capire molte delle operazioni su filesystem. Per esempio, basti considerare i collegamenti . e .. che appaiono in ogni cartella. Per comprendere pienamente cosa una cartella .. è effettivamente, bisogna prima dare uno sguardo al numero di inode di /usr/local:

Codice 3.6: Recuperare le informazioni sull'inode per una cartella

$ ls -id /usr/local
   5120 /usr/local

La cartella /usr/local ha un numero di inode di 5120. Adesso, va preso in considerazione il numero di inode di /usr/local/bin/.. :

Codice 3.7: Recuperare le informazioni sull'inode per una cartella

$ ls -id /usr/local/bin/..
   5120 /usr/local/bin/..

Come è possibile notare, /usr/local/bin/.. ha lo stesso numero di inode di /usr/local . Bisogna spiegare come va affrontata questa rivelazione scioccante. In precedenza, /usr/local è stata considerata la cartella stessa. Adesso, è stato scoperto che di fatto è l'inode 5120 la cartella e sono state individuate due voci di cartelle (chiamate "collegamenti") che puntano a questo inode. Sia /usr/local che /usr/local/bin/.. sono collegamenti all'inode 5120. Anche se l'inode 5120 esiste in una posizione unica sul disco, cose diverse sono ad esso collegate. L'inode 5120 è la voce effettiva sul disco.

Infatti, è possibile vedere il numero totale di volte che l'inode 5120 è referenziato usando il comando ls -dl:

Codice 3.8: Recuperare informazioni sui riferimenti all'inode

$ ls -dl /usr/local
drwxr-xr-x    8 root     root          240 Dec 22 20:57 /usr/local

Dando un'occhiata alla seconda colonna da sinistra, si nota che la cartella /usr/local (inode 5120) viene referenziata otto volte. Sul sistema di chi sta scrivendo, quelli che seguono sono i diversi percorsi che referenziano questo inode:

Codice 3.9: Riferimenti all'inode

/usr/local
/usr/local/.
/usr/local/bin/..
/usr/local/games/..
/usr/local/lib/..
/usr/local/sbin/..
/usr/local/share/..
/usr/local/src/..

mkdir

Di seguito un'occhiata veloce al comando mkdir, che può essere usato per creare nuove cartelle. L'esempio seguente crea tre nuove cartelle, tic, tac e toe, tutte sotto /tmp:

Codice 3.10: Creare cartelle

$ cd /tmp
$ mkdir tic tac toe

Di base, il comando mkdir non crea le cartelle precedenti (anche dette cartelle parente o padre) per l'utente; l'intero percorso dall'inizio al penultimo elemento deve esistere già. Quindi, volendo creare le cartelle splen/di/do, bisogna lanciare tre comandi mkdirseparati:

Codice 3.11: Creare le cartelle padre nel percorso

$ mkdir splen/di/do
mkdir: cannot create directory `splen/di/do': No such file or directory
$ mkdir splen
$ mkdir splen/di
$ mkdir splen/di/do

Comunque, mkdir ha una pratica opzione -p che indica al comando di creare ogni cartella parente mancante, come mostrato di seguito:

Codice 3.12: Creare le cartelle padre in una volta sola

$ mkdir -p gioco/da/ragazzi

Tutto sommato, davvero diretto. Per saperne di più riguardo al comando mkdir, basta digitare man mkdir per leggerne la pagina di manuale. Questo dovrebbe funzionare con quasi tutti i comandi discussi qui (per esempio, man ls), eccetto per cd, che è incorporato con bash.

touch

Adesso, verrà dato uno sguardo veloce ai comandi cp e mv, usati per copiare, rinominare e spostare file e cartelle. Per iniziare questa visione d'insieme, useremo prima il comando touch per creare un file in /tmp:

Codice 3.13: Creare un file

$ cd /tmp
$ touch copiami

Il comando touch aggiorna il valore di "mtime" di un file se esistente (un richiamo alla sesta colonna nel risultato di ls -l). Se il file non esiste, allora verrà creato un nuovo file vuoto. Dovrebbe essere presente adesso un file /tmp/copiami con dimensione pari a zero.

echo

Adesso che il file esiste, bisogna aggiungere in esso qualche dato. Questo può essere fatto usando il comando echo, il quale prende il proprio argomento e lo stampa sullo standard output. Primo, il comando echo da solo:

Codice 3.14: Creare un file usando 'echo'

$ echo "primo_file"
primo_file

Ora, lo stesso comando echo con una ridirezione dell'output:

Codice 3.15: Usare la redirezione dell'output

$ echo "primo_file" > copiami

Il segno di maggiore indica alla shell di scrivere l'output di echo in un file chiamato copiami. Questo file sarà creato se non esiste, altrimenti verrà sovrascritto se già presente. Digitando ls -l, è possibile vedere che il file copiami ha dimensione pari a 11 byte, dato che contiene la parola primo_file e il carattere di a capo:

Codice 3.16: Vedere le informazioni sul file

$ ls -l copiami
-rw-r--r--    1 root     root           11 Dec 28 14:13 copiami

cat e cp

Per stampare il contenuto di un file sul terminale, usare il comando cat:

Codice 3.17: Vedere il contenuto di un file

$ cat copiami
primo_file

Ora, è possibile usare una invocazione di base del comando cp per creare un file copiato (di nome e di fatto) dall'originale file copiami:

Codice 3.18: Copiare un file

$ cp copiami copiato

Indagando, l'utente scoprirà che questi sono veramente file separati; il loro numero di inode è diverso:

Codice 3.19: Controllare le differenze sugli inode

$ ls -i copiami copiato
  648284 copiami   650704 copiato

mv

Adesso, andiamo ad usare il comando mv per rinominare "copiato" in "spostato". Il numero di inode rimarrà lo stesso; comunque, il nome del file che punta all'inode cambierà.

Codice 3.20: Rinominare un file

$ mv copiato spostato
$ ls -i spostato
  648284 spostato

Il numero di inode di un file spostato rimarrà lo stesso fino a che la destinazione del file si trova sullo stesso filesystem del file sorgente. Verrà data un'occhiata più da vicino ai filesystem nella Parte 3 di questa serie di guide introduttive.

Parlando ancora di mv, vediamo un altro modo di usare questo comando. mv, oltre a permettere di rinominare file, dà la possibilità anche di spostare uno o più file in un altra posizione nella gerarchia di cartelle. Per esempio, per spostare /var/tmp/mio_file.txt in /home/drobbins (che risulta essere la cartella home dello scrittore) basta digitare:

Codice 3.21: Spostare un file in una posizione diversa

$ mv /var/tmp/mio_file.txt /home/drobbins

Dopo aver digitato questo comando, mio_file.txt sarà spostato in /home/drobbins/mio_file.txt. E se /home/drobbins si trova su un filesystem diverso da /var/tmp, il comando mv gestirà la copia di mio_file.txt sul nuovo filesystem e lo cancellerà dall'attuale. Come è possibile indovinare, quando mio_file.txt viene spostato fra filesystem, il mio_file.txt nella nuova posizione avrà un nuovo numero di inode. Questo perché ogni filesystem ha il proprio insieme indipendente di numeri di inode.

Esiste anche la possibilità di usare il comando mv per spostare più file in una singola cartella di destinazione. Per esempio, per spostare mio_file1.txt e mio_articolo3.txt in /home/drobbins, basterà digitare:

Codice 3.22: Spostare più file

$ mv /var/tmp/mio_file1.txt /var/tmp/mio_articolo3.txt /home/drobbins

4.  Creare collegamenti e rimuovere file

Hard link (Collegamenti fisici)

Il termine "link" (collegamento) è stato usato in riferimento alla relazione fra le voci delle cartelle (i "nomi" che vengono digitati) e gli inode (i numeri di indice sul filesystem sottostante che possono essere normalmente ignorati). Ci sono in realtà due tipi di collegamenti disponibili in Linux. Il tipo discusso in precedenza è chiamato hard link (collegamento fisico). Un determinato inode può avere un numero qualsiasi di hard link e l'inode continuerà ad esistere sul filesystem fino a che tutti gli hard link non spariranno. Quando l'ultimo hard link sparirà e nessun programma starà tenendo il file aperto, Linux cancellerà il file automaticamente. Nuovi hard link possono essere creati usando il comando ln:

Codice 4.1: Creare collegamenti a file

$ cd /tmp
$ touch primo_link
$ ln primo_link secondo_link
$ ls -i primo_link secondo_link
  15782 primo_link    15782 secondo_link

Come è possibile vedere, gli hard link lavorano a livello di inode per puntare ad un particolare file. Su sistemi Linux, gli hard link hanno diverse limitazioni. Per cominciare, si possono creare solamente hard link a file, non a cartelle. Esatto; Anche se . e .. sono hard link creati dal sistema a cartelle, all'utente (perfino come utente "root") non è permesso in alcun caso crearne di propri. La seconda limitazione degli hard link è che questi non possono attraversare i filesystem. Ciò significa che non può essere creato un link da /usr/bin/bash a /bin/bash se le cartelle / e /usr esistono su filesystem separati.

Symbolic link (Collegamenti simbolici)

In pratica, i collegamenti simbolici (o symlink) vengono usati più spesso degli hard link. I symlink sono tipi speciali di file dove il collegamento si riferisce ad un altro file per nome, piuttosto che direttamente ad un inode. I symlink non prevengono il fatto che un file possa essere cancellato; se il file puntato sparisce, allora il symlink sarà semplicemente inutilizzabile, o rotto.

Un collegamento simbolico può essere creato passando l'opzione -s a ln.

Codice 4.2: Uno sguardo ai collegamenti simbolici

$ ln -s secondo_link terzo_link
$ ls -l primo_link secondo_link terzo_link
-rw-rw-r--    2 agriffis agriffis        0 Dec 31 19:08 primo_link
-rw-rw-r--    2 agriffis agriffis        0 Dec 31 19:08 secondo_link
lrwxrwxrwx    1 agriffis agriffis       12 Dec 31 19:39 terzo_link ->
secondo_link

I collegamenti simbolici possono essere distinti dai normali file nel risultato di ls -l in tre modi. Primo, basta notare che al prima colonna contiene un carattere l a indicare il collegamento simbolico. Secondo, la dimensione del collegamento simbolico è il numero di caratteri del file puntato (secondo_link, in questo caso). Terzo, l'ultima colonna del risultato mostra il nome del file puntato preceduto da un piccolo grazioso ->.

Approfondimento sui collegamenti simbolici

I collegamenti simbolici sono in generale più flessibili degli hard link. È possibile creare un collegamento simbolico ad ogni tipo di oggetto sul filesystem, incluse le cartelle. E poiché l'implementazione dei collegamenti simbolici è basata su percorsi (non sugli inode), è assolutamente corretto creare collegamenti simbolici che puntano ad un oggetto su un altro filesystem fisico. Comunque, questo aspetto può anche rendere i collegamenti simbolici difficili da capire.

Si consideri una situazione in cui è richiesta la creazione di un collegamento in /tmp che punti a /usr/local/bin. Potrebbe bastare digitare quanto segue:

Codice 4.3: Collegamento a cartelle, primo tentativo

$ ln -s /usr/local/bin bin1
$ ls -l bin1
lrwxrwxrwx    1 root     root           14 Jan  1 15:42 bin1 -> /usr/local/bin

O in alternativa:

Codice 4.4: Collegamento a cartelle, secondo tentativo

$ ln -s ../usr/local/bin bin2
$ ls -l bin2
lrwxrwxrwx    1 root     root           16 Jan  1 15:43 bin2 -> ../usr/local/bin

Come viene mostrato, entrambi i collegamenti simbolici puntano alla stessa cartella. Comunque, se il secondo link viene poi spostato in un'altra cartelle, risulterà "rotto" ("broken") a causa del percorso relativo:

Codice 4.5: Rompere un collegamento simbolico

$ ls -l bin2
lrwxrwxrwx    1 root     root           16 Jan  1 15:43 bin2 -> ../usr/local/bin
$ mkdir mia_nuova_cartella
$ mv bin2 mia_nuova_cartella
$ cd mia_nuova_cartella
$ cd bin2
bash: cd: bin2: No such file or directory

Dato che la cartella /tmp/usr/local/bin non esiste, l'utente non potrà più spostarsi nella cartella bin2; in altre parole, bin2 è ora rotto.

Per questa ragione, è talvolta una buona idea evitare di creare collegamenti simbolici con informazioni sul percorso relativo. Comunque, ci sono molti casi in cui collegamenti simbolici relativi tornano utili. Basta considerare un esempio in cui si voglia creare un nome alternativo per un programma in /usr/bin:

Codice 4.6: Vedere le informazioni sul file keychain

# ls -l /usr/bin/keychain
-rwxr-xr-x    1 root     root        10150 Dec 12 20:09 /usr/bin/keychain

Come utente root, potrebbe esserci la volontà di creare un nome alternativo per "keychain", come "kc". In questo esempio, è usato l'accesso come root, come evidenziato dal prompt bash cambiato in "#". È necessario l'accesso come root perché utenti normali non sono abilitati a creare file in /usr/bin. Da root, sarà possibile creare un nome alternativo per keychain come segue:

Codice 4.7: Creare un collegamento simbolico per keychain

# cd /usr/bin
# ln -s /usr/bin/keychain kc
# ls -l keychain
-rwxr-xr-x    1 root     root        10150 Dec 12 20:09 /usr/bin/keychain
# ls -l kc
lrwxrwxrwx    1 root     root           17 Mar 27 17:44 kc -> /usr/bin/keychain

Nell'esempio, è stato creato un collegamento simbolico chiamato kc che punta al file /usr/bin/keychain.

Mentre questa soluzione funziona, creerà problemi nel caso venga deciso di spostare entrambi i file, /usr/bin/keychain e /usr/bin/kc, in /usr/local/bin:

Codice 4.8: Spostare i collegamenti simbolici

# mv /usr/bin/keychain /usr/bin/kc /usr/local/bin
# ls -l /usr/local/bin/keychain
-rwxr-xr-x    1 root     root        10150 Dec 12 20:09 /usr/local/bin/keychain
# ls -l /usr/local/bin/kc
lrwxrwxrwx    1 root     root           17 Mar 27 17:44 kc -> /usr/bin/keychain

Dato che è stato usato un percorso assoluto nel proprio collegamento simbolico, il symlink kc starà ancora puntando a /usr/bin/keychain, che non esiste più dato che è stato spostato /usr/bin/keychain in /usr/local/bin.

Questo significa che kc è ora un symlink rotto. Entrambi i parcorsi assoluti e relativi nei collegamenti simbolici hanno i loro meriti e l'utente potrebbe usare un tipo di percorso che è appropriato per la sua particolare applicazione. Spesso, sia i percorsi relativi che quelli assoluti operano abbastanza bene. Il prossimo esempio dovrebbe funzionare anche dopo che entrambi i file sono stati spostati:

Codice 4.9: Spostare file in giro con symlink

# cd /usr/bin
# ln -s keychain kc
# ls -l kc
lrwxrwxrwx    1 root     root            8 Jan  5 12:40 kc -> keychain
# mv keychain kc /usr/local/bin
# ls -l /usr/local/bin/keychain
-rwxr-xr-x    1 root     root        10150 Dec 12 20:09 /usr/local/bin/keychain
# ls -l /usr/local/bin/kc
lrwxrwxrwx    1 root     root           17 Mar 27 17:44 kc -> keychain

Ora, è possibile eseguire il programma keychain digitando /usr/local/bin/kc. /usr/local/bin/kc punta al programma keychain nella stessa cartella di kc.

rm

Adesso che sono stati affrontati cp, mv e ln, è il momento di imparare come rimuovere oggetti dal filesystem. Normalmente, viene fatto tramite il comando rm. Per rimuovere file, basta indicarli sulla riga di comando:

Codice 4.10: Rimuovere file

$ cd /tmp
$ touch file1 file2
$ ls -l file1 file2
-rw-r--r--    1 root     root            0 Jan  1 16:41 file1
-rw-r--r--    1 root     root            0 Jan  1 16:41 file2
$ rm file1 file2
$ ls -l file1 file2
ls: file1: No such file or directory
ls: file2: No such file or directory

Bisogna notare che in Linux, una volta che un file è cancellato, risulta di norma eliminato per sempre. Per questa ragione, molti giovani amministratori di sistema useranno l'opzione -i cancellando file. L'opzione -i dice ad rm di rimuovere tutti i file in modalità interattiva -- ovvero, chiederà prima di rimuovere ogni file. Per esempio:

Codice 4.11: Rimuovere file e chiedere conferma

$ rm -i file1 file2
rm: remove regular empty file `file1'? y
rm: remove regular empty file `file2'? y

Nell'esempio precedente, il comando rm chiede se i file indicati dovrebbero *veramente* essere cancellati o meno. In modo che fossero cancellato, è stato necessario digitare "y" e Enter (Invio) due volte. Se fosse stato digitato "n", il file non sarebbe stato rimosso. O, se fosse stato fatto qualcosa di veramente sbagliato, sarebbe bastato digitare Control-C per abortire completamente il comando rm -i -- tutti ciò che avviene prima è capace di arrecare ogni potenziale danno al proprio sistema.

Se ancora si desidera usare il comando rm, può risultare utile aggiungere la linea seguente al proprio file ~/.bashrc usando l'editor di testi preferito, quindi effettuare il logout e nuovamente il login. Adesso, ogni volta che viene digitato rm, la shell bash lo convertirà automaticamente nel comando rm -i. In questo modo, rm opererà sempre in modalità interattiva:

Codice 4.12: Impostare l'alias 'rm -i'

alias rm="rm -i"

rmdir

Per cancellare cartelle, si hanno due opzioni. Possono essere rimossi tutti gli oggetti all'interno di una cartella e quindi usato rmdir per rimuovere la cartella stessa:

Codice 4.13: Rimuovere cartelle

$ mkdir mia_dir
$ touch mia_dir/file1
$ rm mia_dir/file1
$ rmdir mia_dir

Questo metodo è comunemente indicato come "rimozione di cartelle per stupidi". Tutti gli utenti esperti e gli amministratori degni di questo nome usano il molto più conveniente comando rm -rf, spiegato di seguito.

Il miglior modo per cancellare una cartella è l'uso dell'opzione di forzatura ricorsiva sul comando rm per indicare a rm di cancellare la cartella specificata, così come tutti gli oggetti in essa contenuti:

Codice 4.14: Rimuovere completamente una cartella

$ rm -rf mydir

In genere, rm -rf è il metodo preferito per rimuovere un albero di cartelle. Bisogna però fare molta attenzione nell'uso di rm -rf, in quanto la sua potenza può essere usata in modo sia divino che diabolico.

5.  Usare le wild card

Introduzione alle wild card

Nell'uso giornaliero di Linux, ci sono molte situazioni in cui si ha la necessità di effettuare una singola operazione (come un rm) su molti oggetti nel filesystem tutti in una volta. In questi casi, può essere spesso tedioso digitare molti nomi di file sulla riga di comando:

Codice 5.1: Rimuovere file individualmente

$ rm file1 file2 file3 file4 file5 file6 file7 file8

Per risolvere il problema, è possibile trarre vantaggio dal supporto integrato in Linux per le wild card. Questo supporto, anche chiamato "globbing" (per ragioni storiche), permette all'utente di indicare file diversi in una volta usando un pattern wildcard. Bash e altri comandi Linux interpreteranno questo pattern scrutando il disco e cercando ogni file che corrisponda. Quindi, se sono presenti file da file1 fino a file8 nella cartella corrente, possono essere rimossi digitando:

Codice 5.2: Rimuovere file usando il completamento della shell

$ rm file[1-8]

O, nei casi in cui semplicemente vi sia la necessità di rimuovere tutti i file il cui nome comincia con file così come tutti i file chiamati file, basterà digitare:

Codice 5.3: Rimuovere file usando il completamento della shell con il glob *

$ rm file*

La wildcard * trova riscontro con ogni carattere o sequenza di caratteri o perfino "nessun carattere". Certamente, le glob wildcard possono essere usate per molte più cose della semplice cancellazione di file, come sarà mostrato nel paragrafo successivo.

Capire le discordanze

Nel caso in cui si desideri avere una lista di tutti gli oggetti del filesystem presenti in /etc il cui nome inizia con g, così come tutti i file chiamati g, basta digitare:

Codice 5.4: Esempio di uso del glob *

$ ls -d /etc/g*
/etc/gconf  /etc/ggi  /etc/gimp  /etc/gnome  /etc/gnome-vfs-mime-magic  /etc/gpm  /etc/group  /etc/group-

Ma cosa succede se viene specificato un pattern (modello) che non corrisponde con alcun oggetto del filesystem? Nell'esempio che segue, viene tentato di ricavare la lista di tutti i file in /usr/bin che iniziano con asdf e finiscono con jkl, incluso potenzialmente il file asdfjkl:

Codice 5.5: Un altro esempio del glob *

$ ls -d /usr/bin/asdf*jkl
ls: /usr/bin/asdf*jkl: No such file or directory

Ecco cos'è successo. Normalmente, quando viene specificato un pattern, esso si abbina ad uno o più file sul filesystem sottostante, e bash rimpiazza il modello con una lista, avente le voci separate da spazi, di tutti gli oggetti che coincidono. Tuttavia, quando il pattern non produce nessuna corrispondenza, bash lascia intatto l'argomento, wild card e tutto il resto, così com'è. Quindi, così facendo ls non può trovare il file /usr/bin/asdf*jkl e consegna all'utente un messaggio d'errore. La regola operativa in questi casi è che i modelli glob (glob pattern) sono espansi solo se corrispondenti ad oggetti nel filesystem. Altrimenti rimangono come sono e vengono letteralmente passati al programma che è stato chiamato.

Sintassi delle wild card: * e ?

Adesso che è stato mostrato come operano i globbing, è doveroso dare uno sguardo alla sintassi delle wild card. Possono essere usati caratteri speciali per l'espansione delle wild card:

Con * vengono riscontrati zero o più caratteri. Ciò significa "ogni cosa può andare qua, anche niente". Per esempio:

  • /etc/g* indica tutti i file in /etc che iniziano con g, o un file chiamato g.
  • /tmp/mio_*1 indica tutti i file in /tmp che iniziano con mio_ e finiscono con 1, incluso il file mio_1.

Con ? viene riscontrato ogni carattere singolarmente. Per esempio:

  • mio_file? corrisponde ad ogni file il cui nome consiste in mio_file seguito da un singolo carattere
  • /tmp/note?txt corrisponderà sia a /tmp/note.txt che a /tmp/note_txt, se questi esistono

Sintassi delle wild card: []

Questa wild card è simile a ?, ma permette di essere più specifici. Per usare questa wild card, bisogna porre ogni carattere che si desidera sia concorde all'interno di []. L'espressione risultante riscontrerà una singola occorrenza di ognuno di questi caratteri. È possibile anche usare - per specificare un intervallo e perfino combinare intervalli. Per esempio:

  • mio_file[12] concorderà con mio_file1 e mio_file2. La wild card sarà espansa purché almeno uno di questi file esista nella cartella corrente.
  • [Cc]hange[Ll]og riscontrerà Changelog, ChangeLog, changeLog, e changelog. Come è possibile vedere, l'uso della wild card parentesi può essere utile per rilevare variazioni nella scrittura in maiuscolo.
  • ls /etc/[0-9]* restituirà la lista di tutti i file in /etc che iniziano con un numero.
  • ls /tmp/[A-Za-z]* restituirà la lista di tutti i file in /tmp che iniziano con una lettera maiuscola o minuscola.

Il costrutto [!] è simile al costrutto [], eccetto che piuttosto che riscontrare qualsiasi carattere all'interno delle parentesi, effettuerà la corrispondenza con ogni carattere, purché questo non sia presente nella lista compresa fra [! e ]. Per esempio:

  • rm mio_file[!9] rimuoverà tutti i file chiamati mio_file più un singolo carattere, eccetto mio_file9

Rischi nell'uso delle wild card

Di seguito vengono elencate alcune cose a cui fare attenzione quando si usano le wild card. Dato che bash tratta i caratteri relativi alle wild card (?, [, ] e *) in modo speciale, bisogna fare attenzione particolare quando si digitano in un argomento per un comando che contiene questi caratteri. Per esempio, laddove si voglia creare un file che contiene la stringa [fo]*, il seguente comando potrebbe non fare ciò che si vuole:

Codice 5.6: Uso errato dei caratteri speciali

$ echo [fo]* > /tmp/mio_nuovo_file.txt

Se il pattern [fo]* concorda con ogni file nella cartella di lavoro corrente, allora troveremo i nomi di questi file all'interno di /tmp/mio_nuovo_file.txt piuttosto che il letterale [fo]* come ci si aspetta. La soluzione? Bene, un approccio è quello di circondare i propri caratteri con apici singoli, che comunica a bash di non effettuare assolutamente alcuna espansione delle wild card su di essi:

Codice 5.7: Eludere i caratteri speciali

$ echo '[fo]*' > /tmp/mio_nuovo_file.txt

Usando questo approccio, il nuovo file conterrà un letterale [fo]* come ci si aspettava. In alternativa, possono essere usate le barre inverse (backslash) di escaping per indicare a bash che [, ] e * dovrebbero essere trattati letteralmente piuttosto che come wild card:

Codice 5.8: Effettuare l'escaping di caratteri speciali, seconda possibilità

$ echo \[fo\]\* > /tmp/mio_nuovo_file.txt

Entrambi gli approcci (apici singoli o barre inverse di escaping) hanno lo stesso effetto. Dato che si sta discutendo dell'espansione delle barre inverse, questo è un ottimo momento per dire che per specificare un letterale \, è possibile sia includere quest'ultimo fra apici singoli così com'è che digitare invece \\ (sarà espanso in \).

Nota: Gli apici doppi operano in modo simile agli apici singoli, ma permettono ancora limitatamente a bash di fare alcune espansioni. Perciò, gli apici singoli devono essere la scelta preferita quando l'utente è sinceramente interessato nel passare testo letterale ad un comando. Per maggiori informazioni sull'espansione delle wild card, digitare man 7 glob. Per maggiori informazioni sugli apici in bash, digitare man 8 glob e leggere la sezione intitolata QUOTING. In caso si pianifichi di sostenere gli esami del LPI, considerare quanto sopra come un compito per casa.

6.  Sommario e risorse

Sommario

Congratulazioni; è giunta la fine di questo articolo sui fondamenti di Linux. L'autore si augura che possa essere stato d'aiuto nel solidificare le fondamenta della propria conoscenza di Linux. Gli argomenti imparati qua, inclusi i fondamenti di bash, i comandi di base per Linux, collegamenti (link) e wild card, hanno gettato le fondamenta per la prossima breve guida sull'amministrazione di base, in cui saranno coperti argomenti come le espressioni regolari, proprietà e permessi, gestione degli account utente e altro ancora.

Continuando in questa serie di brevi guide, il lettore sarà presto pronto per raggiungere la propria Certificazione LPIC di Livello 1 del Linux Professional Institute. Parlando di certificazione LPIC, se questo è ciò a cui è interessato il lettore, si raccomanda di studiare le Risorse indicare nel paragrafo successivo, le quali sono state attentamente selezionate per completare il materiale coperto in questa breve guida.

Risorse

Nella serie di articoli "Bash by example" (Bash tramite esempi) su developerWorks, Daniel mostra al lettore come usare i costrutti della programmazione bash per scrivere i propri script in bash. Questa serie (in particolare Parte 1 e 2) rappresenta una buona preparazione per l'esame LPIC di Livello 1:

Gli utenti novizi o intermedi di Linux dovrebbero sentirsi in dovere con se stessi di esaminare le FAQ Tecniche per utenti Linux, una lista di 50 pagine approfondite riguardo domande frequenti su Linux, insieme a risposte dettagliate. Le FAQ stesse sono in formato PDF (Acrobat).

Per chi non fosse così familiare con l'editor vi, fare riferimento alla breve guida su developerWorks chiamata Intro to vi (Introduzione a Vi). Questa fornisce al lettore una semplice e molto veloce introduzione a questo potente editor di testo. Bisogna considerare questo come materiale da leggere se non si sa come usare vi.



Stampa

Aggiornato il 12 ottobre 2005

Oggetto: In questa breve guida sarà data un'introduzione su bash (la shell predefinita in Linux) al lettore, verrà mostrato come ottenere pieno vantaggio da comandi di base in Linux come ls, cp e mv, saranno spiegati gli inodes e sia hard link che link simbolici e tanto altro ancora. Alla fine di questa introduzione, il lettore avrà una base solida sui fondamenti di Linux e sarà anche pronto per iniziare ad imparare alcuni processi basilari riguardo all'amministrazione di sistemi Linux.

Daniel Robbins
Autore

Michele Caini
Traduzione

Donate to support our development efforts.

Copyright 2001-2014 Gentoo Foundation, Inc. Questions, Comments? Contact us.