Quelle indicate nel titolo sono le fasi fondamentali dell'amministrazione dei dati. Nello stesso modo sono anche le operazioni più delicate.
La tabella (seguente) elenca i programmi a cui si accenna in questo capitolo.
La copia genera un altro file o un'altra directory, il link 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 link sono molto importanti e vengono usati di frequente. Si distinguono due tipi di questi: link simbolici e link hard. Attraverso il link hard si creano dei riferimenti a dati esistenti in modo non distinguibile da quelli originali; i link simbolici sono dei file speciali e per questo distinguibili dai file originali.
L'esistenza dei link simbolici altera la logica normale della copia: ha senso copiare i file a cui i link puntano o ha senso copiare i link? Solitamente si considera che la gestione dei link 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 link.
A fianco del problema della copia di file (o 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).
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.
-a | --archive
Equivalente a -dpR, utile per l'archiviazione
o comunque per la copia di link simbolici
così come sono.
-b | --backup
Mantiene delle copie di backup per i file che vengono sovrascritti con la copia.
-d | --no-dereference
Copia i link simbolici mantenendoli come tali, invece di copiare il file a cui i link si riferiscono.
-f | --force
Sovrascrittura forzata dei file di destinazione.
-i | --interactive
Richiede una conferma per la sovrascrittura nel caso in cui esistano già dei file con i nomi uguali a quelli di destinazione della copia.
-l | --link
Crea un hard link invece di copiare i file (non vale per le directory).
-s | --symbolic-link
Crea un link simbolico invece di copiare i file (non vale per le directory).
-P | --parents
Copia anche il percorso indicato nel file di origine.
-p | --preserve
Mantiene le proprietà, i permessi originali e le date originali.
-R | --recursive
Copia file e directory in modo ricorsivo (includendo le sottodirectory).
-S <suffisso-di-backup> | --suffix=<suffisso-di-backup>
Permette di definire il suffisso da utilizzare per le eventuali copie di backup. Se non viene specificato con questa opzione, si utilizza il simbolo contenuto nella variabile di ambiente SIMPLE_BACKUP_SUFFIX e se anche questa variabile non è stata predisposta, si utilizza ~ (tilde).
-V <tipo-di-backup> | --version-control=<tipo-di-backup>
Permette di definire esplicitamente il modo con cui
gestire le copie di backup, quando si usa
anche l'opzione -b.
Il tipo di backup viene definito in base
ai termini seguenti.
t | numbered
Esegue un backup numerato.
nil | existing
Esegue un backup numerato per i soli file che hanno già almeno una versione di backup.
never | simple
Esegue un backup semplice.
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 backup (ovvero 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 di backup.
$ cp -r /test/* ~/prova
Copia il contenuto delle 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.
cp può essere pericoloso perché può sovrascrivere altri file senza
preavviso.
Per ridurre le possibilità di errori, conviene creare un alias in modo
che cp funzioni sempre con l'opzione -i.
Se poi si ha la necessità di sovrascrivere i file di destinazione, si può sempre
utilizzare l'opzione --force.
ln [<opzioni>] <origine> <destinazione>
ln [<opzioni>] <origine>... <directory>
Crea un collegamento (link) tra file e/o directory. Se viene specificata una origine e una destinazione, il nome indicato come destinazione sarà il nuovo link 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 all'interno della directory di destinazione verranno creati tanti link quanti sono i nomi indicati come origine. Se non viene specificato diversamente attraverso le opzioni, vengono creati degli hard link e non dei link simbolici.
-b | --backup
-f | --force
-i | --interactive
-S | --suffix
-V | --version-control
Le opzioni sopra indicate funzionano nello stesso modo di cp ( cp).
---------
-s | --symbolic-link
Crea un link simbolico invece di crearne uno hard.
-d | -F | --directory
Permette all'utente root di creare un hard link per una directory.
-n | --no-dereference
Quando la destinazione corrisponde a un link simbolico preesistente
che punta verso una directory, il funzionamento normale prevederebbe la creazione
del link in quella directory.
Usando questa opzione si intende evitare questo
rimpiazzando quel link simbolico.
Per poter attuare questo, occorre però utilizzare
anche l'opzione --force.
ln utilizza le variabili di ambiente VERSION_CONTROL e SIMPLE_BACKUP_SUFFIX nello stesso modo di cp ( cp).
$ ln -s /bin/ls ~/elenco
Crea il link simbolico elenco all'interno della directory home che punta al comando ls. Eseguendo ~/elenco si ottiene in pratica di eseguire il comando ls.
$ ln /bin/ls ~/elenco
Crea un hard link elenco all'interno della directory home che punta al comando ls. Eseguendo ~/elenco si ottiene in pratica di eseguire il comando ls.
$ ln -s /bin/* ~/
Crea una serie di link simbolici all'interno della directory home per tutti i file contenuti in /bin.
$ ln -s /bin ~/binari
Crea il link simbolico binari alla directory /bin. Eseguendo cd ~/binari ci si ritroverà in /bin.
install [<opzioni>] <origine>... <destinazione>
install [<opzioni>]
-d <directory>...
Copia di file, attribuzione dei permessi e delle proprietà. Il comando 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. È tipicamente usato per l'installazione di programmi.
-b | --backup
-S | --suffix
-V | --version-control
Le opzioni sopra indicate funzionano nello stesso modo di cp ( cp).
---------
-d <directory>... | --directory=<directory>...
Crea le directory indicate, definisce l'utente proprietario, il gruppo proprietario ed i permessi.
-g <gruppo> | --group=<gruppo>
Definisce il gruppo proprietario dei file installati o delle directory.
-m <modo> | --mode=<modo>
Definisce i permessi in modo analogo alla sintassi di chmod ( chmod).
-o <proprietario> | --owner=<proprietario>
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 (-).
Se tra le opzioni, non vengono definiti i file di input e/o di output, si usano
rispettivamente lo standard input e lo standard output.
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:
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 (
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 attraverso un 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 carattere
newline (
In pratica, il risultato finale è quello di un file con i record di
dimensione uguale e per questo senza più alcuna terminazione attraverso
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 un unico carattere.
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 short (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 qui 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
Il programma dd viene normalmente usato 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 (precedentemente inizializzato). 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 1440KB (e naturalmente che il file di 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 512KB: 2*18*512 = 18KB. Specificando l'opzione obs=18k si intende fare in modo che dd fornisca al dispositivo /dev/fd0 blocchi di quella dimensione in modo 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 la 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 ext2 (Linux native) non esiste la possibilità di recuperare i dati cancellati. Piuttosto di cancellare, sarebbe meno pericoloso spostare temporaneamente i file in una directory che funge da cestino. Nella sezione `Cestino personale' viene mostrato uno script in grado di gestire agevolmente una sorta di cestino del genere.
mv [<opzioni>]
<origine>... <destinazione>
Sposta i file e/o le directory. Se vengono specificati solo i nomi di due elementi (file o directory), il primo viene spostato e/o rinominato in modo da ottenere quanto indicato come destinazione. Se vengono indicati più elementi (file o directory), l'ultimo attributo 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 cosiddetti file regolari (quindi: no link, no directory).
-b | --backup
-f | --force
-i | --interactive
-S | --suffix
-V | --version-control
Le opzioni sopra indicate funzionano nello stesso modo di cp ( cp).
mv può essere pericoloso perché può sovrascrivere altri file senza
preavviso.
Per ridurre le possibilità di errori, conviene creare un alias in modo
che mv funzioni sempre con l'opzione -i.
Se poi si ha la necessità di sovrascrivere i file di destinazione, si può sempre
utilizzare l'opzione --force.
rm [<opzioni>] <nome>...
Rimuove i file indicati come argomento. In mancanza dell'indicazione delle opzioni necessarie, non vengono rimosse le directory.
-r | -R | --recursive
Rimuove il contenuto delle directory in modo ricorsivo.
-i | --interactive
Chiede una conferma esplicita per la cancellazione di ogni file.
-d | --directory
Elimina le directory trattandole come se fossero dei file normali. in pratica, i file e le eventuali altre directory contenute 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 una 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.
-f | --force
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 (ricorsione).
$ rm -r ~/varie
Elimina la directory varie che risiede nella directory home, 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 un questi. Ci sono tre cose da fare per ridurre i rischi di disastri:
-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 home.
#!/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
# utilizzata come 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 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 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 diversi filesystem.
#------------------------------------------------------------------
if ! mv $* $CESTINO/$RICICLO 2> /dev/null
then
#--------------------------------------------------------------
# Essendo fallito lo spostamento, almeno in parte, si procede
# con la copia.
# La copia viene fatta senza dereferenziare i link.
#--------------------------------------------------------------
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 "Presumibilmente, sono stati trasferiti i file seguenti:"
echo "$*"
echo "in $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 attraverso 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.
Questo argomento viene ripreso anche nel capitolo dedicato alle copie di sicurezza ( `Copie di sicurezza').
cpio
-o [<opzioni>] [< <elenco-nomi>] [> <archivio>]
cpio
-i [<opzioni>] [<modello>] [< <archivio>]
cpio
-p [<opzioni>] <directory-di-destinazione> [< <elenco-nomi>]
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.
Dallo standard input viene letto un elenco di nomi di file (uno per riga) e questi file (con il loro contenuto) vengono copiati nello standard output.
Dallo standard input viene letto il contenuto di un archivio dal quale si possono estrarre i file in esso contenuti.
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 info cpio o cpio(1).
-o | --create
-A | --append
Aggiunge dati a un archivio esistente che
deve essere specificato con l'opzione
-O.
-L | --dereference
Quando incontra dei link simbolici, copia i file a cui questi puntano, invece di copiare semplicemente i link.
-O <nome-archivio>
Specifica il nome dell'archivio da creare o incrementare, invece di utilizzare lo standard output.
-i | --extract
-d | --make-directories
Crea le directory necessarie.
-E <file> | --pattern-file=<file>
Legge il modello che esprime i nomi dei file da estrarre, o l'elenco dei nomi stessi, dal file indicato come argomento dell'opzione.
-f | --nomatching
Copia soltanto i file che non corrispondono al modello indicato.
-I <archivio>
Permette di specificare il nome dell'archivio da usare, invece di riceverlo dallo standard input.
-t | --list
Elenca il contenuto dell'archivio.
-p | --pass-through
-d | --make-directories
Crea le directory necessarie.
-l | --link
Se possibile, crea dei link invece di copiare i file.
-L | --dereference
Quando incontra dei link simbolici, copia i file a cui questi puntano, invece di copiare semplicemente i link.
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.
Per la descrizione completa di questo programma, conviene consultare tar(1).
-A | --catenate | --concatenate
Aggiunge dei file tar a un archivio già esistente.
-c | --create
Crea un nuovo archivio.
-d | --diff | --compare
Trova le differenze tra l'archivio e i file esistenti effettivamente.
--delete
Cancella dall'archivio i file indicati. Non può essere usato per un archivio su nastro.
-r | --append
Aggiunge dati a un archivio già esistente.
-t | --list
Elenca il contenuto di un archivio.
-u | --update
Aggiunge solo i file più recenti rispetto a quanto già contenuto nell'archivio.
-x | --extract | --get
Estrae i file da un archivio.
--atime-preserve
Fa in modo che la data di accesso dei file che vengono archiviati, non venga modificata.
-f <file> | --file=<file>
Emette l'archivio nel file o nel dispositivo. Se si tratta di un file normale, questo viene creato.
-h | --dereference
Non copia i link simbolici, ma i file a cui questi fanno riferimento.
-k | --keep-old-files
In fase di estrazione da un archivio, non sovrascrive i file eventualmente già esistenti.
-l | --one-file-system
Quando viene creato un archivio, resta in un solo filesystem: quello di partenza.
-L <Kilobyte> | --tape-lenght=<Kilobyte>
Definisce la dimensione massima dei vari segmenti di copia multivolume.
-m | --modification-time
In fase di estrazione da un archivio, non viene ripristinata la data di modifica dei file.
-M | --multi-volume
Permette di creare, elencare o estrarre un archivio multivolume.
-N <data> | --after-date=<data> | --newer <data>
Archivia solo i file la cui data è più recente di quella indicata come argomento.
-O | --to-stdout
Estrae i file nello standard output.
-p | --same-permissions | --preserve-permissions
Estrae tutti i permessi associati ai file.
-P | --absolute-path
Estrae i file utilizzando i percorsi assoluti, cioè senza eliminare la prima barra (/) che appare nei nomi di percorso (pathname).
--remove-files
In fase di creazione di un nuovo archivio, elimina i file archiviati.
--same-owner
Durante l'estrazione da un archivio, assegna ai file estratti le proprietà originali.
-v | --verbose
Elenca i file che vengono elaborati.
-W | --verify
Cerca di verificare la validità dell'archivio dopo averlo creato.
-Z | --compress | --uncompress
Filtra l'archivio attraverso il programma di compressione compress.
-z | --gzip | --ungzip
Filtra l'archivio attraverso il programma di compressione gzip.
# 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 1440KB).
<!>
Con la copia multivolume, come in questo caso, non è possibile utilizzare la compressione
automatica attraverso l'opzione -z o -Z.
$ 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 le opzioni -p e
--same-owner siano già predefinite a causa di
una opportuna modifica fatta da chi ha realizzato la distribuzione Linux.
In ogni caso vale la pena di ricordarsene.
$ 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.
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 di dati
(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
(-), lo standard input viene
compresso e il risultato viene emesso attraverso lo
standard output.
Vedere info gzip o gzip(1).
-c | --stdout | --to-stdout
Emette il risultato attraverso lo standard output. gzip si comporta con questa opzione predefinita quando viene eseguito con il nome zcat.
-d | --decompress | --uncompress
Decomprime un file compresso. gzip si comporta con questa opzione predefinita quando viene eseguito con il nome gunzip.
-r | --recursive
Se tra i nomi indicati nella riga di comando appaiono delle directory, vengono compressi o decompressi tutti i file in esse contenuti.
-t | --test
Controlla l'integrità dei file compressi.
gunzip come programma autonomo non esiste: è
un link a gzip.
Se gzip viene avviato con il nome gunzip si comporta come se
fosse stata utilizzata l'opzione -d.
Il link verso gzip può essere sia simbolico che non.
zcat come programma autonomo non esiste: è
un link a gzip.
Se gzip viene avviato con il nome zcat si comporta come se
fosse stata utilizzata l'opzione -c.
Il link verso gzip può essere sia simbolico che non.
Quello che segue è un 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>
#
# 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
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 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 falso.
#----------------------------------------------------------
exit 1
fi
fi
#------------------------------------------------------------------
# Giunti a questo punto, dovrebbe esistere la directory
# di destinazione.
# Inizia il loop 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'estenzione ``.tgz''.
# Si utilizza ``tar'' e in particolare:
# ``-z'' permette di comprimere automaticamente l'archivio
# attraverso ``gzip'';
#--------------------------------------------------------------
tar -c -f $DESTINAZIONE/$BASE_NAME.tgz -v -z \
--same-permissions --same-owner --same-order $DA_ARCHIVIARE
done
#------------------------------------------------------------------
# L'operazione di archiviazione e' terminata.
#------------------------------------------------------------------
echo "L'archiviazione e' terminata."
#======================================================================
# Fine.
#======================================================================
1997.10.26 - Scritto da Daniele Giacomini daniele@calion.com (vedi copyright: Appunti Linux).