Quelle indicate nel titolo sono le fasi fondamentali dell'amministrazione dei dati. Nello stesso modo sono anche le operazioni più delicate. La tabella 54.1 elenca i programmi a cui si accenna in questo capitolo.
| Programma | Descrizione |
| cp | Copia. |
| ln | Crea dei collegamenti. |
| install | Copia attribuendo permessi e proprietà ai file di destinazione. |
| dd | Copia a basso livello. |
| mv | Sposta o rinomina i file. |
| rm | Cancella. |
| cpio | Archivia e recupera. |
| tar | Archivia e recupera. |
| gzip | Comprime e decomprime. |
| bzip2 | Comprime e decomprime. |
La copia genera un altro file o un'altra directory, il collegamento genera un riferimento aggiuntivo agli stessi dati di origine: assomiglia alla copia, ma rappresenta solo un modo per fare apparire la stessa cosa in più punti differenti.
Nei sistemi Unix i collegamenti sono molto importanti e vengono usati di frequente. Si distinguono due tipi di questi: collegamenti simbolici e collegamenti fisici (hard link). Attraverso il collegamento fisico si creano dei riferimenti a dati esistenti in modo non distinguibile da quelli originali; i collegamenti simbolici sono dei file speciali e per questo distinguibili dai file originali.
A fianco del problema della copia di file (o di directory), cioè di entità virtuali per il contenimento dei dati, ci può essere il problema elementare (anche se complicato per l'utente) di trasferire dati attraverso i dispositivi in modo diretto (copia a basso livello).
Si è detto che i collegamenti simbolici sono dei file speciali, distinguibili dai file originali. Si creano normalmente utilizzando il programma ln, con l'opzione -s
$ ln [Invio]-s /bin/sh ./sh
Seguendo l'esempio, se si leggono le caratteristiche del file ./sh attraverso ls, si può notare l'indicazione esplicita del fatto che si tratti di un riferimento al file /bin/sh (il quale potrebbe essere un altro collegamento, ma questo adesso non è importante).
$ ls [Invio]-l sh
lrwxrwxrwx 1 tizio tizio 7 Mar 2 10:16 sh -> /bin/sh |
La lettera che appare all'inizio dei permessi, l, indica esplicitamente che si tratta di un collegamento simbolico. Alla fine, viene indicato anche a chi punta il collegamento: -> /bin/sh
Si può osservare inoltre che i permessi di un collegamento simbolico non esistono. Formalmente vengono mostrati come attivi tutti i permessi degli ultimi 9 bit (lettura, scrittura ed esecuzione per tutti gli utenti), perché quelli che contano sono in realtà i permessi del file (o della directory) cui effettivamente punta il collegamento simbolico.
|
L'esistenza dei collegamenti simbolici altera la logica normale della copia: ha senso copiare i file a cui i collegamenti puntano, o ha senso copiare i collegamenti? Solitamente si considera che la gestione dei collegamenti simbolici debba essere trasparente, come se questi non esistessero e si trattasse effettivamente dei file a cui loro puntano. Ciò fino a quando non si fa esplicitamente riferimento ai collegamenti in quanto tali. |
La gestione dei collegamenti fisici è più seria, nel senso che deve essere riservata a situazioni di particolare necessità. Si è detto che attraverso il collegamento fisico si creano dei riferimenti a dati esistenti in modo non distinguibile da quelli originali. In pratica, due voci nella stessa directory, o in directory differenti, possono puntare allo stesso file.
Quando si cancella un file, si elimina il riferimento al suo inode dalla directory che lo contiene formalmente. Quando un inode non ha più riferimenti, viene considerato libero, e può essere riutilizzato per un altro file. In altre parole, se si utilizzano i collegamenti fisici, un file viene cancellato effettivamente quando sono stati eliminati tutti i riferimenti a questo.
Per comprendere in pratica cosa accade, si può provare a eseguire gli esempi seguenti.
$ touch mio_file[Invio]
$ ls [Invio]-l mio_file
-rw-rw-r-- 1 tizio tizio 0 Mar 2 10:48 mio_file |
$ ln mio_file tuo_file[Invio]
$ ls [Invio]-l mio_file tuo_file
-rw-rw-r-- 2 tizio tizio 0 Mar 2 10:48 mio_file -rw-rw-r-- 2 tizio tizio 0 Mar 2 10:48 tuo_file |
Come si vede, con questa serie di operazioni si è giunti ad avere due file, apparentemente indipendenti, ma se viene modificato il contenuto di uno si vedono le modifiche anche sull'altro. Dal momento che i permessi e la proprietà dei file (UID e GID) sono informazioni contenute nell'inode, la modifica di questi si ripercuote su tutti i collegamenti.
Si può osservare il numero che appare dopo i permessi: 2. Indica quanti riferimenti ha l'inode corrispondente. In pratica, quel numero indica quante voci puntano a quello stesso file. Non si può sapere facilmente quali siano gli altri riferimenti. Si può solo conoscere il numero dell'inode.
$ ls [Invio]-l -i mio_file tuo_file
270385 -rw-rw-r-- 2 tizio tizio 0 Mar 2 10:48 mio_file 270385 -rw-rw-r-- 2 tizio tizio 0 Mar 2 10:48 tuo_file |
Come si vede, i due file hanno lo stesso inode (il numero che appare prima dei permessi), quindi sono lo stesso file.
Ogni directory contiene due riferimenti convenzionali: uno a se stessa e uno alla directory precedente (. e ..). Si tratta di nomi di file a tutti gli effetti, che puntano agli inode della directory stessa e di quella precedente.
l'inode di una directory ha pertanto almeno due riferimenti: quello che serve a raggiungere la directory stessa, a partire dalla sua directory precedente, e quello rappresentato dal punto singolo (directory corrente).
Quando una directory ne contiene un'altra, allora il numero di riferimenti alla directory di partenza aumenta, perché la directory che si aggiunge ha un riferimento alla sua directory precedente.
$ mkdir miadir[Invio]
$ ls [Invio]-l -d -i miadir
157715 drwxrwxr-x 2 tizio tizio 1024 Mar 2 11:22 miadir |
L'esempio mostra semplicemente il riferimento alla directory miadir/ contenuto nella sua directory precedente. Si può provare a leggere il contenuto della directory appena creata.
$ cd miadir[Invio]
$ ls [Invio]-l -i -a miadir
157715 drwxrwxr-x 2 tizio tizio 1024 Mar 2 11:22 . 536615 drwxrwxr-x 3 tizio tizio 3072 Mar 2 11:22 .. |
Come si può osservare, il file indicato con un singolo punto (.) ha lo stesso numero di inode della directory miadir/, e questo spiega il motivo per cui una directory ha almeno due riferimenti (collegamenti fisici).
La directory precedente, rappresentata dai due punti in sequenza (..), ha tre riferimenti totali per il solo fatto che esiste questa directory (in pratica: i due riferimenti naturali, più questo, perché esiste questa directory).
cp [<opzioni>] <origine> <destinazione> |
cp [<opzioni>] <origine>... <directory> |
Copia i file. Se vengono specificati solo i nomi di due file, il primo viene copiato sul secondo, viene cioè generata una copia che ha il nome indicato come destinazione. Se il secondo nome indicato è una directory, il file viene copiato con lo stesso nome nella directory. Se vengono indicati più file, l'ultimo nome deve essere una directory e verranno generate le copie di tutti i file indicati nella directory di destinazione. In mancanza di altre indicazioni, le directory non vengono copiate.
|
|
|
Equivalente a -dpR
|
Mantiene delle copie di sicurezza dei file che vengono sovrascritti con la copia.
|
Copia i collegamenti simbolici mantenendoli come tali, invece di copiare i file a cui i collegamenti si riferiscono.
|
Sovrascrittura forzata dei file di destinazione.
|
Richiede una conferma per la sovrascrittura nel caso in cui esistano già dei file con i nomi uguali a quelli di destinazione della copia.
|
Crea un collegamento fisico invece di copiare i file (non vale per le directory).
|
Crea un collegamento simbolico invece di copiare i file (non vale per le directory).
|
Copia anche il percorso indicato nel file di origine.
|
Mantiene le proprietà, i permessi originali e le date originali.
|
Copia file e directory in modo ricorsivo (includendo le sottodirectory), considerando tutto ciò che non è una directory come un file normale.
|
Copia file e directory in modo ricorsivo (includendo le sottodirectory).
|
Permette di definire il suffisso da utilizzare per le eventuali copie di sicurezza delle versioni precedenti. Se non viene specificato con questa opzione, si utilizza il simbolo contenuto nella variabile di ambiente SIMPLE_BACKUP_SUFFIX. Se anche questa variabile non è stata predisposta, si utilizza il simbolo tilde (~).
|
Permette di definire esplicitamente il modo con cui gestire le copie di sicurezza delle versioni precedenti, quando si usa anche l'opzione -b
t, numbered
le copie di sicurezza hanno un'estensione numerata;
nil, existing
mantiene le copie di sicurezza solo per i file che hanno già una o più copie di sicurezza numerate;
never, simple
esegue una copia di sicurezza semplice, ovvero ne mantiene una sola copia.
Se questa opzione non viene indicata, si prende in considerazione il valore della variabile di ambiente VERSION_CONTROL.
VERSION_CONTROL |
Permette di definire la modalità di gestione delle copie di sicurezza delle versioni precedenti in modo predefinito. I valori attribuibili a questa variabile sono gli stessi utilizzati come argomento dell'opzione -V
SIMPLE_BACKUP_SUFFIX |
Definisce il simbolo da utilizzare come suffisso per i nomi dei file che rappresentano le copie di sicurezza.
$ cp -r /test/* ~/prova
Copia il contenuto della directory /test/ in ~/prova/, copiando anche eventuali sottodirectory contenute in /test/.
$ cp -r /test ~/prova
Copia la directory /test/ in ~/prova/ (attaccando test/ a ~/prova/), copiando anche eventuali sottodirectory contenute in /test/.
$ cp -P aa/bb/cc miadir
Copia il file aa/bb/cc in modo da ottenere miadir/aa/bb/cc. Le directory intermedie, eventualmente mancanti, vengono create.
ln [<opzioni>] <origine> <destinazione> |
ln [<opzioni>] <origine>... <directory> |
Crea un collegamento tra file o tra directory. Se viene specificata un'origine e una destinazione, quest'ultima sarà il nuovo collegamento che punta al nome indicato come origine (e può trattarsi anche di una directory). Se vengono specificati più nomi nell'origine, l'ultimo argomento deve essere una directory e si intende che al suo interno verranno creati tanti collegamenti quanti sono i nomi indicati come origine. Se non viene specificato diversamente attraverso le opzioni, vengono creati dei collegamenti fisici e non dei collegamenti simbolici.
|
|
|
|
|
Le opzioni sopra indicate funzionano nello stesso modo di cp.
---------
|
Crea un collegamento simbolico invece di creare un collegamento fisico.
|
Permette all'utente root di creare un collegamento fisico per una directory, ma questa operazione dovrebbe essere impedita poi dal kernel Linux.
|
Quando la destinazione corrisponde a un collegamento simbolico preesistente che punta verso una directory, il funzionamento normale prevederebbe la creazione del collegamento in quella directory. Usando questa opzione si intende evitare ciò, rimpiazzando quel collegamento simbolico. Per poter attuare in pratica la cosa, occorre anche utilizzare l'opzione -f
ln utilizza le variabili di ambiente VERSION_CONTROL e SIMPLE_BACKUP_SUFFIX nello stesso modo di cp.
$ ln -s /bin/ls ~/elenco
Crea il collegamento simbolico elenco all'interno della directory personale che punta a /bin/ls. Eseguendo ~/elenco si ottiene in pratica di eseguire il comando ls.
$ ln /bin/ls ~/elenco
Crea il collegamento fisico elenco, all'interno della directory personale, che punta a /bin/ls. Eseguendo ~/elenco si ottiene in pratica di eseguire il comando ls.
$ ln -s /bin/* ~/
Crea una serie di collegamenti simbolici all'interno della directory personale per tutti i file contenuti in /bin. Per ogni collegamento simbolico che viene creato, il percorso di questo sarà assoluto e inizierà con /bin/.
$ cd /bin ; ln -s * ~/
In questo esempio, rispetto a quanto mostrato in quello precedente, il comando di creazione dei collegamenti simbolici viene dato nel momento in cui ci si trova nella directory /bin/, in riferimento a tutti i file della stessa. Quello che si ottiene nella directory personale dell'utente è la creazione di collegamenti simbolici diretti a se stessi, e quindi perfettamente inutili.
$ ln -s /bin ~/binari
Crea il collegamento simbolico ~/binari alla directory /bin/. Eseguendo cd ~/binari ci si ritroverà in /bin/.
install [<opzioni>] <origine>... <destinazione> |
install [<opzioni>]
|
Copia i file attribuendo i permessi e le proprietà stabilite. In pratica, si comporta in modo simile a cp con in più la possibilità di definire gli attributi dopo la copia e di creare tutte le directory necessarie. È usato tipicamente per l'installazione di programmi.
|
|
|
Le opzioni sopra indicate funzionano nello stesso modo di cp.
---------
|
Crea le directory indicate, definisce l'utente proprietario, il gruppo proprietario e i permessi in base alle altre opzioni.
|
Definisce il gruppo proprietario dei file installati o delle directory.
|
Definisce i permessi in modo analogo alla sintassi di chmod (
53.2.5).
|
Definisce l'utente proprietario dei file installati o delle directory.
dd [<opzioni>] |
dd (Data Duplicator o Data Dump) è un programma di copia a basso livello. Le opzioni sono definite in modo strano rispetto ai normali programmi di utilità Unix: non sono prefissate dal solito trattino (-
Molte delle opzioni utilizzano un argomento numerico. Questi argomenti numerici possono essere indicati anche con l'ausilio di moltiplicatori posti subito dopo il numero stesso:
nb = n * 512
nc = n * 1 = n
nk = n * 1024
nw = n * 2
nxm = n * m
if=<file> |
Legge i dati dal file indicato invece che dallo standard input.
of=<file> |
Scrive i dati nel file indicato invece che attraverso lo standard output. In questo caso, se il file indicato esiste già e la quantità di dati da scrivere è inferiore alla sua vecchia dimensione, questo file viene troncato alla dimensione nuova. Questa regola non vale più se si utilizza un tipo di conversione notrunc (viene descritto più giù).
ibs=<numero-di-byte> |
Legge a blocchi di byte della quantità indicata dall'argomento.
obs=<numero-di-byte> |
Scrive a blocchi di byte della quantità indicata dall'argomento.
bs=<numero-di-byte> |
Legge e scrive a blocchi di byte della quantità indicata dall'argomento. Questa opzione annulla eventuali dichiarazioni fatte attraverso ibs e obs.
cbs=<numero-di-byte> |
Definisce la dimensione del buffer di conversione. In pratica determina la dimensione del blocco da utilizzare quando si devono effettuare delle conversioni nella codifica. Più avanti viene descritto il significato di questa opzione, in corrispondenza della descrizione dei tipi di conversione attuabili.
skip=<numero-di-blocchi> |
In fase di lettura del file di input, salta il numero di blocchi indicato come argomento, dall'inizio del file, prima di iniziare la copia. I blocchi in questione corrispondono a quanto definito con ibs o con bs.
seek=<numero-di-blocchi> |
In fase di scrittura del file di output, salta il numero di blocchi indicato come argomento prima di iniziare la copia. I blocchi in questione corrispondono a quanto definito con obs o con bs. Il risultato dell'azione di saltare dei blocchi in fase di scrittura cambia a seconda che il file di destinazione sia già esistente o meno. Se il file esiste già, i byte dei blocchi saltati vengono lasciati inalterati e nel file si comincia a scrivere dopo la posizione indicata: se poi il file è troppo corto, questo viene allungato. Se il file non esiste, i byte dei blocchi da saltare vengono scritti con un valore nullo (<NUL>).
count=<numero-di-blocchi> |
Determina la quantità di blocchi da scrivere: si tratta di blocchi di input e quindi di quelli definiti attraverso l'opzione ibs o bs. Senza l'indicazione di questa opzione, la copia è sempre completa (a meno che non si saltino delle porzioni con l'opzione skip).
conv=<conversione>[,<conversione>]... |
Permette di definire il tipo di conversione, anche attraverso passaggi successivi. Il tipo di conversione viene specificato con il nome che lo identifica. Se si intendono applicare passaggi successivi, i tipi di conversione si separano con una virgola senza spazi prima o dopo la stessa.
ascii |
Converte dalla codifica EBCDIC a ASCII.
ebcdic |
Converte dalla codifica ASCII a EBCDIC.
ibm |
Converte dalla codifica ASCII-IBM a EBCDIC.
block |
Tratta le righe di ingresso come record terminati dal codice di interruzione di riga. Questi record vengono troncati o allungati in modo da corrispondere alla dimensione indicata attraverso l'opzione cbs. Alla fine, i codici di interruzione di riga risultano trasformati in spazi normali (<SP>), a meno che i record non siano stati troncati prima, e se si è reso necessario un allungamento dei record, è sempre il carattere spazio a essere aggiunto.
In pratica, il risultato finale è quello di un file con i record di dimensione uguale e per questo senza più alcuna terminazione attraverso codici di interruzione di riga.
unblock |
Esegue l'operazione opposta di block: il file in ingresso viene letto a blocchi di dimensione stabilita attraverso l'opzione cbs e gli spazi finali di ogni blocco vengono sostituiti con il codice di interruzione di riga.
lcase |
Trasforma le lettere maiuscole in minuscole.
ucase |
Trasforma le lettere minuscole in maiuscole.
swab |
Scambia le coppie di byte: ciò può essere utile quando i dati in questione sono interi a 16 bit da trasformare in, o da, una piattaforma Intel. (Nelle piattaforme Intel, gli interi a 16 bit sono scritti in modo da invertire la sequenza normale dei due byte che si utilizzano).
noerror |
Nel caso si verifichi un errore di lettura, continua ugualmente l'operazione.
notrunc |
Il file in uscita non viene troncato. Questo argomento è utile nel caso si scriva su file già esistenti: se dopo la trasformazione che si fa, la dimensione dei dati in uscita è inferiore a quella che ha già il file su cui si scrive, i dati rimanenti si lasciano come sono senza ridurre la dimensione di questo file.
sync |
Aggiusta la lunghezza di ogni blocco in ingresso, aggiungendo eventualmente il carattere <NUL> (0x00), in modo che la sua dimensione sia uguale a quanto stabilito attraverso l'opzione ibs.
Il programma dd viene usato normalmente per riprodurre le immagini di dischetti, anche se nella maggior parte dei casi è sufficiente usare cp.
---------
# dd if=disk.img of=/dev/fd0
In questo caso si trasferisce semplicemente il file disk.img nel dischetto (inizializzato precedentemente). Nessun'altra indicazione è stata data, per cui si presume che il file sia adatto al formato di dischetto che si sta utilizzando.
# dd if=disk.img of=/dev/fd0 obs=18k
Rispetto all'esempio precedente, si immagina di avere a disposizione un dischetto da 1440 Kbyte (e naturalmente che il file-immagine sia adatto a questo tipo di dischetto). Un dischetto da 3,5 pollici con questo formato è composto da cilindri contenenti 18+18 settori di 512 Kbyte: 2*18*512 = 18 Kbyte. Specificando l'opzione obs=18k si intende fare in modo che dd fornisca al dispositivo /dev/fd0 blocchi di quella dimensione per da facilitare l'operazione di scrittura.
# dd if=disk.img of=/dev/fd0 obs=18k count=80
Rispetto all'esempio precedente, viene specificato il numero di blocchi da scrivere: 80, pari al numero dei cilindri. In questo modo, se il file in ingresso fosse più grande, non ci sarebbe alcun tentativo di superare tale limite.
Lo spostamento è una sorta di copia e cancellazione dell'originale. Attraverso questo meccanismo si ottiene anche il cambiamento del nome di file e directory: un cambiamento di nome puro e semplice non è possibile. Questo fatto deve essere considerato quando si valutano le conseguenze dei permessi attribuiti ai file e alle directory, e quando si valuta l'eventuale pericolosità di questo tipo di operazione: cambiare nome a un file in modo errato può provocare la sovrascrittura di un altro.
La cancellazione è sempre l'operazione più pericolosa. Nei filesystem Second-extended non è molto facile recuperare i dati cancellati. Piuttosto di cancellare, sarebbe meno pericoloso spostare temporaneamente i file in una directory che funge da cestino. Nella sezione 54.2.3 viene mostrato uno script in grado di gestire agevolmente una sorta di cestino del genere.
mv [<opzioni>] <origine>... <destinazione> |
Sposta i file o le directory. Se vengono specificati solo i nomi di due elementi (file o directory), il primo viene spostato o rinominato in modo da ottenere quanto indicato come destinazione. Se vengono indicati più elementi (file o directory), l'ultimo argomento deve essere una directory: verranno spostati tutti gli elementi elencati nella directory di destinazione. Nel caso di spostamenti attraverso diversi filesystem, vengono spostati solo i file normali, e quindi: né collegamenti, né directory.
|
|
|
|
|
|
|
Le opzioni sopra indicate funzionano nello stesso modo di cp.
rm [<opzioni>] <nome>... |
Rimuove i file indicati come argomento. In mancanza dell'indicazione delle opzioni necessarie, non vengono rimosse le directory.
|
Rimuove il contenuto delle directory in modo ricorsivo.
|
Chiede una conferma esplicita per la cancellazione di ogni file.
|
Elimina le directory trattandole come se fossero dei file normali. In pratica, i file e le altre directory che dovessero eventualmente essere contenuti, non vengono rimossi prima: viene semplicemente interrotto il loro collegamento. L'operazione può essere pericolosa perché ci potrebbero essere dei file aperti al di sotto di queste directory che si rimuovono e questa situazione non verrebbe verificata. Inoltre, dopo un'azione di questo tipo, il filesystem deve essere controllato in modo da eliminare gli errori che si generano: la presenza di file senza riferimenti è un errore.
|
Ignora l'eventuale assenza di file per i quali si richiede la cancellazione e non chiede conferme all'utente. Può essere utile quando si prepara uno script e non è importante se ciò che si cancella esiste già o meno.
$ rm prova
Elimina il file prova.
$ rm ./-r
Elimina il file -r che inizia il suo nome con un trattino, senza confondersi con l'opzione -r
$ rm -r ~/varie
Elimina la directory varie/ che risiede nella directory personale dell'utente, insieme a tutte le sue eventuali sottodirectory.
rm è pericolosissimo perché è potente e irreversibile. Gli errori più frequenti, e disastrosi, sono causati da sbagli nella digitazione dei comandi o da cattiva valutazione dell'effetto di uno di questi. Ci sono tre cose da fare per ridurre i rischi di disastri:
evitare il più possibile di accedere come utente root;
controllare il comando che si vuole eseguire;
creare un alias in modo che rm funzioni sempre con l'opzione -i
Gli errori più frequenti da evitare sono i seguenti.
$ rm prova *
L'intenzione era quella di eliminare solo i file che iniziano con la parola prova, in realtà, si è inserito uno spazio involontario tra prova e l'asterisco. In tal modo, viene cancellato il file prova e poi tutto quello che si trova nella directory corrente.
$ rm -r .*
L'intenzione era quella di eliminare tutti i file e le directory nascoste (cioè tutto ciò che inizia con un punto) contenute nella directory corrente. In realtà si cancellano sì i file nascosti, ma con essi anche la directory corrente (.) e la directory precedente (..). In pratica, se i permessi dei file e delle directory lo permettono, si elimina tutto, PROPRIO TUTTO.
Il modo migliore per non sbagliare utilizzando rm è quello di non usarlo. Quello che segue è un esempio di uno script che invece di cancellare sposta i file e le directory in un cestino costituito da una directory speciale collocata nella propria directory personale.
#!/bin/bash
#======================================================================
# ricicla <file>...
#======================================================================
#======================================================================
# Variabili.
#======================================================================
#------------------------------------------------------------------
# Il nome del punto di inizio del sistema di riciclaggio.
#------------------------------------------------------------------
CESTINO="$HOME/.riciclaggio"
#------------------------------------------------------------------
# Questa variabile contiene un nome composto dall'anno, il mese,
# il giorno, le ore, i minuti e i secondi del momento in cui
# si esegue lo script.
# Questo nome verrà utilizzato per ottenere una directory
# che funga da contenitore dei file da riciclare.
#------------------------------------------------------------------
RICICLO=$(date +%Y%m%d%H%M%S)
#======================================================================
# Inizio.
#======================================================================
#------------------------------------------------------------------
# Verifica se esiste la directory di partenza del sistema di
# riciclaggio.
#------------------------------------------------------------------
if [ -e $CESTINO ]
then
#--------------------------------------------------------------
# Qualcosa con il nome del cestino esiste già.
# Si deve verificare che si tratti di una directory.
#--------------------------------------------------------------
if [ ! -d $CESTINO ]
then
#----------------------------------------------------------
# Non si tratta di una directory.
# Non si può procedere con il riciclaggio.
#----------------------------------------------------------
echo "Non è possibile procedere con il riciclaggio"
echo "perché $CESTINO esiste e non è una directory."
#----------------------------------------------------------
# Lo script termina restituendo un valore corrispondente
# a «falso».
#----------------------------------------------------------
exit 1
fi
else
#--------------------------------------------------------------
# La directory non esiste.
# Si tenta di crearla.
#--------------------------------------------------------------
if ! mkdir $CESTINO
then
#----------------------------------------------------------
# Non è stato possibile creare il cestino: forse
# ci sono problemi di permessi.
#----------------------------------------------------------
echo "Non è possibile creare la directory"
echo "$CESTINO"
#----------------------------------------------------------
# Lo script termina restituendo un valore corrispondente
# a «falso».
#----------------------------------------------------------
exit 1
fi
fi
#------------------------------------------------------------------
# Giunti a questo punto, dovrebbe esistere la directory
# $CESTINO. Si passa a creare la sottodirectory usata per
# questa particolare operazione di riciclaggio.
#------------------------------------------------------------------
if ! mkdir $CESTINO/$RICICLO
then
#--------------------------------------------------------------
# Non è stato possibile creare il cestino: forse
# ci sono problemi di permessi.
#--------------------------------------------------------------
echo "Non è possibile creare la directory"
echo "$CESTINO/$RICICLO"
#--------------------------------------------------------------
# Lo script termina restituendo un valore falso.
#--------------------------------------------------------------
exit 1
fi
#------------------------------------------------------------------
# A questo punto sono stati superati tutti gli ostacoli.
# Si procede con il trasferimento dei dati da eliminare.
# Se lo spostamento con «mv» non funziona, si tratta di un
# tentativo di spostare directory attraverso filesystem differenti.
#------------------------------------------------------------------
if ! mv $* $CESTINO/$RICICLO 2> /dev/null
then
#--------------------------------------------------------------
# Essendo fallito lo spostamento, almeno in parte, si procede
# con la copia.
# La copia viene fatta mantenendo i collegamenti simbolici
# come tali.
#--------------------------------------------------------------
if cp -dpR $* $CESTINO/$RICICLO 2> /dev/null
then
#----------------------------------------------------------
# La copia ha funzionato, si procede a eliminare l'origine.
#----------------------------------------------------------
rm -r $*
fi
fi
#------------------------------------------------------------------
# Si conclude con un resoconto.
#------------------------------------------------------------------
echo "I file seguenti sono stati trasferiti in $CESTINO/$RICICLO"
ls "$CESTINO/$RICICLO"
#======================================================================
# Fine.
#======================================================================
|
L'archiviazione è quel procedimento con cui si impacchettano file o rami di directory in modo da facilitarne la conservazione all'interno di unità di memorizzazione senza filesystem. Per lo stesso motivo, l'archiviazione è il modo con cui si possono trasferire agevolmente i dati attraverso piattaforme differenti.
L'archiviazione pura e semplice non ottiene alcun risparmio nello spazio utilizzato dai dati. Per questo si utilizza la compressione che permette di ridurre questo utilizzo.
|
L'archiviazione pura e semplice è ottenuta normalmente attraverso il programma |
Questo argomento viene ripreso anche nel capitolo dedicato alle copie di sicurezza ( 198).
cpio
|
cpio
|
cpio
|
Copia file da e verso archivi cpio o tar. L'archivio può essere un file su disco, un nastro magnetico o una pipe. Le tre sintassi indicate rappresentano le tre modalità operative del comando.
copy-out (archiviazione)
Dallo standard input viene letto un elenco di nomi di file (uno per riga) e l'archivio di questi file viene generato ed emesso attraverso lo standard output.
copy-in (lettura di un archivio)
Dallo standard input viene letto il contenuto di un archivio dal quale si possono estrarre i file in esso contenuti.
copy-pass (copia)
Dallo standard input viene letto un elenco di nomi di file (uno per riga) e questi file (con il loro contenuto) vengono copiati nella directory di destinazione.
Vedere cpio.info o cpio(1).
|
Funziona in modalità copy-out.
|
Aggiunge dati a un archivio esistente che deve essere specificato con l'opzione -O
|
Quando incontra dei collegamenti simbolici, copia i file a cui questi puntano, invece di copiare semplicemente i collegamenti.
|
Specifica il nome dell'archivio da creare o incrementare, invece di utilizzare lo standard output.
|
Funziona in modalità copy-in.
|
Crea le directory necessarie.
|
Legge il modello che esprime i nomi dei file da estrarre, o l'elenco dei nomi stessi, dal file indicato come argomento dell'opzione.
|
Copia soltanto i file che non corrispondono al modello indicato.
|
Permette di specificare il nome dell'archivio da usare, invece di riceverlo dallo standard input.
|
Elenca il contenuto dell'archivio.
|
Funziona in modalità copy-pass.
|
Crea le directory necessarie.
|
Se possibile, crea dei collegamenti invece di copiare i file.
|
Quando incontra dei collegamenti simbolici, copia i file a cui questi puntano, invece di copiare semplicemente i collegamenti.
$ cpio -o < elenco > /tmp/archivio.cpio
Archivia i file e le directory elencati nel file elenco generando il file /tmp/archivio.cpio.
$ cat *.sgml | cpio -o > /tmp/archivio.cpio
Archivia i file e le directory corrispondenti al modello *.sgml generando il file /tmp/archivio.cpio.
$ find lavoro -print | cpio -o > /tmp/archivio.cpio
Archivia la directory lavoro/, e tutto il suo contenuto, generando il file /tmp/archivio.cpio.
$ cpio -i -t < /tmp/archivio.cpio
Elenca il contenuto dell'archivio /tmp/archivio.cpio.
$ cpio -i < /tmp/archivio.cpio
estrae l'archivio /tmp/archivio.cpio a partire dalla directory corrente.
$ cpio -p < elenco > /tmp/prova
Copia i file e le directory elencati nel file elenco nella directory /tmp/prova/.
tar <opzione-di-funzionamento> [<opzioni>] <file>... |
tar (Tape ARchive) è un programma di archiviazione nato originariamente per essere usato con i nastri. Il primo argomento deve essere una delle opzioni che ne definisce il funzionamento. Alla fine della riga di comando vengono indicati i nomi dei file o delle directory da archiviare. Se non viene specificato diversamente attraverso le opzioni, l'archivio viene emesso attraverso lo standard output.
Il tar tradizionale ammette l'uso di opzioni senza il trattino anteriore (-tar GNU a cui si fa riferimento in questa sezione, ma questa forma deve essere usata consapevolmente e con prudenza. Negli esempi verrà mostrato in che modo potrebbero essere usate tali opzioni senza trattino.
Per la descrizione completa di questo programma, conviene consultare tar(1).
Un gruppo di opzioni rappresenta l'operazione da compiere. Di queste, può e deve esserne utilizzata una sola. Di solito, data l'importanza di queste opzioni, queste appaiono all'inizio degli argomenti di tar.
---------
A | |
Aggiunge dei file tar a un archivio già esistente.
c | |
Crea un nuovo archivio.
d | |
Trova le differenze tra l'archivio e i file esistenti effettivamente.
|
Cancella dall'archivio i file indicati. Non può essere usato per un archivio su nastro.
r | |
Aggiunge dati a un archivio già esistente.
t | |
Elenca il contenuto di un archivio.
u | |
Aggiunge solo i file più recenti rispetto a quanto già contenuto nell'archivio.
x | |
Estrae i file da un archivio.
|
Fa in modo che la data di accesso dei file che vengono archiviati non venga modificata.
|
Emette l'archivio nel file o nel dispositivo. Se si tratta di un file normale, questo viene creato.
|
Non copia i collegamenti simbolici, ma i file a cui questi fanno riferimento.
|
In fase di estrazione da un archivio, non sovrascrive i file eventualmente già esistenti.
|
Quando viene creato un archivio, resta in un solo filesystem: quello di partenza.
|
Definisce la dimensione massima dei vari segmenti di copia multivolume.
|
In fase di estrazione da un archivio, non viene ripristinata la data di modifica dei file.
|
Permette di creare, elencare o estrarre, un archivio multivolume.
|
Archivia solo i file la cui data è più recente di quella indicata come argomento.
|
Estrae i file emettendoli attraverso lo standard output.
|
Estrae tutti i permessi associati ai file. Se non viene usata questa opzione, i file ottengono i permessi predefiniti, anche in funzione della maschera dei permessi dell'utente che esegue l'operazione.
|
Estrae i file utilizzando i percorsi assoluti, cioè senza eliminare la prima barra (/) che appare nei nomi di percorso (pathname).
|
In fase di creazione di un nuovo archivio, elimina i file archiviati.
|
Durante l'estrazione da un archivio, assegna ai file estratti gli utenti e i gruppi proprietari originali.
|
Elenca i file che vengono elaborati.
|
Cerca di verificare la validità dell'archivio dopo averlo creato.
|
Filtra l'archivio attraverso il programma di compressione compress.
|
Filtra l'archivio attraverso il programma di compressione gzip.
|
Filtra l'archivio attraverso il programma di compressione indicato nell'argomento. Questo programma di compressione deve riconoscere l'opzione -dgzip, allo scopo di decomprimere i dati.
# tar -c -f /dev/fd0 -L 1440 -M -v /usr
Archivia la directory /usr/ con tutto il suo contenuto, comprese le sottodirectory, utilizzando i dischetti (da 1440 Kbyte).
|
Con la copia multivolume, come in questo caso, non è possibile utilizzare la compressione automatica attraverso l'opzione |
# tar cf /dev/fd0 -L 1440 -M -v /usr
Esattamente come nell'esempio precedente, con la differenza che le opzioni -c-f
# tar cvf /dev/fd0 -L 1440 -M /usr
Esattamente come nell'esempio precedente.
# tar -cfv /dev/fd0 -L 1440 -M /usr
# tar cfv /dev/fd0 -L 1440 -M /usr
Questi due esempi sono identici, ed errati. Non è possibile accodare lettere di altre opzioni dopo la f, dal momento che questa richiede un argomento.
|
In molti documenti su |
$ tar -t -f /dev/fd0 -L 1440 -M -v
Visualizza l'elenco del contenuto dell'archivio fatto su dischetti.
$ tar -x -f /dev/fd0 -L 1440 -M -v -p --same-owner
Estrae il contenuto dell'archivio su dischetti a partire dalla posizione corrente.
|
È probabile che l'opzione |
$ tar xpvf /dev/fd0 -L 1440 -M --same-owner
Come nell'esempio precedente, aggregando alcune opzioni e togliendo il trattino iniziale di queste.
$ tar -c -f /tmp/archivio.tgz -z -v /usr
Archivia il contenuto della directory /usr/ nel file /tmp/archivio.tgz dopo averlo compresso con gzip.
$ tar czvf /tmp/archivio.tgz /usr
Come nell'esempio precedente.
gzip [<opzioni>] [<file>...] |
gzip è un programma di compressione attraverso il quale viene creato un file compresso per ogni file indicato negli argomenti. gzip è in grado di comprimere solo file normali (regular file) e soltanto singolarmente: per ogni file ne viene generato un altro con l'estensione .gz o un'altra se specificato diversamente con le opzioni. Se non viene indicato alcun file o se si utilizza espressamente un singolo trattino isolato (-
Vedere gzip.info o gzip(1).
|
Emette il risultato attraverso lo standard output. gzip si comporta con questa opzione predefinita quando viene eseguito con il nome zcat.
|
Decomprime un file compresso. gzip si comporta con questa opzione predefinita quando viene eseguito con il nome gunzip.
|
Se tra i nomi indicati nella riga di comando appaiono delle directory, vengono compressi o decompressi tutti i file in esse contenuti.
|
Controlla l'integrità dei file compressi.
|
Permette di definire il livello di compressione: -1-9-6
$ gzip *.sgml
Comprime i file *.sgml, utilizzando un livello intermedio di compressione, sostituendo i file originali con quelli compressi: *.sgml.gz.
$ gzip -d *.sgml.gz
Espande i file corrispondenti al modello *.sgml.gz, togliendo loro l'estensione .gz.
$ cat pippo | gzip -9 > pippo.gz
Genera il file pippo.gz come risultato della compressione di pippo. In particolare, viene utilizzato il livello di compressione massima, e il file originale non viene cancellato.
$ cat pippo.gz | gzip -d > pippo
Fa l'opposto dell'esempio precedente: espande il file pippo.gz generando pippo, senza cancellare il file originale.
gunzip come programma autonomo non esiste: è un collegamento a gzip. Se gzip viene avviato con il nome gunzip si comporta come se fosse stata utilizzata l'opzione -d
zcat come programma autonomo non esiste: è un collegamento a gzip. Se gzip viene avviato con il nome zcat si comporta come se fosse stata utilizzata l'opzione -c
bzip2 [<opzioni>] [<file>...] |
bzip2 è un programma di compressione funzionalmente analogo a gzip, nel senso che viene creato un file compresso per ogni file indicato negli argomenti. bzip2, come gzip, è in grado di comprimere solo file normali (regular file) e soltanto singolarmente: per ogni file ne viene generato un altro con l'estensione .bz2. Se non viene indicato alcun file o se si utilizza espressamente un singolo trattino isolato (-
bzip2 utilizza un algoritmo di compressione differente, rispetto a gzip, con un carico di elaborazione maggiore, e diventa efficace solo in presenza di file di grandi dimensioni. In generale, per garantire la massima portabilità di un archivio compresso, conviene utilizzare gzip, salvo quando le dimensioni dell'archivio sono tali da rendere realmente conveniente l'utilizzo di bzip2.
La sintassi di bzip2 è molto simile a quella di gzip, anche se non è del tutto identica. Prima di decidere di utilizzare bzip2 per archiviare i propri dati, conviene leggere la documentazione originale, bzip2(1), in modo da poter valutare correttamente.
|
Comprime o decomprime emettendo il risultato attraverso lo standard output. La decompressione ammette l'emissione di più file, mentre in caso di compressione, se ne può emettere solo uno.
|
Forza la modalità di decompressione dei dati. bzip2 si comporta con questa opzione predefinita quando viene eseguito con il nome bunzip2.
|
Forza la modalità di compressione dei dati. Serve a imporre la compressione, indipendentemente dal nome utilizzato per avviare bzip2.
|
Controlla l'integrità dei file compressi.
|
Permette di definire il livello di compressione: -1-9
bunzip2 [<opzioni>] [<file>...] |
bunzip2 è un collegamento a bzip2, il quale, se avviato con questo nome, utilizza implicitamente l'opzione -d
Quello che segue è l'esempio di un semplice script per l'archiviazione di una serie di file e directory attraverso la coppia tar e gzip.
#!/bin/bash
#======================================================================
# salva <directory-di-destinazione> < <elenco>
#
# Archiviazione di tutti i file e directory indicati attraverso lo
# standard input, utilizzando <directory-di-destinazione> come luogo
# di destinazione degli archivi.
#
# Gli archivi vengono generati in formato .tgz, cioè tar+gzip.
#======================================================================
#======================================================================
# Variabili.
#======================================================================
#------------------------------------------------------------------
# L'elenco dei file e delle directory da archiviare proviene dallo
# standard input.
#------------------------------------------------------------------
ELENCO_DA_ARCHIVIARE=`cat`
#------------------------------------------------------------------
# Directory di destinazione.
#------------------------------------------------------------------
DESTINAZIONE=$1
#======================================================================
# Funzioni.
#======================================================================
#------------------------------------------------------------------
# Visualizza la sintassi corretta per l'utilizzo di questo script.
#------------------------------------------------------------------
function sintassi () {
echo ""
echo "cat elenco | $0 <directory-di-destinazione>"
echo ""
}
#======================================================================
# Inizio.
#======================================================================
#------------------------------------------------------------------
# Verifica la quantità di argomenti.
#------------------------------------------------------------------
if [ $# != 1 ]
then
#--------------------------------------------------------------
# La quantità di argomenti è errata. Richiama la funzione
# «sintassi» e termina l'esecuzione dello script restituendo
# un valore corrispondente a «falso».
#--------------------------------------------------------------
sintassi
exit 1
fi
#------------------------------------------------------------------
# Verifica se esiste la directory di destinazione.
#------------------------------------------------------------------
if [ -e $DESTINAZIONE ]
then
#--------------------------------------------------------------
# Qualcosa con quel nome esiste già.
# Si deve verificare che si tratti di una directory.
#--------------------------------------------------------------
if [ ! -d $DESTINAZIONE ]
then
#----------------------------------------------------------
# Non si tratta di una directory.
#----------------------------------------------------------
echo "Non è possibile procedere con l'archiviazione"
echo "perché $DESTINAZIONE esiste e non è una directory."
#----------------------------------------------------------
# Lo script termina restituendo un valore corrispondente
# a «falso».
#----------------------------------------------------------
exit 1
fi
else
#--------------------------------------------------------------
# La directory non esiste.
# Si tenta di crearla.
#--------------------------------------------------------------
if ! mkdir $DESTINAZIONE
then
#----------------------------------------------------------
# Non è stato possibile creare la directory
#----------------------------------------------------------
echo "Non è possibile creare la directory"
echo "$DESTINAZIONE"
#----------------------------------------------------------
# Lo script termina restituendo un valore corrispondente
# a «falso».
#----------------------------------------------------------
exit 1
fi
fi
#------------------------------------------------------------------
# Giunti a questo punto, dovrebbe esistere la directory
# di destinazione.
# Inizia il ciclo di archiviazione.
#------------------------------------------------------------------
for DA_ARCHIVIARE in $ELENCO_DA_ARCHIVIARE
do
#--------------------------------------------------------------
# Estrae il nome del file o della directory senza il suo
# percorso.
#--------------------------------------------------------------
BASE_NAME=`basename $DA_ARCHIVIARE`
#--------------------------------------------------------------
# Comprime il file o il contenuto del directory ottenendo un
# file compresso con lo stesso nome e l'aggiunta
# dell'estensione «.tgz».
# Si utilizza «tar» specificando in particolare l'opzione «z»
# che permette di comprimere automaticamente l'archivio
# attraverso «gzip»;
#--------------------------------------------------------------
tar czvf $DESTINAZIONE/$BASE_NAME.tgz $DA_ARCHIVIARE
done
#------------------------------------------------------------------
# L'operazione di archiviazione e' terminata.
#------------------------------------------------------------------
echo "L'archiviazione e' terminata."
#======================================================================
# Fine.
#======================================================================
|
---------------------------
Appunti Linux 1999.09.21 --- Copyright © 1997-1999 Daniele Giacomini -- daniele @ pluto.linux.it