Lorenzo Masetti
mkdir immagini mv *.gif *.jpg immagini
Ad esempio ls è un comando interno della shell che scrive il contenuto della directory corrente, emacs è un programma esterno però si invocano entrambi scrivendo il nome del comando o del programma.
La shell si presenta come un prompt che invita l'utente a scrivere un comando, ad esempio
guest@curzio:/home/guest/#
Nel prompt vengono scritte delle informazioni utili. Tipicamente vengono scritti il nome dell'utente, la directory corrente e a volte il nome del computer su cui si opera. Nell'esempio si vede che l'utente guest è sul computer curzio nella directory /home/guest.
Ogni utente ha una sua home directory. Appena fatto il login per ogni utente viene aperta una shell e la directory corrente è la sua home.
<nome comando> <opzioni (precedute da -)> <parametri>
Red Hat Linux release 7.1 (Seawolf) Kernel 2.4.2-2 on an i686 curzio login: guest Password: guest Last login: Sat Nov 21 10:12:48 on tty2 Il System Manager ti saluta You have mail. guest@curzio ~$
Questo significa che vi identificate e autenticate con il
sistema con una conversazione del genere:
Io sono un sistema Linux Red Hat versione 7.1 soprannominato
Seawolf, lupo di mare. La mia versione di kernel è
2.4.2-2 e giro su un computer che ha un processore della
famiglia intel versione 686. Il mio nome è curzio.
chi va là ? sono quello che tu chiami guest
parola d'ordine ? guest
Naturalmente quando scrivete la password non appare niente sul video, per proteggervi da sguardi indiscreti, neanche degli asterischi (che rivelerebbero la lunghezza della password)
il sistema (in realtà un ben preciso programma che, guarda il caso, si chiama login) controlla che esista un utente con il nome dato (username, non nome effettivo), e che la password corrisponda a quella registrata nel file /etc/passwd
Quando il login ha successo viene visualizzata di solito la data dell'ultimo login (così si può controllare se qualcuno è entrato con il nostrto account), un messaggio che l'amministratore di sistema ha preparato per voi (naturalmente può variare) e eventualmente un messaggio che vi informa che avete della posta nella vostra casella di posta locale.
A questo punto, avete una "identità": lo username, a cui corrisponde uno userid (o uid) numerico; e appartenete ad alcuni gruppi, a cui corrispondono dei groupid (o gid) numerici.
Nota: Questa "identità" spesso viene chiamata "account" : "conto" nel senso di conto bancario o simili - il nome deriva dai tempi in cui i grandi computer venivano utilizzati in batch o in time sharing, e agli utilizzatori veniva fatto pagare in proporzione a quanto "tempo di CPU" veniva utilizzato dall'utente - quindi a ogni utente corrispondeva appunto un conto a cui addebitare l'utilizzo.
Potete controllare la vostra identità con il comando whoami (chi sono io?). Naturalmente è possibile cambiare utente senza effettuare il login da capo ma ne parleremo nel paragrafo 2.2.
Una volta terminato il lavoro ricordatevi di uscire dalla shell con il comando logout o semplicemente premendo CTRL-D.
guest@curzio ~$ ls autosave Desktop GNUstep guest@curzio ~$
Il comando ls può prendere come parametro una directory e allora scriverà la lista di quella directory. Oppure può prendere come directory un file semplice (o più file) e allora listerà solo quel (quei) file. Questo può avere senso con l'opzione -l oppure con il meccanismo di espansione dei comandi (cfr. paragrafo 1.10)
guest@curzio ~$ ls / bin dev home lost+found mnt proc sbin shlib10 usr boot etc lib misc opt root shbin10 tmp var guest@curzio ~$
Alcune opzioni da provare
Ricordati:
Ricordatevi la differenza tra percorsi (path) assoluti e percorsi relativi: i percorsi assoluti iniziano con / e identificano il percorso di un file muovendosi tra le varie directory. Le directory sono divise dallo slash / e non dal backslash (\) come in DOS. Invece i percorsi relativi identificano il percorso da seguire a partire dalla directory attuale.
Esempi
guest@curzio ~$ cd / guest@curzio /$ ls bin dev home lost+found mnt proc sbin shlib10 usr boot etc lib misc opt root shbin10 tmp var guest@curzio /$ cd /usr/ guest@curzio /usr$ cd local/bin/ guest@curzio /usr/local/bin$ cd guest@curzio ~$ pwd /home/guest guest@curzio ~$
Esempi di percorsi relativi e corrispondente path assoluto
| pwd | relativo | assoluto |
|---|---|---|
| /home/guest | prova/ | /home/guest/prova |
| /home/guest | ../carlo | /home/carlo |
| / | usr/bin | /usr/bin |
| /usr/local | bin/ | /usr/local/bin/ |
| /usr/local/bin | ../../lib | /usr/lib |
Lo storico dei comandi: usando le frecce in su e in giu si possono scorrere i comandi precedenti.
Esempio:
guest@curzio ~$ cd /u (premere tab) guest@curzio ~$ cd /usr/ (premere l e poi tab) guest@curzio ~$ cd /usr/l lib libexec local guest@curzio ~$ cd /usr/l (premere o e poi tab) guest@curzio ~$ cd /usr/local/ guest@curzio /usr/local$
Nota: Non potete pretendere che la bash vi legga nel pensiero. Se state creando un nuovo file di nome precipitevolissimevolmente non potete sperare di scrivere prec e poi premere Tab :-)
mkdir nomedirectory1 [ nomedirectory2 ... nomedirectoryN ]
cp file_sorgente file_destinazione cp file_sorgente1 ... file_sorgenteN directory_destinazione
Esempio:
guest@curzio ~$ mkdir prova guest@curzio ~$ cd prova guest@curzio ~/prova$ cp /etc/passwd . guest@curzio ~/prova$ ls passwd guest@curzio ~/prova$ cp passwd curzio guest@curzio ~/prova$ ls curzio passwd guest@curzio ~/prova$ mkdir malaparte guest@curzio ~/prova$ cp curzio passwd malaparte/ guest@curzio ~/prova$ ls malaparte/ curzio passwd guest@curzio ~/prova$
Cosa succede se dò più di due parametri ma l'ultimo non è una directory?
guest@curzio ~/prova$ cp curzio passwd pippo cp: copying multiple files, but last argument `pippo' is not a directory Usare `cp --help' per ulteriori informazioni.
Opzioni:
guest@curzio ~/prova$ ls -F curzio malaparte/ passwd guest@curzio ~/prova$ cp -R malaparte/ benigni guest@curzio ~/prova$ ls -F benigni/ curzio malaparte/ passwd guest@curzio ~/prova$ ls benigni/ curzio passwd
L'utilizzo di rm è pericoloso perchè i file cancellati non possono essere recuperati in alcun modo. Bisogna quindi stare attenti prima di premere invio. Questo comando non è amichevole, non solo non chiede conferma prima di cancellare ma se gli passiamo una lista di file e alcuni nomi sono sbagliati, cancellerà lo stesso i file di cui abbiamo scritto bene il nome:
guest@curzio ~/prova$ ls curzio roberto yuri guest@curzio ~/prova$ rm roberto yuri curzzio rm: cannot remove `curzzio': File o directory inesistente guest@curzio ~/prova$ ls curzio guest@curzio ~/prova$
Non si può cancellare una directory in modo normale: se la directory è vuota si usa il comando rmdir. Se la directory non è vuota si usa rm -r che cancella tutto il suo contenuto. Vediamo un esempio (il comando touch serve per creare un file vuoto)
guest@curzio ~/prova$ mkdir chechi guest@curzio ~/prova$ rm chechi rm: `chechi' is a directory guest@curzio ~/prova$ rmdir chechi guest@curzio ~/prova$ mkdir rossi guest@curzio ~/prova$ touch rossi/paolo guest@curzio ~/prova$ rmdir rossi rmdir: `rossi': La directory non e' vuota guest@curzio ~/prova$ rm -r rossi guest@curzio ~/prova$
Opzioni utili per rm
mv vecchio_nome nuovo_nome mv file1 file2 ... fileN directory
Quando un principiante di Linux (o più in generale di Unix) chiede a un utente più esperto delucidazioni su come funziona un qualche comando, la risposta scortese ma sicuramente azzeccata è spesso RTFM - ``Read The Fucking Manual!''. Tutti i comandi sono ampiamente documentati, non si vede perché bisognerebbe perdere tempo a rispiegare cose che qualcuno (spesso l'autore del programma) ha già spiegato esaurientemente....
Quindi provate sempre a scrivere
man <nomecomando>
e avrete pagine e pagine di documentazione... per consultarle scorrete le pagine con lo spazio e uscite premendo q.
Ci sono più sezioni del manuale, ad esempio quella con i riferimenti per i comandi C. Per specificare esplicitamente la sezione scrivete il numero della sezione prima del comando.
Come si leggono i manuali che visualizziamo con man? Prima regola: i manuali NON SI LEGGONO, si consultano. I manuali sono molto spesso estremamente dettagliati, la stragrande maggior parte delle cose che ci sono scritte non vi serviranno mai o forse vi serviranno tra due mesi, non ora... ricordatevi che, per quanto vuota possa essere la vostra vita, avrete sempre di meglio da fare che mettervi a leggere il manuale di ls. Usate i manuali quando non vi ricordate il nome di un'opzione o a cosa serve, scorreteli velocemente alla ricerca della parte che vi interessa. Ricordatevi che potete fare delle ricerche di testo all'interno del manuale scrivendo lo slash (/) e poi il testo da cercare.
Suggerimento: Se scrivendo man <comando> il sistema risponde ``No manual entry for...'' provate con <comando> -help o <comando> -h. Spesso funziona.
I file di testo sono importantissimi. I file di testo in formato ASCII sono un formato standard che dovrebbe essere utilizzato più spesso e meglio. La Microsoft cerca di imporci un modo di pensare secondo cui anche la lista della spesa va scritta in Word con fonts eccezionali e con dieci colori diversi, dove le email sono in html e contengono sfondi, testi colorati o lampeggianti e altre bestialità di questo tipo.
Questo modo di pensare ha un costo. Per esempio prendiamo un messaggio che potreste scrivere a un amico
Ciao oggi sono stato al corso di linux del PLUG. Era molto interessante!Tutta l'informazione che volevate comunicare, memorizzata in un file di testo, occupa esattamente 73 byte (uno per carattere). Questo è il minimo di memoria con cui potete esprimere questo (banale) pensiero. Se mandate l'email con outlook tutto questo messaggio viene inserito in una pagina html automaticamente generata che occupera tra i 300 e i 600 byte. Per non parlare di un documento word con questo stesso messaggio... Moltiplicate per il numero di email e di documenti che circolano su internet e scoprirete quanti terabyte di informazioni assolutamente inutili viaggiano sulla rete.
Nota: Un romanzo di medie proporzioni, ``La coscienza di Zeno'', occupa in formato testo 834 Kbytes. Poi scrivete una lettera con word e vi occupa 100 Kb (ma voi non avete assolutamente scritto un ottavo di romanzo, forse un trecentesimo!). La domanda che sorge spontanea è: ma cosa ci scrive Microsoft in un file word? Questo è un buon motivo per preferire i programmi ed i formati liberi.
In ambiente Linux i file di testo sono importantissimi, perchè tutti i file di configurazione sono semplici file di testo. Sapere fare bene alcune cose con i file di testo semplifica molto la vita.
Una velocissima panoramica per vedere cosa si può fare con un file di testo
guest@curzio ~/prova$ echo W IL PLUG W IL PLUG
guest@curzio ~$ cd pub/ guest@curzio ~/pub$ more beer I think I'll have another beer
Normalmente per i comandi lanciati dalla shell l'input e l'output sono associati con due file speciali: lo standard input, che coincide con la tastiera e lo standard output, che coincide con lo schermo. Questo comportamento può essere cambiato facilmente.
La ridirezione serve per cambiare l'input o l'output di un comando. Il < ridirige l'input, il > ridirige l'output. Questi caratteri vanno visti come se fossero frecce in entrata e in uscita.
Per esempio abbiamo visto che il comando echo scrive una stringa sullo schermo (standard output). Lo stesso comando può essere usato per scrivere su un file.
guest@curzio ~/prova$ echo Il Signore degli Anelli > yurichechi.txt guest@curzio ~/prova$ cat yurichechi.txt Il Signore degli Anelli guest@curzio ~/prova$
Ad esempio il comando sort ordina quello che gli viene passato nell'input. Nell'esempio vediamo che una volta abbiamo ridiretto solo l'input e il risultato viene scritto sullo standard output, la seconda volta abbiamo ridiretto anche l'output su un nuovo file.
guest@curzio ~/prova$ cat elenco yuri roberto curzio paolo guest@curzio ~/prova$ sort < elenco curzio paolo roberto yuri guest@curzio ~/prova$ sort < elenco > elenco_ordinato guest@curzio ~/prova$ cat elenco_ordinato curzio paolo roberto yuri
Oltre allo standard input e allo standard output esiste anche lo standard error che è associato allo schermo come lo standard output. Quando si ridirige lo standard output però i messaggi d'errore non sono ridiretti e compaiono ancora sullo schermo. Lo standard error può essere ridiretto con >.
Quando si ridirige l'output su un file tutto il contenuto del file viene perso, se invece si vuole aggiungere l'output in fondo al file si può usare >>. Invece &> ridirige sia l'output che l'errore sullo stesso file. Naturalmente è possibile scrivere anche 2>> e &>> con l'effetto che vi potete immaginare (provare per credere).
Suggerimento: La ridirezione apre delle strade nuove, ad esempio, poichè tutto in Unix è un file, anche le periferiche (ad esempio il cdrom è associato al file speciale /dev/cdrom), per creare l'immagine di un cd in un file basta digitare
cat /dev/cdrom > fileimmagine.img
ls -l | less
In questo esempio invece prendiamo un elenco di nomi, lo ordiniamo con sort estraiamo le prime quattro righe con il comando head -4 e da questo risultato estraiamo le ultime due righe con il comando tail -2. Quindi le pipeline possono essere concatenate!
guest@curzio ~/prova$ cat elenco yuri roberto curzio paolo gaetano francesco gianni guest@curzio ~/prova$ sort < elenco | head -4 | tail -2 gaetano gianni guest@curzio ~/prova$
guest@curzio ~/prova$ ls curzio.txt paolorossi yuri.txt guest@curzio ~/prova$ ls *.txt curzio.txt yuri.txt
L'ultimo comando si è espanso in ls curzio.txt yuri.txt.
Esistono, su tutti i sistemi Unix, delle identità che non appartengono a persone reali, ma a certi ``ruoli''. Ad esempio i programmi che gestiscono la posta sono eseguiti con una identità speciale, "mail", che gli dà il diritto di scrivere nelle caselle di posta degli utenti.
Esiste un account che ha tutti i diritti su tutto, senza alcuna limitazione, ed è l'account del system manager o "superuser": root.
Root ha diritto di accesso, in lettura e scrittura, a qualsiasi cosa sul sistema: dalle configurazioni, alle periferiche, la posta di tutti gli utenti, persino ai programmi che sono in esecuzione. Il system manager ha poteri illimitati, e gli utenti devono avere illimitata fiducia nella sua affidabilità e discrezione.
Come utenti Linux, probabilmente sarete voi stessi i system manager del vostro PC. Non dimenticatevi mai che il superuser ha possibilità illimitate - e quindi capacità illimitata di causare danni. La prima regola, quindi, è: non fidatevi di voi stessi. Quando avete l'identità di root, pensate sempre due volte al comando che state scrivendo, o preparatevi a sopportarne le conseguenze.
# rm -rf /*Questo comando apparantemente innocuo è sufficiente (premendo solo dieci tasti compreso l'invio) a cancellare qualsiasi file sulle vostre partizioni... e altri possono facilmente fare polpette di tutto l'hard disk.
Se avete appena installato il Linux, come prima contromisura, createvi un utente "normale" col vostro nome:
# adduser marioe assegnategli una password:
# passwd marioe usate sempre questo user. Usate root solo quando non ne potete fare a meno: per configurare il sistema, per installare del nuovo software. La tentazione di usare sempre root è forte - soprattutto se in precendenza avete avuto la sfortuna di scontrarvi con un system manager che faceva il bello e il cattivo tempo; non fosse altro per la sensazione di potenza, o per contrastare la sensazione di impotenza (``ma come, non posso neanche scrivere un file in quella directory? ma è il MIO computer!'' == paura della castrazione), ma è bene resistere più che si può, anche per evitare le fobie a livello di timor panico che si sviluppano dopo aver distrutto il sistema per la terza volta consecutiva...
Il comando da usare è su che significa set user. La sua sintassi è quella che vi aspettate:
su <username>
Siccome è estremamente comune usare il comando su per diventare l'amministratore di sistema, si può evitare di scrivere su root e scrivere solo su.
Quando eseguite il comando su vi viene chiesta la password dell'utente in cui volete trasformarvi. Se però già siete root potete trasformarvi in qualsiasi utente senza inserire nessuna password (secondo la filosofia secondo cui il root può fare tutto!).
Cambiando utente così spesso si può andare incontro a crisi di identità, in quel caso è utile il comando whoami (chi sono io?!?). Esempio:
guest@curzio ~$ whoami guest
guest@curzio ~/prova$ ls -l totale 20 -rw------- 1 guest users 18 giu 5 23:46 curzio -rw-r--r-- 1 guest users 31 giu 5 23:46 paolorossi drwxrwxrwx 2 guest users 4096 giu 5 23:48 pratesi -rwxr-xr-- 1 guest users 20 giu 5 23:46 roberto -rw-rw-rw- 1 guest users 24 giu 5 23:46 yuri guest@curzio ~/prova$
In questo modo avete molte informazioni sui file che listate. Sulla prima colonna vengono scritti i permessi associati a ciascun file.
Ogni file in un filesystem unix appartiene ad un utente e ad un gruppo. L'utente e il gruppo sono scritti nella terza e nella quarta colonna dell'output di ls -l. Ogni file può avere diversi permessi per tre categorie di utenti: l'utente a cui appartiene il file, gli utenti che appartengono al gruppo a cui appartiene il file, e tutti gli altri. Questo modo di gestire i permessi è estremamente flessibile e permette di introdurre categorie di utenti con permessi diversi.
Nella prima colonna dell'output di ls -l si possono leggere i permessi: il primo carattere è - per i file ordinari, d per le directory. Seguono tre triplette di caratteri che indicano i permessi dell'utente (user), del gruppo (group) e degli altri (user). I permessi possono essere di lettura (r), di scrittura (w) e di esecuzione (x), in questo ordine (se non si ha un permesso nella posizione corrispondente, al posto della lettera viene scritta una lineetta, -). Per le directory il permesso di esecuzione corrisponde al permesso di listarne il contenuto.
Nell'esempio:
Il comando chmod serve a cambiare i permessi di uno o più file.
chmod <triads> filename1 [filename2 ... filenameN]
Al posto di triads si può scrivere una cosa di questa
forma: chi azione permessi.
| chi | azione | permessi |
|---|---|---|
| u = user (utente) | + = aggiungi | r = read (lettura) |
| g = group (gruppo) | - = togli | w = write (scrittura) |
| o = other (altri) | = = assegna | x = execute (esecuzione) |
| a = all (tutti) | ||
| = user |
Esempi:
chmod a+r documento.txtDà a tutti il permesso di leggere il file documento.txt
chmod o-r documentosegreto.txtNon permette a tutti gli altri utenti che non appartengono al gruppo di leggere il file
chmod ug+x programmaAggiunge il permesso di esecuzione all'utente e al gruppo
chmod +x documento.txtAggiunge il permesso di esecuzione all'utente (u è sottointeso)
chmod a=rw documento.txtSetta i permessi a -rw-rw-rw-.
chmod xyz documento.txt
dove x, y e z sono tre cifre (da 0 a 7) che indicano i permessi per utente, gruppo e altri. La cifra si determina ricordando che
Ad esempio se avete un file riservato che non volete fare leggere a nessun altro potete settare i permessi a rw---- con il comando
chmod 600 filesegreto
A questo punto, mi sembra necessario ricordare che sono molto importanti le protezioni assegnate ad una directory (che si gestiscono con gli stessi comandi utilizzati per i file): in particolare, se assegnate ad un gruppo i diritti di scrittura su una directory, tutti gli utenti appartenenti a quel gruppo potranno non solo scrivere dei file in quella directory (che probabilmente è ciò che volete) ma anche cancellare qualsiasi file in quella directory (cosa che probabilmente NON volete). L'assegnazione dei diritti su un file o su una directory, quindi, in un sistema multiutente, è una cosa piuttosto delicata, e bisogna sempre pensare ai possibili effetti collaterali di quello che si fa.
Per cambiare l'utente proprietario di un file si usa il comando
chown nuovo_proprietario filename
e per cambiare il gruppo
chgrp nuovo_gruppo filename
Per cambiare il proprietario o il gruppo di un file bisogna essere il super-user (root).
Come si fa allora ad accedere al floppy, al cdrom, ad altri hard disk? La risposta di Unix è molto semplice, un filesystem va montato in una directory. Montare un filesystem significa sostituire la porzione di albero che comincia da un directory con il filesystem contenuto in un altro dispositivo.
Per esempio provate a inserire un dischetto (formattato) nel drive e a scrivere
guest@curzio ~$ mount /floppy(questo funziona su un sistema Debian. Nelle distribuzioni Red Hat e Mandrake di solito la directory giusta dove montare il floppy disk è /mnt/floppy).
A questo punto potete entrare nella directory /floppy e vedere il contenuto del dischetto, copiarci file e fare tutto quello che volete come se fosse una directory qualunque. Quando avete finito di usare il dischetto, uscite dalla directory /floppy e scrivete
guest@curzio ~$ umount /floppySolo a questo punto potete estrarre il dischetto. Ricordatevi sempre di smontare i dischetti prima di estrarli. Con i cd-rom non c'è questo problema, perché di solito Linux impedisce di estrarre il cdrom se è ancora montato.
# mount -t vfat /dev/fd0 /mnt/floppy/e avreste dovuto essere root per farlo. Infatti di norma l'operazione di mount è consentita solo al root e il comando mount deve specificare la periferica (in questo caso /dev/fd0 è il file associato al drive A:), la directory dove montare e il tipo di filesystem (vfat indica che il floppy è formattato per il DOS).
Per evitare di dover scrivere tutte queste cose tutte le volte, esiste un apposito file di configurazione, che come molti altri file di configurazione si trova nella directory /etc. Questo file si chiama /etc/fstab (file system table).
Ecco come si presenta questo file in una distribuzione Debian:
# /etc/fstab: static file system information. # # <file system> <mount point> <type> <options> <dump> <pass> /dev/hda6 / ext2 defaults,errors=remount-ro 0 1 /dev/hda5 none swap sw 0 0 proc /proc proc defaults 0 0 /dev/fd0 /floppy auto defaults,user,noauto 0 0 /dev/hda1 /boot ext2 rw 0 2 /dev/scd0 /cdrom iso9660 defaults,ro,user,noauto,exec 0 0 /dev/hda2 /win vfat rw,user 0 0
La prima colonna di ogni riga di questa tabella indica la periferica da montare, la seconda il punto di montaggio, la terza il tipo di filesystem, la quarta le opzioni. Le altre due colonne le vedremo meglio dopo.
Nell'esempio si vede che il filesystem principale viene montato in /. Il filesystem principale è un filesystem Linux ed è quindi di tipo ext2 (recentemente è stato introdotto anche il filesystem ext3), /dev/hda6 è la partizione che contiene il root filesystem. Le partizioni su linux corrispondono a file speciali di nome /dev/hdxn dove ad hd segue una lettera che indica l'hard disk (a=master, b=slave) e un numero che indica la partizione.
La seconda riga è quella che indica dove si trova la partizione di swap, che viene usata per la memoria virtuale e quindi non deve essere montata. La terza riga riguarda un filesystem speciale per la gestione dei processi. La quarta riga indica che il floppy deve essere montato nella directory floppy, il tipo di filesystem deve essere rilevato automaticamente, le opzioni user e noauto indicano che non deve essere eseguito il mounting automatico all'avvio e che il floppy può essere montato anche da utenti normali. Sulla riga successiva vediamo un filesystem che viene montato nella directory /boot e che contiene il kernel.
Il cdrom ha un filesystem di tipo iso9660, le opzioni indicano che deve essere montato in sola lettura (ro = read-only), che può essere montato da tutti (user), che non deve essere montato automaticamente all'avvio, e che i file al suo interno possono essere eseguiti (sul filesystem dei cdrom i file non hanno gli usuali permessi di unix perché usano un filesystem diverso).
Infine sull'ultima riga vediamo come si può accedere da Linux a una partizione Windows. Il tipo di filesystem usato da Windows è vfat, si deve indicare rw=read-write per poterci scrivere e user per poterlo montare senza essere root. Il problema di poter scrivere come utente comune (non root) su una partizione window è molto comune quindi lo descrivo nella sezione 3.3
Due parole sul significato delle ultime due colonne. La prima di queste indica al programma dump quali filesystem sottoporre al backup (di solito nessuno quindi si scrive 0), la seconda comunica al programma fsck per determinare l'ordine nel quale deve essere fatta la verifica dei file system in fase di reboot (quando raggiungono un certo numero di mount o quando il computer non viene chiuso correttamente). Specificare 1 per il filesystem radice (quello montato in /) e 2 per gli atri filesystem linux. Per i filesystem non linux specificare 0 perché non vanno controllati.
Per informazioni più dettagliate, naturalmente... man fstab.
In questa sezione viene spiegato come impostare la fstab in modo da poter accedere in modo facile alla partizione windows, anche da utente non root. Queste indicazioni si riferiscono a filesystem di tipo FAT, quello usato da Windows 95 e Windows 98. Windows 2000 di default usa NTFS, anche se al momento dell'installazione di Windows 2000 è possibile chiedere che il disco venga formattato con FAT32.
Il problema da affrontare è che, quando i filesystem vengono montati all'avvio l'operazione di mount viene effettuata da utente root e quindi di default tutti i file del filesystem di Windows vengono assegnati all'utente root. È possibile modificare questo comportamento di default specificando opportuni parametri nella fstab.
Come prima cosa creiamo un gruppo di utenti che avranno il permesso di scrivere sulla partizione di Windows. Chiamiamo il gruppo ad esempio fatwriters.
# addgroup fatwriters
Aggiungiamo a questo gruppo gli utenti che avranno il permesso di scrivere sulla partizione di Windows, ad esempio supponiamo che gli utenti a cui vogliamo accordare questo permesso siano marco e sara.
# adduser marco fatwriters # adduser sara fatwriters
Faremo in modo che i file all'interno della partizione windows appartengano all'utente root e al gruppo fatwriters. Per fare questo è necessario conoscere l'uid di root (è sempre 0!!) e il gid di fatwriters. Per sapere il gid di fatwriters, fate il login come uno degli utenti che appartengono al gruppo fatwriters (ricordatevi che è necessario rifare il login perchè l'utente venga effettivamente aggiunto al gruppo!) e usate il comando id.
marco@curzio:~$ id uid=1001(marco) gid=1001(marco) gruppi=1001(marco),104(fatwriters)
In questo caso l'id del gruppo fatwriters è 104. Tra le opzioni di montaggio del filesystem di windows dovremo quindi aggiungere le opzioni che indicano l'uid e il gid con i quali effettuare l'operazione di montaggio. Inoltre si deve specificare la maschera dei permessi in modo che il gruppo abbia i permessi di scrittura (questo si fa con l'opzione umask=1003 per permettere solo a chi appartiene al gruppo di leggere e scrivere mentre a chi non appartiene al gruppo è permesso l accesso in sola lettura). Nel nostro caso si avrà uid=0,gid=104,umask=1003. Altre opzioni utili per filesystem di tipo FAT sono rw che dice che il filesystem è in lettura e scrittura, user che permette a tutti di montarlo e smontarlo, exec che permette di eseguire file contenuti nel filesystem. L'opzione codepage=850 determina il modo di visualizzare i caratteri speciali e può essere utile se i caratteri accentati d un filesystem windows non vengono visti correttamente da Linux.
In definitiva la riga della fstab che regola il montaggio del filesystem di windows sarà qualcosa del genere.
/dev/hda1 /win vfat user,rw,exec,codepage=850,uid=0,gid=104,umask=1003 0 0
Per controllare che tutto funzioni, rimontate il filesystem di windows e controllate che i file appartengano all'utente root e al gruppo fatwriters, poi provate a scrivere dentro al filesystem di Windows come uno degli utenti appartenenti al gruppo fatwriters.
Per fortuna non è sempre necessario ricompilare tutti i programmi, perché questa operazione non è sempre facile. Le varie distribuzioni hanno introdotto vari formati di pacchetti già compilati.
Ci sono molti programmi grafici per la gestione dei pacchetti RPM, ad esempio rpmdrake della Mandrake oppure KPackage e GnoRPM.
Tuttavia è importante anche sapere come installare gli rpm da linea di comando, un po' per le solite ragioni (è più veloce, ecc...), ma anche perché vi potreste trovare in una situazione in cui il programma grafico non è disponibile (crash della scheda video...).
Per installare un pacchetto rpm dovete essere l'amministratore di sistema (diventatelo con il comando su, cfr. 2.2) e usare il comando rpm. Portatevi nella directory dove si trova il pacchetto da installare e scrivete
[root /root]# rpm -i pacchetto.rpmOpzioni interessanti sono v che vi permette di vedere alcune informazioni aggiuntive sui pacchetti e h che dà una rappresentazione grafica del progresso nell'installazione. Invece l'opzione U (update), nel caso che il pacchetto sia già installato lo aggiorna, se non è installato lo installa. Quindi spesso la scelta migliore è
[root /root]# rpm -Uvh pacchetto.rpmmentre
[root /root]# rpm -F pacchetto.rpmaggiorna il pacchetto solo se una versione più vecchia del pacchetto è già installata. In questo modo è facile aggiornare tutti i pacchetti che già abbiamo installato: dalla directory che contiene tutti i nuovi pacchetti lanciate il comando
[root /root]# rpm -F *.rpm
Si può controllare se un pacchetto è installato con il comando rpm -q. Esempio
guest@curzio ~$ rpm -q emacs emacs-20.7-34
Per disinstallare un pacchetto usare il comando
# rpm -e nomepacchetto
Vediamo qual è la procedura standard, che a volte funziona, a volte incontra qualche problema se il nostro sistema non ha tutte le caratteristiche giuste per quel pacchetto.
I sorgenti vengono distribuiti di solito nel formato compresso tgz. Il file che scaricate avrà estensione tgz o tar.gz. In ogni caso potete estrarre il contenuto dell'archivio con il comando
tar zxvf nomepacchetto.tgzDi solito il pacchetto crea una directory in cui sono contenuti i sorgenti del programma. Entrate nella directory. La procedura standard per installare un programma è
$ ./configure $ makee, da root,
# make install
Il primo comando controlla le caratteristiche del vostro sistema e prepara la compilazione con i parametri appropriati. Il comando make lancia la compilazione dei sorgenti secondo le modalità descritte nel file di nome Makefile, make install copia i file nelle directory giuste. Quando avete installato con successo il programma potete cancellare la directory creata al momento dell'estrazione dell'archivio, non cancellate invece il pacchetto che avete scaricato perché vi potrebbe servire per installarlo nuovamente.
Naturalmente ci sono delle eccezioni, a volte ./configure non serve, a volte ha bisogno di alcuni parametri... con un po' di pratica imparerete a gestire anche i casi più complicati.
Devo inoltre ringraziare Marco Nenciarini che mi ha spiegato il metodo descritto nella sezione 3.3 per montare il filesystem di Windows con i permessi opportuni.
Gli appunti che state leggendo si possono trovare on line in
vari formati (ps, pdf e anche i sorgenti
LATEX)
all'indirizzo
http://www.prato.linux.it/~lmasetti/seriamente/lezionebash/
Questo documento ricade interamente sotto la GNU Public Licence, ed è quindi gratuito per qualsiasi fine, ma protetto da Copyleft.
This document was generated using the LaTeX2HTML translator Version 2K.1beta (1.47)
Copyright © 1993, 1994, 1995, 1996, Nikos Drakos,
Computer Based Learning Unit, University of Leeds.
Copyright © 1997, 1998, 1999, Ross Moore, Mathematics
Department, Macquarie University, Sydney.
The command line arguments were:
latex2html -dir html -mkdir -split 3
lezione.tex
The translation was initiated by Lorenzo Masetti on
2002-06-12