diff --git a/it_IT.ISO8859-15/articles/committers-guide/Makefile b/it_IT.ISO8859-15/articles/committers-guide/Makefile
index 55c27c1cf7..e27d23c4ce 100644
--- a/it_IT.ISO8859-15/articles/committers-guide/Makefile
+++ b/it_IT.ISO8859-15/articles/committers-guide/Makefile
@@ -1,29 +1,29 @@
#
# $FreeBSD$
#
# Crea la Nuova Guida per i Committer di FreeBSD
#
-MAINTAINER=sysadmin@alexdupre.com
+MAINTAINER=ale@FreeBSD.org
DOC?= article
FORMATS?= html
INSTALL_COMPRESSED?= gz
INSTALL_ONLY_COMPRESSED?=
WITH_ARTICLE_TOC?= YES
#
# SRCS lista i singoli files SGML che compongono il documento. Modifiche
# a qualunque di questi files obbligano la ricreazione
#
# Contenuto SGML
SRCS= article.sgml
DOC_PREFIX?= ${.CURDIR}/../../..
.include "${DOC_PREFIX}/share/mk/doc.project.mk"
diff --git a/it_IT.ISO8859-15/articles/committers-guide/article.sgml b/it_IT.ISO8859-15/articles/committers-guide/article.sgml
index de5f40839d..d6185aed7e 100644
--- a/it_IT.ISO8859-15/articles/committers-guide/article.sgml
+++ b/it_IT.ISO8859-15/articles/committers-guide/article.sgml
@@ -1,1688 +1,1698 @@
%man;
%freebsd;
%authors;
%teams;
%it-trademarks;
-
-
-%trademarks;
+
+
+%trademarks;
%mailing-lists;
%translators;
]>
Guida del CommitterThe FreeBSD Italian Documentation Project$FreeBSD$19992000200120022003
+ 2004
+
The FreeBSD Italian Documentation Project
-
+
&tm-attrib.freebsd;
- &tm-attrib.cvsup;
- &tm-attrib.ibm;
- &tm-attrib.intel;
- &tm-attrib.sparc;
- &tm-attrib.general;
-
+ &tm-attrib.cvsup;
+ &tm-attrib.ibm;
+ &tm-attrib.intel;
+ &tm-attrib.sparc;
+ &tm-attrib.general;
+ Questo documento fornisce informazioni per la comunità dei
committer di FreeBSD. Tutti i nuovi committer dovrebbero leggere
questo documento prima di iniziare, e i committer già esistenti
sono fortemente incoraggiati a riguardarselo di tanto in tanto.
- Traduzione a cura di &a.it.alex;.
+ &trans.it.alex;
Dettagli AmministrativiHost con il Repository
Principalencvs.FreeBSD.orgMetodi di Accesso&man.ssh.1;, solo protocollo 2CVSROOT Principalencvs.FreeBSD.org:/home/ncvs
(guarda anche la ).&a.cvs; Principali&a.peter; e &a.markm;, così come &a.joe; per i
ports/Mailing List&a.developers;, &a.committers;
(Entrambe sono liste private; gli archivi possono essere trovati
in /home/mail/developers-archive
e /home/mail/committers-archive
sul cluster di FreeBSD.org.)Report mensili del Core Team/home/core/public/monthly-report
sul cluster di FreeBSD.org.Tag CVS Degni di NotaRELENG_4 (4.X-STABLE),
HEAD (-CURRENT)È richiesto l'uso di &man.ssh.1; o &man.telnet.1; con
Kerberos 5 per connettersi agli host del progetto e solo &man.ssh.1;,
protocollo 2 ha il permesso di collegarsi all'host con il repository.
Questi sono generalmente più sicuri che un semplice &man.telnet.1;
o &man.rlogin.1; visto che la negoziazione delle credenziali
avverrà sempre in modo cifrato.
Tutto il traffico è cifrato di default
con &man.ssh.1;. Insieme a programmi di utilità come
&man.ssh-agent.1; e &man.scp.1;, anch'essi disponibili, &man.ssh.1;
è di gran lunga più conveniente. Se non sai nulla di
&man.ssh.1;, guarda la .Tipi di Bit di CommitIl repository CVS di FreeBSD ha un numero di componenti che, se
combinati, supportano i sorgenti di base del sistema operativo, la
documentazione, l'infrastruttura dei port delle applicazioni di terze
parti, e vari programmi di utilità. Quando vengono assegnati i bit
di commit di FreeBSD, vengono specificate le aree dell'albero dove il bit
può essere usato. Solitamente, le aree associate a un bit
corrispondono a quelle di chi ha autorizzato l'assegnamento del bit di
commit. Ulteriori aree di autorità possono essere aggiunte in
seguito: se occorrerà, il committer dovrà seguire le
normali procedure di allocazione del bit di commit per quell'area
dell'albero, chiedendo l'approvazione all'entità appropriata e
possibilmente prendendo un mentore per quell'area per un po' di
tempo.Tipo di CommitterResponsabileComponenti dell'Alberosrccore@src/, doc/ soggetta ad appropriata revisionedocdoceng@doc/, www/, documentazione src/portsportmgr@ports/I bit di commit assegnati prima dello sviluppo della nozione di aree
di autorità possono essere usati in molte parti dell'albero.
Tuttavia, il buon senso dice che un committer che non ha mai lavorato
precedentemente in un'area dell'albero chieda una revisione del proprio
lavoro prima di effettuare il commit, chieda l'approvazione del
responsabile appropriato, e/o lavori d'accordo con un mentore. Dato che
le regole sulla manutenzione del codice differiscono a seconda dell'area
dell'albero, questo è per il bene del committer che lavora in
un'area poco familiare tanto quanto per gli altri che lavorano
sull'albero.I committer sono incoraggiati a chiedere la revisione del proprio
lavoro come parte del normale processo di sviluppo, indifferentemente
dall'area dell'albero in cui stanno lavorando.Operazioni sul CVSSi assume che tu abbia già familiarità con le operazioni
di base di CVS.I &a.cvs; sono i proprietari del repository CVS e sono
responsabili delle sue modifiche dirette allo scopo di ripulire o
sistemare dei gravi abusi di CVS da parte di un committer.
Nel caso dovessi causare qualche problema al repository,
diciamo una errata operazione di cvs import o
cvs tag, invia un messaggio ai &a.cvs; (o chiama uno di
loro) ed esponi il problema ad uno di loro. Gli unici che hanno il
permesso di manipolare direttamente i bit del repository sono i
repomeister. Per questo non ci sono shell di login
disponibili sulle macchine del repository, tranne che per i
repomeister.L'albero CVS è attualmente diviso in quattro repository
- differenti, ovvero doc, ports,
+ differenti, ovvero doc, ports,
projects e src. Questi vengono
ricomposti sotto un unico CVSROOT quando vengono
distribuiti tramite CVSup per la convenienza
- dei nostri utenti.
-
+ dei nostri utenti.
+
Nota che il modulo www che contiene i sorgenti
del sito web di FreeBSD
è contenuto all'interno del repository
doc.
-
-
+
+
I repository CVS sono ospitati sulle macchine repository.
Attualmente, ognuno dei repository elencati qui sopra risiede sulla stessa
macchina fisica, ncvs.FreeBSD.org, ma
per permettere la possibilità di averne ognuno su una macchina
diversa in futuro, ci sono diversi nomi di host che i committer
dovrebbero utilizzare. Inoltre, ogni repository risiede in una
- directory differente. La seguente tabella racchiude la situazione.
-
-
Le operazioni sul CVS sono fatte da remoto impostando la variabile di
ambiente CVSROOT a ncvs.FreeBSD.org:/home/ncvs
e la variabile CVS_RSH a ssh, e
quindi effettuando le appropriate operazioni di check-out/check-in.
Molti committer definiscono degli alias che si espandono nella corretta
invocazione di cvs per il repository
appropriato. Per esempio, un utente di &man.tcsh.1; può aggiungere
le seguenti righe al suo .cshrc per questo
- scopo:
-
- alias dcvs env CVS_RSH=ssh cvs -d user@dcvs.freebsd.org:/home/dcvs
-alias pcvs env CVS_RSH=ssh cvs -d user@pcvs.freebsd.org:/home/pcvs
-alias projcvs env CVS_RSH=ssh cvs -d user@projcvs.freebsd.org:/home/projcvs
-alias scvs env CVS_RSH=ssh cvs -d user@ncvs.freebsd.org:/home/ncvs
-
+ scopo:
+
+ alias dcvs env CVS_RSH=ssh cvs -d user@dcvs.freebsd.org:/home/dcvs
+alias pcvs env CVS_RSH=ssh cvs -d user@pcvs.freebsd.org:/home/pcvs
+alias projcvs env CVS_RSH=ssh cvs -d user@projcvs.freebsd.org:/home/projcvs
+alias scvs env CVS_RSH=ssh cvs -d user@ncvs.freebsd.org:/home/ncvs
+
In questo modo è possibile fare tutte le operazioni di
CVS localmente ed usare Xcvs
- commit per effettuare il commit sull'albero CVS ufficiale.
+ commit per effettuare il commit sull'albero CVS ufficiale.
Se desideri aggiungere qualcosa di totalmente nuovo (ad esempio dei
sorgenti in contrib, ecc.), deve essere usato cvs
import. Guarda come riferimento la pagina man di &man.cvs.1;
per l'utilizzo.Per favore non usare cvs
checkout o update con la macchina con il
repository ufficiale impostata come CVS Root per tenere aggiornato il
tuo albero dei sorgenti. CVS da remoto non è ottimizzato per la
distribuzione via rete e richiede un grande sovraccarico di lavoro e di
amministrazione sul lato server. Utilizza il nostro metodo di
distribuzione avanzato cvsup per ottenere i bit del
repository, ed esegui solamente l'operazione di
commit sull'host con il repository.
Forniamo un'estesa rete di mirror cvsup per questo scopo, così
come diamo accesso al cvsup-master se hai veramente
bisogno di essere aggiornato alle ultime modifiche.
Il cvsup-master ha la potenza necessaria a gestire
questa cosa, il repository principale no. &a.kuriyama; è a capo
del cvsup-master.Se devi usare le operazioni add e
delete di CVS come se fosse un'operazione &man.mv.1;,
allora va effettuata una copia nel repository piuttosto che usare
add e delete di CVS. In una
copia nel repository, un CVS Meister
copierà il/i file nei loro nuovi nomi e/o locazioni e ti
avviserà ad operazione avvenuta. Lo scopo di una copia del
repository è di preservare la cronologia dei cambiamenti del file,
o i log. Noi del FreeBSD Project diamo molta importanza alla cronologia
dei cambiamenti che CVS fornisce al progetto.Informazioni di riferimento, tutorial, e FAQ su CVS possono
essere trovate su: .
Anche le informazioni contenute nei capitoli di Karl Fogel
da Open Source Development with CVS sono molto
utili.&a.des; ha fornito inoltre il seguente mini manuale su
CVS.Effettua il check out di un modulo con il comando
co o checkout.&prompt.user; cvs checkout shazamQuesto estrae una copia del modulo shazam. Se
non c'è alcun modulo shazam nel file dei
moduli, cercherà allora una directory di primo livello chiamata
shazam.
Opzioni utili con cvs checkoutNon crea le directory vuoteEstrae solo un livello, non le sottodirectoryEstrai la versione, il ramo, o il tag
verEstrai i sorgenti com'erano in data
data
Esempi pratici su FreeBSD:Estrai il modulo miscfs, che
corrisponde a src/sys/miscfs:&prompt.user; cvs co miscfsOra hai una directory chiamata miscfs
con le sottodirectory CVS,
deadfs, devfs, e
così via. Una di queste (linprocfs)
è vuota.Estrai gli stessi file, ma con il percorso completo:&prompt.user; cvs co src/sys/miscfsOra hai una directory chiamata src,
con le sottodirectory CVS e
sys. La directory
src/sys ha le
sottodirectory CVS e
miscfs, ecc.Estrai gli stessi file, ma elimina le directory vuote:&prompt.user; cvs co -P miscfsOra hai una directory chiamata miscfs
con le sottodirectory CVS,
deadfs, devfs... ma nota
che non c'è nessuna sottodirectory
linprocfs, perché non contiene alcun
file.Estrai la directory miscfs, ma nessuna
delle sue sottodirectory:&prompt.user; cvs co -l miscfsOra hai una a directory chiamata miscfs
con solo una sottodirectory chiamata
CVS.Estrai il modulo miscfs com'è nel
ramo 4.X:&prompt.user; cvs co -rRELENG_4 miscfsPuoi modificare i sorgenti ed effettuare il commit su questo
ramo.Estrai il modulo miscfs com'era nella
3.4-RELEASE.&prompt.user; cvs co -rRELENG_3_4_0_RELEASE miscfsNon potrai effettuare il commit delle modifiche, visto che
RELENG_3_4_0_RELEASE corrisponde ad un
preciso istante di tempo, non a un ramo.Estrai il modulo miscfs com'era il 15
gennaio 2000.&prompt.user; cvs co -D'01/15/2000' miscfsNon potrai effettuare modifiche.Estrai il modulo miscfs com'era una
settimana fa.&prompt.user; cvs co -D'last week' miscfsNon potrai effettuare modifiche.Tieni presente che cvs salva i metadati in sottodirectory chiamate
CVS.Gli argomenti di e
sono fissi, che vuol dire che cvs se li ricorderà in seguito,
ad esempio quando farai un cvs update.Controlla lo stato dei file estratti con il comando
status.&prompt.user; cvs status shazamQuesto visualizza lo stato del file shazam o
di ogni file nella directory shazam. Per ogni
file, lo stato è uno fra:Up-to-dateIl file à aggiornato e non è stato
modificato.Needs PatchIl file non è stato modificato, ma c'è una
nuova versione nel repository.Locally ModifiedIl file è aggiornato, ma è stato
modificato.Needs MergeIl file è stato modificato, e c'è una nuova
versione nel repository.File had conflicts on mergeCi sono stati conflitti l'ultima volta che il file
è stato aggiornato, e non sono ancora stati
risolti.Vedrai anche la versione e la data locale, il numero dell'ultima
versione appropriata (ultima appropriata perché
se hai una data, un tag o un ramo fissati, può non essere
l'ultima versione), e i tag, le date o le opzioni applicate.Dopo avere estratto qualcosa, puoi aggiornarlo con il comando
update.&prompt.user; cvs update shazamQuesto aggiorna il file shazam o il contenuto
della directory shazam all'ultima versione sul
ramo che hai estratto. Se hai estratto un preciso instante di
tempo, non fa nulla a meno che i tag non siano stati
spostati nel repository o qualche altra strana cosa sia in
corso.Opzioni utili, in aggiunta a quelle elencate sopra, con
checkout:Estrae ogni directory aggiuntiva mancante.Scarica l'ultima versione del ramo principale.Altre magie (guarda sotto).Se hai estratto un modulo con o
, l'esecuzione di cvs update
con un argomento differente di o
o con selezionerà un
nuovo ramo, una nuova versione o una nuova data.
L'opzione elimina tutti i tag, le date o le
versioni fissate mentre e ne
impostano di nuove.Teoricamente, specificando HEAD come argomento
di avrai lo stesso risultato di
, ma è solo in teoria.L'opzione è utile se:qualcuno ha aggiunto delle sottodirectory al modulo che hai
estratto dopo averlo estratto.hai estratto con , e dopo cambi idea e
vuoi estrarre anche le sottodirectory.hai cancellato delle sottodirectory e vuoi estrarle
nuovamente.Osserva l'output di cvs update con
cura. La lettera all'inizio di ogni file indica cosa
è stato fatto su di esso:UIl file è stato aggiornato senza problemi.PIl file è stato aggiornato senza problemi (vedrai
questo solo quando lavorerai su un repository remoto).MIl file è stato modificato, ed è stato
fuso senza conflitti.CIl file è stato modificato, ed è stato
fuso con dei conflitti.La fusione è ciò che avviene quando estrai una copia
di qualche codice sorgente, lo modifichi, quindi qualcun altro
effettua il commit di un'altra modifica, e tu esegui cvs
update. CVS nota che tu hai fatto dei cambiamenti locali, e
cerca di fondere le tue modifiche con quelle fatte tra la versione che
hai originariamente estratto e quella che stai aggiornando. Se i
cambiamenti sono a due parti separate del file, solitamente non ci
saranno problemi (sebbene il risultato possa non essere
sintatticamente o semanticamente corretto).CVS stamperà una M davanti ad ogni file
modificato localmente anche se non c'è una nuova versione nel
repository, quindi cvs update è adatto
per avere un resoconto di quello che hai cambiato in locale.Se appare una C, allora le tue modifiche sono
in conflitto con i cambiamenti presenti nel repository (le modifiche
sono sulle stesse righe, o righe vicine, o hai cambiato così
tanto il file locale che cvs non è in grado
di applicare le modifiche al repository). Dovrai allora andare a
modificare il file a mano e risolvere i conflitti; questi saranno
evidenziati da righe di simboli <,
= e >. Per ogni conflitto,
ci sarà una linea di demarcazione formata da sette
< e il nome del file, seguita da una porzione di
quello che il tuo file locale conteneva, seguita da una riga di
separazione con sette =, seguita dalla porzione
corrispondente presente nella versione del repository, seguita da una
riga di separazione con sette > e il numero di
versione che stai aggiornando.L'opzione è un po' voodoo. Aggiorna
il file locale alla versione specificata come se avessi usato
, ma non cambia il numero di versione o il ramo
registrato del file locale. Non è realmente utile tranne
quando usata due volte, nel qual caso fonderà le modifiche
tra le due versioni specificate nella copia su cui stai
lavorando.Per esempio, supponiamo che ti abbia effettuato il commit di una
modifica a shazam/shazam.c in &os.current; e che
più tardi tu voglia effettuare l'MFC. Le modifiche che vuoi
fondere sono nella versione 1.15:Estrai la versione &os.stable; del modulo
shazam:&prompt.user; cvs co -rRELENG_4 shazamApplica le modifiche tra la ver 1.14 e la 1.15:&prompt.user; cvs update -j1.14 -j1.15 shazam/shazam.cQuasi certamente avrai un conflitto a causa delle righe
$Id$ (o nel caso di FreeBSD, $FreeBSD$),
quindi dovrai modificare a mano il file per risolvere il conflitto
(rimuovi le righe di separazione e la seconda linea
$Id$, lasciando la linea $Id$
originale intatta).Guarda le differenze tra la versione locale e quella sul
repository con il comando diff.&prompt.user; cvs diff shazammostra ogni modifica che hai fatto al file o al modulo
shazam.
Opzioni utili con cvs diffUtilizza il formato diff unificato.Utilizza il formato diff contestuale.Visualizza i file mancanti o aggiunti.
Vorrai sempre utilizzare , visto che le diff
unificate sono molto più semplici da leggere rispetto a quasi
tutti gli altri formati (in alcune circostanze, le diff contestuali
generate con l'opzione possono essere meglio, ma
sono molto più voluminose). Una diff unificata consiste di una
serie di parti. Ogni parte inizia con una riga con due caratteri
@ e specifica dove si trovano le differenze nel
file e su quante linee si estendono. Questa è seguita da un
certo numero di righe; alcune (precedute da uno spazio) fanno parte
del contesto; altre (precedute da un -) sono quelle
eliminate e altre ancora (precedute da un +) sono
quelle aggiunte.Puoi anche effettuare una diff con una versione differente
rispetto a quella che hai estratto specificando la versione con
o come per il
checkout o l'update,
o anche visualizzare le differenze tra due versioni arbitrarie
(indipendentemente da quella che hai localmente) specificando
due versioni con o
.Guarda le righe di log con il comando
log.&prompt.user; cvs log shazamSe shazam è un file, questo
stamperà un'intestazione con le
informazioni sul file, come la locazione nel repository dove il file
è salvato, a quale versione è l'HEAD
per questo file, in quali rami si trova il file, e qualsiasi tag
valido per questo file. Quindi, per ogni versione del file, viene
stampato un messaggio di log. Questo include la data e l'ora del
commit, chi ha fatto il commit, quante righe sono state aggiunte e/o
tolte, e alla fine il messaggio di log che il committer ha scritto
quando ha inviato la modifica.Se shazam è una directory, allora le
informazioni di log descritte sopra vengono stampate a turno per ogni
file presente nella directory. A meno che tu abbia dato l'opzione
a log, vengono stampati anche
i log per tutte le sottodirectory di shazam, in
maniera ricorsiva.Usa il comando log per vedere la storia di uno
o più file, come è salvata nel repository CVS. Puoi
anche usarlo per vedere il messaggio di log di una versione specifica,
se aggiungi al
comando log:&prompt.user; cvs log -r1.2 shazamQuesto stamperà solamente il messaggio di log per la
versione 1.2 del file shazam
se è un file, oppure i messaggi di log per le versioni 1.2 di
ogni file sotto shazam se è una
directory.Guarda chi ha fatto cosa con il comando
annotate. Questo comando visualizza ogni riga del
file o dei file specificati, insieme all'utente che ha modificato
più recentemente quella riga.&prompt.user; cvs annotate shazamAggiungi nuovi file con il comando add.Crea il file, usa cvs add su di esso, quindi
cvs commit.In modo analogo, puoi aggiungere nuove directory creandole e poi
utilizzando cvs add su di esse. Nota che non
c'è bisogno di usare il commit sulle directory.Rimuovi i file obsoleti con il comando
remove.Rimuovi il file, quindi usa cvs rm su di esso,
ed infine cvs commit.Effettua il commit con il comando commit o
checkin.
Opzioni utili con cvs commitForza il commit di un file non modificato.Specifica un messaggio di commit sulla riga di comando
anziché invocare un editor.
Usa l'opzione se ti accorgi che hai lasciato
fuori informazioni importanti dal messaggio di commit.Buoni messaggi di commit sono importanti. Dicono agli altri
perché hai fatto le modifiche che hai fatto, non solo qui ed
ora, ma per mesi o anni quando qualcuno si chiederà
perché dei pezzi di codice all'apparenza illogici o
inefficienti sono entrati nel file sorgente. È inoltre un
aiuto inestimabile per decidere su quali modifiche va effettuato
l'MFC e su quali no.I messaggi di commit devono essere chiari, concisi, e fornire
un ragionevole sommario per dare un'indicazione di cosa è stato
cambiato e perché.I messaggi di commit devono fornire abbastanza informazioni
affinché una terza parte possa decidere se la modifica è
rilevante per lei e se debba leggere la modifica stessa.Evita di effettuare il commit di più modifiche scollegate
in una volta sola. Questo rende difficile la fusione, e inoltre rende
più complicato determinare quale modifica è colpevole
se salta fuori un bug.Evita di effettuare il commit di correzioni di stile o di
spaziatura insieme a correzioni di funzionalità. Questo rende
difficile la fusione, e inoltre rende più complicato capire
quali modifiche alle funzionalità sono state fatte. Nel caso
di file di documentazione, può rendere il lavoro dei gruppi
di traduzione più complicato, visto che diventa difficile per
loro determinare esattamente quali modifiche al contenuto vanno
tradotte.Evita di effettuare il commit di cambiamenti a più file
con un unico messaggio generico o vago. Invece, effettua il commit
di un file alla volta (o di piccoli gruppi di file correlati) con un
messaggio di commit appropriato.Prima di effettuare il commit, devi
sempre:verificare su che ramo stai effettuando il commit, tramite
cvs status.revisionare i tuoi cambiamenti, con
cvs diffInoltre, devi SEMPRE specificare esplicitamente sulla riga di
comando su quali file deve essere effettuato il commit, in modo da non
toccare incidentalmente altri file non voluti - cvs
commit senza argomenti effettuerà il commit di ogni
modifica nella directory corrente ed ogni sottodirectory.Suggerimenti e trucchi aggiuntivi:Puoi inserire le opzioni più comunemente usate nel tuo
~/.cvsrc, come in questo caso:cvs -z3
diff -Nu
update -Pd
checkout -PQuesto esempio dice:usa sempre il livello di compressione 3 quando si parla con un
server remoto. Questo è un salvavita quando si lavora su
una connessione lenta.usa sempre le opzioni (visualizza i file
aggiunti o rimossi) e (formato diff unificato)
con &man.diff.1;.usa sempre le opzioni (elimina le
directory vuote) e (estrai le nuove directory)
quando si effettua l'update.usa sempre l'opzione (elimina le
directory vuote) quando si estrae.Usa lo script cdiff di Eivind Eklund per
visualizzare le diff unificate. È un wrapper per &man.less.1;
che aggiunge i codici colore ANSI per far risaltare le intestazioni
delle sezioni, le righe rimosse e quelle aggiunte; il contesto rimane
invariato. Inoltre espande i tab correttamente (i tab spesso appaiono
errati nelle diff a causa del carattere aggiuntivo all'inizio di ogni
riga).Semplicemente usalo al posto di &man.more.1; o
&man.less.1;:&prompt.user; cvs diff -Nu shazam | cdiffAlternativamente alcuni editor come &man.vim.1;
(editors/vim5) hanno il supporto
al colore e quando vengono usati con l'evidenziazione della sintassi
attiva evidenzieranno molti tipi di file, incluse le diff, le patch,
e i log CVS/RCS.&prompt.user; echo "syn on" >> ~/.vimrc
&prompt.user; cvs diff -Nu shazam | vim -
&prompt.user; cvs log shazam | vim -CVS è vecchio, arcano, complesso e buggato, e a volte
esibisce comportamenti non deterministici che qualcuno sostiene siano
la prova che CVS non sia niente di più di una manifestazione
Newtoniana di una entità ultradimensionale sensibile.
Non è umanamente possibile conoscere ogni dettaglio di CVS,
quindi non essere dispiaciuto di chiedere aiuto all'Intelligenza
Artificiale (&a.cvs;).Non lasciare il comando cvs commit nella
modalità di inserimento del messaggio di commit per troppo
tempo (più di 2–3 minuti). Questo blocca la directory in
cui stai lavorando ed impedirà ad altri sviluppatori di
effettuare commit nella stessa directory. Se devi digitare un
messaggio di commit lungo, scrivilo prima di eseguire
cvs commit, e inseriscilo successivamente.Convenzioni e TradizioniCome nuovo committer ci sono alcune cose che dovresti fare
all'inizio.Aggiungere te stesso alla sezione Developers della
Contributors List e
rimuovere te stesso dalla sezione Additional
Contributors. Una volta fatto ciò, non dimenticarti
di aggiungere la tua entity di autore in
doc/en_US.ISO8859-1/share/sgml/authors.ent;
usa le altre voci come esempio.Questo è un compito relativamente semplice, ma rimane una
buona prima prova delle tue abilità con CVS.Aggiungi una voce per te stesso in
www/en/news/news.xml. Guarda le altre voci che
assomigliano a A new committer e segui il
formato.
- Se hai una chiave PGP o GnuPG, potresti volerla aggiungere in
- doc/share/pgpkeys.
+ Dovresti aggiungere la tua chiave PGP o GnuPG in
+ doc/share/pgpkeys (e se non ce l'hai, dovresti
+ creartene una).&a.des; ha scritto uno script di shell per rendere questa
operazione molto semplice. Guarda il file README
per maggiori informazioni.
+
+
+ È importante avere una chiave PGP/GnuPG aggiornata nel
+ Manuale, visto che potrà essere richiesta per
+ l'identificazione del committer, ad esempio dai &a.admins; per
+ il recupero dell'account.
+ Alcune persone aggiungono una voce per se stessi in
ports/astro/xearth/files/freebsd.committers.markers.Alcune persone aggiungono una voce per se stessi in
src/usr.bin/calendar/calendars/calendar.freebsd.Presentati agli altri committer, altrimenti nessuno avrà
idea di chi tu sia o di cosa ti occupi. Non devi scrivere una
biografia completa, basta un paragrafo o due su chi sei e su quello
di cui hai intenzione di occuparti come committer di FreeBSD.
Invialo alla &a.developers; e sarai sulla strada giusta!Loggati su hub.FreeBSD.org e crea un file
/var/forward/utente
(dove utente è il tuo nome utente)
contenente l'indirizzo e-mail dove vuoi che i messaggi indirizzati a
tuonomeutente@FreeBSD.org siano inoltrati.
Questo include tutti i messaggi di commit così come ogni altro
messaggio inviato alla &a.committers; e alla &a.developers;. Caselle
di posta veramente grandi che hanno preso residenza fissa su
hub spesso vengono accidentalmente
troncate senza preavviso, quindi inoltra o leggi i messaggi in modo da
non perderli.Se sei iscritto alla &a.cvsall;, probabilmente vorrai
disiscriverti per evitare di ricevere copie doppie dei messaggi di
commit e della loro evoluzione.Tutti i nuovi committer hanno un mentore assegnato a loro per i primi
mesi. Il tuo mentore è più o meno responsabile di
spiegarti ogni cosa ti sia poco chiara ed è anche responsabile
delle tue azioni durante questo periodo iniziale. Se fai un commit
errato, imbarazzerai il tuo mentore e probabilmente dovresti passare
almeno i primi commit a lui prima di agire direttamente sul
repository.Tutti i commit dovrebbero andare su &os.current; prima di essere
fusi in &os.stable;. Nessuna nuova caratteristica importante o modifica
ad alto rischio dovrebbe essere fatta sul ramo &os.stable;.Relazioni tra SviluppatoriSe stai lavorando direttamente sul tuo codice o su codice che è
già stabilito essere di tua responsabilità, allora
c'è probabilmente poca necessità di confrontarsi con altri
committer prima di effettuare un commit. Se vedi un bug in un'area del
sistema che è chiaramente orfana (e ce n'è qualcuna di
queste aree, per nostra vergogna), agisci allo stesso modo. Se, tuttavia,
stai per modificare qualcosa che è chiaramente mantenuto
attivamente da qualcun'altro (ed è solo guardando la mailing list
cvs-committers che puoi veramente sapere cosa è
e cosa non è) allora invia le modifiche a lui, come avresti
fatto prima di diventare committer. Per i port, dovresti contattare il
MAINTAINER specificato nel
Makefile. Per altre parti del repository, se non sei
sicuro di chi possa essere il maintainer attivo, potrebbe essere utile
scorrere l'output di cvs log per vedere chi ha
effettuato delle modifiche in passato. &a.fenner; ha scritto un utile
script di shell che può aiutare a determinare chi sia il
maintainer attivo. Questo elenca ogni persona che ha effettuato commit
su un file specifico con il numero di commit che ha fatto. Può
essere trovato su freefall in
~fenner/bin/whodid. Se alle tue richieste non
corrisponde una risposta o se il committer in altro modo dimostra uno
scarso interesse nell'area oggetto della modifica, vai avanti ed effettua
il commit tu stesso.Se non sei sicuro di un commit per qualunque motivo, fallo revisionare
da -hackers prima di effettuare il commit. Meglio
che sia criticato lì piuttosto che quando è parte del
repository CVS. Se ti capita di effettuare un commit che provoca
controversie, potresti voler considerare l'annullamento delle modifiche
finché il problema sia chiarito. Ricorda – con CVS possiamo
sempre tornare indietro.Non mettere in dubbio le intenzioni di qualcuno che non è
d'accordo con te. Se vedono una soluzione differente dalla tua per un
problema, o anche un problema diverso, non è perché sono
stupidi, perché hanno una dubbia origine, o perché stanno
cercando di distruggere il tuo duro lavoro, la tua immagine personale, o
FreeBSD, ma semplicemente perché hanno una visione differente del
mondo. La diversità è una buona cosa.Dissenti onestamente. Argomenta la tua posizione con i suoi meriti,
sii onesto sui difetti che può avere, e sii disponibile a guardare
le loro soluzioni, o anche le loro visioni del problema, con mente
aperta.Accetta le correzioni. Possiamo tutti sbagliare. Se hai fatto un
errore, scusati e vai avanti con la tua vita. Non picchiarti, e
sicuramente non picchiare gli altri per il tuo sbaglio. Non sprecare
tempo imbarazzandoti o recriminando, risolvi solo il problema e vai
avanti.Chiedi aiuto. Cerca (e dai) revisioni dagli altri. Uno delle cose
in cui dovrebbe eccellere il software open source è il numero di
occhi che lo scrutano; questo non è vero se nessuno
revisionerà il codice.GNATSIl FreeBSD Project utilizza GNATS per
gestire i bug e le richieste di cambiamenti. Assicurati di usare
edit-pr numero-pr su
freefall quando effettui il commit di una correzione o di
un suggerimento trovato in un PR GNATS per
chiuderlo. È inoltre considerato gentile se trovi il tempo di
chiudere ogni PR associato al tuo commit, se esistono. Puoi anche usare
&man.send-pr.1; tu stesso per proporre qualsiasi cambiamento che pensi
debba essere fatto, a seguito di una maggiore revisione da parte di altre
persone.Puoi trovare di più su GNATS
su:http://www.cs.utah.edu/csinfo/texinfo/gnats/gnats.htmlhttp://www.FreeBSD.org/support.html&man.send-pr.1;Puoi far girare una copia locale di GNATS, e poi integrare l'albero
GNATS di FreeBSD in esso tramite CVSup. In seguito puoi usare i comandi
GNATS localmente, o usare altre interfacce, come
tkgnats. Questo ti permette di interrogare il database
dei PR senza bisogno di essere connesso a Internet.Utilizzo di un albero GNATS localeSe non stai già scaricando l'albero GNATS, aggiungi questa
riga al tuo supfile, e riesegui &man.cvsup.1;.
Nota che siccome GNATS non è sotto
il controllo di CVS non ha tag, quindi se lo stai aggiungendo al tuo
supfile esistente deve apparire prima di ogni
voce tag= dato che queste rimangono attive una volta
impostate.gnats release=current prefix=/usrQuesto metterà l'albero GNATS di FreeBSD in
/usr/gnats. Puoi usare un file
refuse per controllare quali categorie ricevere.
Per esempio, per ricevere solo i PR docs, metti
questa riga in /usr/local/etc/cvsup/sup/refuseIl percorso preciso dipende dall'impostazione
*default base nel tuo
supfile..gnats/[a-ce-z]*Il resto di questi esempi assume che tu abbia scaricato solo la
categoria docs. Modificali quando è
necessario, a seconda delle categorie che tieni in sincronia.Installa il port GNATS da
ports/databases/gnats. Questo metterà le
varie directory GNATS sotto
$PREFIX/share/gnats.Crea un symlink per le directory GNATS che aggiorni tramite CVSup
sotto la versione di GNATS che hai installato.&prompt.root; cd /usr/local/share/gnats/gnats-db
&prompt.root; ln -s /usr/gnats/docsRipeti tante volte quanto necessario, a seconda di quante
categorie GNATS tieni in sincronia.Aggiorna il file categories di GNATS con
queste categorie. Il file è
$PREFIX/share/gnats/gnats-db/gnats-adm/categories.# Questa categoria è obbligatoria
pending:Categoria per i PR errati:gnats-admin:
#
# Categorie di FreeBSD
#
docs:Bug di Documentazione:freebsd-doc:Esegui $PREFIX/libexec/gnats/gen-index per
ricreare l'indice GNATS. L'output deve essere reindirizzato su
$PREFIX/share/gnats/gnats-db/gnats-adm/index.
Puoi fare questo periodicamente da &man.cron.8;, o eseguire
&man.cvsup.1; da uno script di shell che fa anche questo.&prompt.root; /usr/local/libexec/gnats/gen-index \
> /usr/local/share/gnats/gnats-db/gnats-adm/indexVerifica la configurazione interrogando il database dei PR.
Questo comando visualizza i PR docs aperti.&prompt.root; query-pr -c docs -s openAnche altre interfacce, come quella fornita dal port databases/tkgnats, dovrebbero funzionare
correttamente.Prendi un PR e chiudilo.Questa procedura funziona solo per permetterti di visualizzare ed
interrogare i PR localmente. Per modificarli o chiuderli dovrai ancora
loggarti su freefall e farlo da lì.Chi è ChiOltre ai meister del repository, ci sono altri membri e team del
FreeBSD Project che probabilmente arriverai a conoscere nel tuo ruolo di
committer. Brevemente, e senza pretesa di elencarli tutti, questi
sono:&a.jhb;John è il manager dell'SMPng Project, e ha
autorità sulla progettazione architetturale e
sull'implementazione del passaggio a un sistema di threading e
locking del kernel a grana fine. È anche l'autore
dell'SMPng Architecture Document. Se stai lavorando sullo stesso
sistema, coordinati con John. Puoi imparare di più
sull'SMPng Project dalla sua home page: &a.jake;, &a.tmm;Jake e Thomas sono i maintainer del port sull'architettura
&sparc64;.&a.doceng;doceng è il gruppo responsabile dell'infrastruttura
per la realizzazione della documentazione, approva i nuovi committer
della documentazione, e assicura che il sito web di FreeBSD e la
documentazione sul sito FTP siano aggiornati rispetto all'albero
CVS. Non è un organo di risoluzione dei conflitti.
La maggior parte delle discussioni relative alla documentazione
prendono posto sulla &a.doc;. I committer interessati a contribuire
alla documentazione dovrebbero familiarizzare con il Documentation
Project Primer.&a.ru;Ruslan è Mister &man.mdoc.7;. Se stai scrivendo una
pagina man e hai bisogno di qualche suggerimento sulla struttura,
o sul linguaggio di markup, chiedi a Ruslan.&a.bde;Bruce è lo Style Police-Meister. Quando fai un commit
che poteva essere fatto meglio, Bruce sarà lì a
dirtelo. Ringrazia che qualcuno lo sia. Bruce conosce anche molto
bene gli standard applicabili a FreeBSD.&a.gallatin;&a.mjacob;&a.dfr;&a.obrien;Questi sono gli sviluppatori e i supervisori primari della
piattaforma DEC Alpha AXP.&a.dg;David è il supervisore del sistema VM. Se hai in mente
una modifica al sistema VM, coordinala con David.&a.dfr;&a.marcel;&a.peter;&a.ps;Questi sono i principali sviluppatori e supervisori della
piattaforma Intel IA-64, ufficialmente conosciuta come l'&itanium;
Processor Family (IPF).&a.murray;&a.steve;&a.rwatson;&a.jhb;&a.bmah;&a.scottl;Questi sono i membri del &a.re;. Questo team è
responsabile di decidere i tempi delle release e controllare il
processo di release. Durante i periodi di congelamento del
codice, gli ingegneri di release hanno l'autorità finale su
tutte le modifiche al sistema per quel ramo di cui si sta preparando
la release. Se c'è qualcosa che vuoi sia fuso da
&os.current; a &os.stable; (qualsiasi valore queste possano avere
in un dato momento), queste sono le persone con cui devi
parlare.Bruce è anche l'autore della documentazione di
release (src/release/doc/*). Se effettui il
commit di una modifica che pensi sia degna di menzione nelle note
di release, assicurati che Bruce lo sappia. Meglio ancora, inviagli
una patch con il tuo commento.&a.benno;Benno è il maintainer ufficiale del port per
&powerpc;.&a.brian;Maintainer ufficiale di
/usr/sbin/ppp.&a.nectar;Jacques è il FreeBSD
Security Officer e supervisiona il
&a.security-officer;.&a.wollman;Se hai bisogno di consigli sulle oscure parti interne delle reti
o non sei sicuro di qualche eventuale modifica al sottosistema di
rete che hai in mente, Garrett è qualcuno con cui parlare.
Garret è inoltre molto esperto sui vari standard applicabili
a FreeBSD.&a.committers;cvs-committers è l'entità che CVS usa per inviarti
tutti i messaggi di commit. Non devi mai
inviare email direttamente a questa lista. Puoi solamente
rispondere a questa lista quando i messaggi sono brevi e
direttamente correlati a un commit.&a.developers;Tutti i committer sono iscritti a -developers. Questa lista
è stata creata per essere un forum sulle questioni della
comunità dei committer. Esempi sono le
votazioni per il Core, annunci, ecc. Questa lista
non è intesa come posto per la revisione
del codice o come rimpiazzo della &a.arch; o della &a.audit;.
Infatti usarla in questo modo urta il FreeBSD Project dato che
dà l'impressione di una lista privata dove vengono prese le
decisioni generali che influenzano tutta la comunità che usa
FreeBSD senza essere rese pubbliche.
Ultimo, ma non per importanza mai e poi mai invia un
messaggio alla &a.developers; mettendo in CC:/BCC: un'altra lista
FreeBSD.
Mai e poi mai invia un messaggio su un'altra mailing list mettendo
in CC:/BCC: la &a.developers;. Fare questo può diminuire
enormemente i benefici di questa lista. Inoltre, non pubblicare o
inoltrare mai email inviate alla &a.developers;. L'atto di inviare
un messaggio alla &a.developers; anziché a una lista
pubblica significa che le informazioni contenute non sono ad uso
pubblico.Guida Rapida a SSHSe stai usando FreeBSD 4.0 o successivo, OpenSSH è incluso
nel sistema base. Se stai usando una release precedente, aggiorna
ed installa uno dei port di SSH. In generale, probabilmente vorrai
prendere OpenSSH dal port security/openssh. Potresti anche voler
estrarre l'ssh1 originale dal port security/ssh, ma sii certo di porre la
dovuta attenzione alla sua licenza. Nota che questi port non possono
essere installati contemporaneamente.Se non vuoi digitare la tua password ogni volta che usi
&man.ssh.1;, e usi chiavi RSA o DSA per autenticarti,
&man.ssh-agent.1; è lì per la tua comodità.
Se vuoi usare &man.ssh-agent.1;, assicurati di eseguirlo prima di
utilizzare altre applicazioni. Gli utenti X, per esempio, solitamente
fanno questo dal loro file .xsession o
.xinitrc. Guarda &man.ssh-agent.1; per i
dettagli.Genera un paio di chiavi con &man.ssh-keygen.1;. Le chiavi
finiranno nella tua directory
$HOME/.ssh.Invia la tua chiave pubblica
($HOME/.ssh/identity.pub)
alla persona che ti sta configurando come committer in modo che possa
inserirla nel file authorized_keys nella tua
home directory su freefall (ad esempio,
$HOME/.ssh/authorized_keys).
Ora dovresti essere in grado di usare &man.ssh-add.1; per autenticarti
una volta a sessione. Ti verrà richiesta la pass phrase della tua
chiave privata, e quindi verrà salvata nel tuo agente di
autenticazione (&man.ssh-agent.1;). Se non vuoi più avere la tua
chiave salvata nell'agente, l'esecuzione di ssh-add -d
la rimuoverà.Verifica facendo qualcosa come ssh freefall.FreeBSD.org ls
/usr.Per maggiori informazioni, guarda security/openssh, &man.ssh.1;,
&man.ssh-add.1;, &man.ssh-agent.1;, &man.ssh-keygen.1;, e
&man.scp.1;.Il Lungo Elenco di Regole dei Committer di FreeBSDTraduzione in corsoSupporto per Diverse ArchitettureTraduzione in corsoFAQ Specifiche sui PortTraduzione in corsoBenefici del LavoroSfortunatamente, non ci sono molti benefici derivanti dall'essere un
committer. Il riconoscimento di essere un progettista di software
competente è probabilmente l'unica cosa che sarà di tuo
vantaggio a lungo termine. Ciononostante, ci sono comunque alcuni
- benefici:
-
-
-
- Accesso diretto al cvsup-master
-
-
- Come committer, puoi chiedere a &a.kuriyama; accesso diretto
- a cvsup-master.FreeBSD.org,
+ benefici:
+
+
+
+ Accesso diretto al cvsup-master
+
+
+ Come committer, puoi chiedere a &a.kuriyama; accesso diretto
+ a cvsup-master.FreeBSD.org,
fornendo l'output della tua chiave pubblica tramite
cvpasswd
- yourusername@FreeBSD.org
- freefall.FreeBSD.org. Nota: devi specificare
- freefall.FreeBSD.org sulla riga di comando si
- cvpasswd anche se il server attuale è
- cvsup-master. L'accesso al
+ yourusername@FreeBSD.org
+ freefall.FreeBSD.org. Nota: devi specificare
+ freefall.FreeBSD.org sulla riga di comando si
+ cvpasswd anche se il server attuale è
+ cvsup-master. L'accesso al
cvsup-master non dovrebbe essere abusato visto che
- è una macchina carica di lavoro.
-
-
-
-
- Un abbonamento gratuito al set da 4 CD
-
-
- FreeBSD Mall,
+ è una macchina carica di lavoro.
+
+
+
+
+ Un abbonamento gratuito al set da 4 CD o DVD
+
+
+ FreeBSD Mall,
Inc. offre un abbonamento gratuito al set da 4 CD o DVD a
tutti i committer di FreeBSD. Le informazioni su come ottenere il
prodotto gratuitamente vengono spedite a
- developers@FreeBSD.org dopo ogni release.
-
-
+ developers@FreeBSD.org dopo ogni release.
+
+ Domande GeneraliTraduzione in corso
diff --git a/it_IT.ISO8859-15/articles/euro/article.sgml b/it_IT.ISO8859-15/articles/euro/article.sgml
index b9b3ce0cfd..90ea625a87 100644
--- a/it_IT.ISO8859-15/articles/euro/article.sgml
+++ b/it_IT.ISO8859-15/articles/euro/article.sgml
@@ -1,399 +1,399 @@
%man;
%it-trademarks;
-
-%trademarks;
+
+%trademarks;
%translators;
]>
Il simbolo dell'Euro su FreeBSDAaronKaplanaaron@lo-res.org20022003The FreeBSD Italian Documentation Project$FreeBSD$
-
- &tm-attrib.freebsd;
- &tm-attrib.general;
-
+
+ &tm-attrib.freebsd;
+ &tm-attrib.general;
+ Questo documento cercherà di aiutarvi ad usare il nuovo
simbolo dell'Euro presente sulla vostra nuova tastiera
comprata all'inizio del 2002 per l'avvento della nuova valuta comune.
Inizieremo dalle parti più importanti come essere in grado di
visualizzare correttamente il simbolo in console. Le sezioni successive
tratteranno la configurazione di specifici programmi come
X11.Molti utili suggerimenti sono stati forniti da Oliver Fromm,
Tom Rhodes e innumerevoli altri.
Grazie! Senza di voi non sarebbe stato possibile realizzare questo
articolo!
- Traduzione a cura di &a.it.dema;.
+ &trans.it.dema;
L'Euro in 5 minutiSe avete già familiarità con la
localizzazione come
descritta nel Manuale di FreeBSD
potreste essere interessanti solamente alle seguenti informazioni che
vi consentiranno di iniziare velocemente ad usare l'Euro:ISO8859-15Questa è una versione leggermente modificata della
più comune mappa caratteri ISO8859-1.
Include il simbolo dell'Euro. Usata per le variabili d'ambiente
LANG e LC_CTYPE.iso15-8x16.fntIl font per la console da usare con &man.vidcontrol.1;/usr/share/syscons/keymaps/*.iso.kbdMappe di tastiera per le diverse lingue. Impostate la vostra
variabile keymap in rc.conf
ad una di queste mappe.LC_CTYPEUsata per impostare il corretto tipo di caratteri nelle vostre
impostazioni locali.XkbLayout
"lingua(euro)"Opzione di configurazione di
XFree86./usr/X11R6/lib/X11/fonts/*/fonts.aliasAssicuratevi di modificare i nomi dei vostri file dei font di
X11 a -*-..-*-iso8859-15Nota generaleNelle sezioni seguenti ci riferiremo spesso a
ISO8859-15.
Questa è la notazione standard a partire da
FreeBSD 4.5.
Nelle versioni più vecchie la notazione standard era invece
ISO_8859-15 oppure
DIS_8859-15.Se state usando una versione di
FreeBSD più vecchia,
assicuratevi di guardare in
/usr/share/locale/ per scoprire quale notazione
è in uso nel vostro sistema.La consoleConfigurare il font della consoleIn base alla risoluzione e dimensione della vostra console
dovrete mettere una delle seguenti linee in
rc.conf:font8x16="iso15-8x16.fnt" # da /usr/share/syscons/fonts/*
font8x14="iso15-8x14.fnt"
font8x8="iso15-8x8.fnt"Questo imposterà effettivamente il font ISO8859-15 conosciuto
anche come Latin-9. ISO8859-15 è una variazione di ISO8859-1.
Potete notare la differenza tra i due esaminando il simbolo dell'Euro:
il suo valore decimale è 164. Nell'ISO8859-1 noterete un
cerchietto con quattro piccoli segnetti agli angoli. Questo è
spesso chiamato simbolo universale di valuta.
Nell'ISO8859-15, invece del cerchietto, avrete il simbolo dell'Euro.
Per il resto i font sono più o meno identici.Al momento della stesura di questo articolo l'unico font
utilizzabile sembra essere l'iso15-8x16.fnt.
Gli altri sembrano avere l'aspetto dello ISO8859-1 sebbene il nome
suggerisca altrimenti.Impostando questo font alcune applicazioni da console avranno
un aspetto rovinato.
Questo è dovuto al fatto che esse si
aspettano di trovare un diverso set di font/caratteri come per esempio
l'ANSI 850. Un tipico esempio è
sysinstall.
Comunque questo non dovrebbe essere un problema nella maggior parte
dei casi.Il vostro prossimo passo dovrebbe essere o riavviare il vostro
sistema affinché i cambiamenti abbiano effetto oppure
(manualmente) effettuare le modifiche nello stesso modo in cui
avverrebbero all'avvio:&prompt.user; vidcontrol -f iso15-8x16.fntPer controllare se il font è stato impostato eseguite il
seguente piccolo script
awk:#!/usr/bin/awk -f
BEGIN {
for(i=160;i<180;i++)
printf"%3d %c\n",i,i
}Il risultato dovrebbe mostrare il simbolo dell'Euro nella
posizione 164.Configurare la vostra tastiera per l'EuroLa maggior parte delle mappe di tastiera dovrebbe essere già
correttamente impostata. Per esempio, se avete una tastiera
italiana e vi funzionano le lettere accentate, potete tranquillamente
saltare questa sezione visto che la tastiera mappa correttamente la
combinazioni di caratteri, qualunque essa sia,
(ad esempio: Alt Gre) al valore decimale 164.
Se avete problemi la cosa migliore è controllare i file in
/usr/share/syscons/keymaps/*.kbd.
Il formato dei file delle mappe di tastiera è descritto in
&man.keyboard.4;. &man.kbdcontrol.1; può essere usato per
caricare una mappa personalizzata.Una volta che è stata trovata la corretta mappa di tastiera,
dovete aggiungerla a /etc/rc.conf con la
linea:keymap="it.iso" # o un'altra mappaCome spiegato in precedenza, questo passo probabilmente lo avete
già fatto al momento dell'installazione (con
sysinstall).
In caso contrario, riavviate oppure caricate la nuova mappa con
&man.kbdcontrol.1;.Per verificare la nuova mappatura della tastiera, passate ad una
nuova console e al prompt di login, invece di
loggarvi, provate a premere il tasto Euro.
Se non funziona assicuratevi di aver correttamente impostato la
giusta mappa di tastiera oppure inviate una segnalazione di bug
con &man.send-pr.1;.Al momento il tasto Euro non funziona ancora con
bash o
tcsh.Correggere le variabili d'ambienteLe shell (bash,
tcsh) si basano sulla libreria
&man.readline.3;, la quale a sua volta utilizza la variabile d'ambiente
LC_CTYPE. LC_CTYPE deve essere impostata
prima che la shell sia completamente operativa.
Fortunatamente è sufficiente aggiungere la linea:export LC_CTYPE=it_IT.ISO8859-15al vostro file .bash_profile
(bash), oppure:setenv LC_CTYPE it_IT.ISO8859-15al vostro file .login
(tcsh). Naturalmente,
it_IT deve essere sostituito con la
vostra lingua. Poi, sloggatevi e riloggatevi nuovamente, e verificate
che il tasto Euro funzioni.
Già così la maggior parte delle applicazioni console
dovrebbe funzionare correttamente col tasto Euro.
Ulteriori configurazioni per programmi speciali come
pine potrebbero essere comunque
necessarie.Un'alternativa alla modifica di .login e
.bash_profile è quella di impostare le
variabili d'ambiente tramite &man.login.conf.5;. Questo approccio
ha il vantaggio di assegnare classi di login a determinati utenti
(esempio, utenti Francesi, utenti Tedeschi, ecc.)
in un solo posto.Modificare X11Modificate /etc/XF86Config secondo le
seguenti istruzioni:Option "XkbLayout" "it(euro)"Come sempre, rimpiazzate it con la
vostra lingua. Così facendo la tastiera dovrebbe essere
configurata correttamente. Come in console, deve essere scelto il font
adatto. Per le applicazioni KDE andate in
KDE control center ->
Personalization -> Country & Language -> Charset e
cambiatelo in ISO8859-15.
Simili modifiche si devono effettuare per
kmail e altre applicazioni.Un'altra buona idea è modificare i vostri file
fonts.alias.
In particolar modo il font fixed dovrebbe essere
modificato per usare la giusta mappa caratteri. Il file
/usr/X11R6/lib/X11/fonts/misc/fonts.alias
dell'autore è mostrato come esempio:! $Xorg: fonts.alias,v 1.3 2000/08/21 16:42:31 coskrey Exp $
fixed -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-15
variable -*-helvetica-bold-r-normal-*-*-120-*-*-*-*-iso8859-15
(...)Come in console, applicazioni speciali hanno ancora i font
ISO8859-1 configurati nei loro rispettivi database &man.xrdb.1;.
Un esempio importante è xterm.
Come regola generale è sufficiente cambiare il corrispondente file
di configurazione in
/usr/X11R6/lib/X11/app-defaults
e aggiungere il font corretto. Ecco come fare per
xterm.&prompt.root; cd /usr/X11R6/lib/X11/app-defaults/
&prompt.root; vi XTermAggiungete la seguente linea all'inizio del file:*font: -misc-fixed-medium-r-normal-*-*-120-*-*-c-*-iso8859-15Infine, fate ripartire X e assicuratevi che i font siano
visualizzati correttamente eseguendo il precedente
script awk.
Tutte le principali applicazioni dovrebbero rispettare la mappatura di
tastiera e l'impostazione del font.Problemi non ancora risoltiNaturalmente, l'autore gradirebbe ricevere i vostri commenti.
Inoltre, fatemi almeno sapere se avete soluzioni per questi problemi
irrisolti.Descrivere metodi alternativi per configurare
XFree86:
x11/xkeycapsImpostazioni in GNOMEImpostazioni in XFCEImpostazioni per (X)EmacsDescrivere l'UTF-8Descrivere libiconv come un buon
sistema per convertire applicazioni da ISO8859-15 a UTF-{8,16}
diff --git a/it_IT.ISO8859-15/articles/explaining-bsd/article.sgml b/it_IT.ISO8859-15/articles/explaining-bsd/article.sgml
index 475dad93ac..5b56f159fb 100644
--- a/it_IT.ISO8859-15/articles/explaining-bsd/article.sgml
+++ b/it_IT.ISO8859-15/articles/explaining-bsd/article.sgml
@@ -1,614 +1,614 @@
%man;
-
-%freebsd;
+
+%freebsd;
%it-trademarks;
-
-%trademarks;
+
+%trademarks;
%translators;
]>
Panoramica su BSDGregLeheygrog@FreeBSD.org
-
- &tm-attrib.freebsd;
- &tm-attrib.apple;
- &tm-attrib.linux;
- &tm-attrib.opengroup;
- &tm-attrib.sun;
- &tm-attrib.xfree86;
- &tm-attrib.general;
-
-
+
+ &tm-attrib.freebsd;
+ &tm-attrib.apple;
+ &tm-attrib.linux;
+ &tm-attrib.opengroup;
+ &tm-attrib.sun;
+ &tm-attrib.xfree86;
+ &tm-attrib.general;
+
+
Nel mondo open source, la parola Linux è quasi
sinonimo di Sistema Operativo, ma non si tratta del solo
sistema operativo &unix; open source. Secondo
l'Internet
Operating System Counter, ad Aprile del 1999 il 31.3% delle
macchine connesse in rete ha in esecuzione Linux.
Il 14.6% fa girare BSD &unix;.
Alcuni dei più grandi operatori del web, come Yahoo!, usano BSD. Il server
FTP più affollato del mondo, ftp.cdrom.com, usa BSD per
trasferire 1.4 TB di dati al giorno. Chiaramente questo non è
un mercato di nicchia: BSD è un segreto ben mantenuto.Dunque, qual è il segreto? Perché BSD non è
conosciuto meglio? Questo documento risponde a questa e ad altre
domande.In questo documento, le differenze tra BSD e Linux verranno
evidenziate così.
- Traduzione a cura di &a.it.surrender;.
+ &trans.it.surrender;
Cos'è BSD?BSD sta per Berkeley Software Distribution. È
il nome delle distribuzioni di codice sorgente dell'Università
della California, Berkeley, che erano originariamente estensioni al
sistema operativo &unix; del settore Ricerca della AT&T.
Molti progetti open source di sistemi operativi sono basati
su una versione di questo codice sorgente noto come
4.4BSD-Lite. Inoltre, essi comprendono un gran numero di
pacchetti provenienti da altri progetti Open Source, incluso, in
particolare, il progetto GNU. L'intero sistema operativo
comprende:Il kernel BSD, che gestisce lo scheduling dei processi, l'utilizzo
della memoria, il supporto multiprocessore (SMP), i driver dei
vari dispositivi, ecc.Diversamente dal kernel Linux, ci sono differenti
kernel BSD con differenti caratteristiche.La libreria C, le API di base per il sistema.La libreria C BSD è basata su codice proveniente
da Berkeley, non dal progetto GNU.Utilità come shell, file manager, compilatori e
linker.Alcune delle applicazioni derivano dal
progetto GNU, altre no.L'X Window System, che gestisce la visualizzazione grafica.L'X Window System usato nella maggior parte delle versioni di
BSD viene mantenuto come un progetto separato, il
progetto &xfree86;.
Questo è lo stesso codice usato da Linux. BSD in genere non
specifica un desktop grafico come GNOME o KDE,
anche se questi sono disponibili.Molti altri programmi ed utilità.Cosa, un vero &unix;?I sistemi operativi BSD non sono cloni, ma derivati open source
del sistema operativo &unix; dell'AT&T Research, che è anche
l'antenato del moderno &unix; System V. Questo potrebbe sorprendere.
Come è potuto accadere questo, se la AT&T non ha mai rilasciato
il suo codice come open source?È vero che lo &unix; AT&T non è open source, e nel
senso del copyright BSD in definitiva non è
&unix;, ma d'altro canto l'AT&T ha importato sorgenti da altri
progetti, in maniera rilevante dal Computer Sciences Research Group
dell'Università della California a Berkeley, CA. Iniziato nel
1976, il CSRG ha iniziato a rilasciare nastri con il loro software,
chiamandolo Berkeley Software Distribution o
BSD.Le versioni iniziali di BSD consistevano principalmente di programmi
utente, ma questo cambiò drammaticamente quando il CSRG
sottoscrisse un contratto con la
Defense Advanced Projects Research Agency (DARPA) per migliorare
i protocolli di comunicazione della loro rete, ARPANET. I nuovi
protocolli furono conosciuti come Internet Protocols,
e in seguito come TCP/IP, ai nomi dei protocolli
più importanti. La prima implementazione distribuita in maniera
estesa fu parte di 4.2BSD, nel 1982.Nel corso degli '80, sorsero un certo numero di compagnie
che producevano workstation. Molti preferirono usare &unix; su licenza
piuttosto che sviluppare da soli un nuovo sistema operativo.
In particolare, la Sun Microsystems rilicenziò &unix; ed
implementò una versione commerciale di 4.2BSD, che chiamò
SunOS. Quando alla AT&T stessa fu permesso di vendere &unix;
commercialmente, cominciarono con una implementazione ridotta all'osso
nota come System III, presto seguita da System V.
Il codice fondamentale di System V non comprendeva la parte di rete,
dunque tutte le implementazioni includevano software addizionale tratto
da BSD, incluso il software legato al TCP/IP, ma anche utilità come
la shell csh e l'editor vi.
Complessivamente, questi miglioramenti furono conosciuti
come le Estensioni Berkeley.Il nastro BSD conteneva codice AT&T e dunque richiedeva
una licenza per il sorgente &unix;. Dal 1990, il finanziamento del CSRG
si stava esaurendo, e se ne stava per affrontare la chiusura.
Alcuni membri del gruppo decisero di rilasciare il codice BSD,
che era Open Source, senza il codice proprietario della AT&T.
Ciò accadde infine con il Networking Tape 2,
in genere noto come Net/2. Net/2 non era un sistema
operativo completo: mancava circa il 20% del codice del kernel. Uno dei
membri del CSRG, William F. Jolitz, scrisse il codice rimanente e lo
rilasciò all'inizio del 1992 come 386BSD.
Allo stesso tempo, un altro gruppo di ex membri del CSRG formò una
compagnia chiamata Berkeley Software
Design Inc. e rilasciò una versione beta di un sistema
operativo chiamato BSD/386,
che era basato sugli stessi sorgenti. Il nome del sistema operativo
è cambiato di recente in BSD/OS.386BSD non divenne mai un sistema operativo stabile. Invece, due
altri progetti se ne distaccarono nel 1993:
NetBSD e
FreeBSD.
I due progetti presero inizialmente direzioni divergenti, a causa della
differente pazienza nell'attendere miglioramenti a
386BSD: la gente di NetBSD cominciò all'inizio dell'anno,
e la prima versione di FreeBSD non fu pronta fino alla fine
dell'anno. Nel frattempo, i codici erano diventati abbastanza differenti
da renderne difficile la fusione. Inoltre, i progetti avevano obiettivi
differenti, come vedremo in seguito. Nel 1996, un ulteriore progetto,
OpenBSD, si divise da
NetBSD.Perché BSD non è più conosciuto?Per un certo numero di ragioni, BSD è relativamente
sconosciuto:Gli sviluppatori BSD sono spesso più interessati
a ripulire il loro codice che a fagli pubblicità.Molta della popolarità di Linux è dovuta a fattori
esterni al progetto Linux, come la stampa, e le compagnie formate per
fornire servizi relativi a Linux. Fino a poco tempo fa,
la varie versioni di BSD open source non avevano tali spinte.Gli sviluppatori BSD tendono ad avere più esperienza
di quelli di Linux, ed hanno meno interesse nel rendere il sistema
facile da usare.
I nuovi arrivati tendono a sentirsi più a loro agio con
Linux.Nel 1992, l'AT&T citò in giudizio
BSDI,
il produttore di BSD/386, sostenendo che il prodotto conteneva
codice sotto copyright della AT&T. Il caso fu risolto in
tribunale nel 1994, ma lo spettro della causa continua a perseguitare
alcune persone. Nel marzo 2000 un articolo pubblicato sul web
sosteneva che il caso era stato concluso
recentemente.Un dettaglio che venne chiarito dall'azione legale fu il nome:
negli anni '80, BSD era stato conosciuto come BSD
&unix;.
Con l'eliminazione delle ultima vestigia del codice AT&T da BSD,
si era perso anche il diritto di usare il nome &unix;. Per questo
noterete riferimenti nei libri al sistema operativo 4.3BSD
&unix; ed al sistema operativo 4.4BSD.C'è una certa percezione che il progetto BSD sia
frammentato e belligerante. Il Wall
Street Journal parlò di
balcanizzazione dei progetti BSD. Come per l'azione
legale, questa percezione si basa principalmente su vecchie
storie.Paragone tra BSD e LinuxDunque qual'è l'effettiva differenza tra, diciamo, Debian
Linux e FreeBSD? Per l'utente medio, la differenza è
sorprendentemente piccola: entrambi sono sistemi operativi tipo &unix;.
Entrambi vengono sviluppati da progetti non commerciali (questo non si
applica a molte altre distribuzioni di Linux, ovviamente). Nella sezione
seguente, daremo un'occhiata a BSD e lo paragoneremo a Linux.
La descrizione si applica molto da vicino a FreeBSD, che conta per un 80%
delle installazioni BSD, ma le differenza da NetBSD ed OpenBSD sono
piccole.Chi possiede BSD?Nessuna persona o società possiede BSD. Esso è creato
e distribuito da una comunità di persone con grande preparazione
tecnica e voglia di fare che contribuiscono da tutto il mondo.
Alcuni dei componenti di BSD sono progetti open source gestiti da
diversi responsabili.Come viene sviluppato ed aggiornato BSD?I kernel BSD vengono sviluppati ed aggiornati
seguendo il modello di sviluppo open source. Ogni progetto mantiene
un albero dei sorgenti liberamente accessibile in
un Concurrent Versions
System, un sistema di gestione delle versioni concorrenti,
che contiene tutti i file sorgenti del progetto,
inclusa la documentazione ed altri file inerenti. Il CVS
permette agli utenti di estrarre (in sostanza,
estrarre una copia di) ogni versione desiderata del sistema.Un grande numero di sviluppatori da tutto il mondo contribuisce al
miglioramento di BSD. Essi sono divisi in tre grandi gruppi:I contributor scrivono codice o
documentazione. Non gli è permesso di effettuare il commit
(aggiungere codice) direttamente all'albero dei sorgenti.
Affinché il loro codice sia incluso nel sistema, esso
deve essere rivisto e controllato da uno sviluppatore registrato,
noto come committer.I committer sono sviluppatori
con accesso in scrittura all'albero dei sorgenti.
Per poter divenire un committer, un individuo deve dimostrare
abilità nell'area nella quale è attivo.
È a discrezione del committer la volontà di
confrontarsi con qualcuno prima di effettuare cambiamenti. In
generale, un committer con esperienza può effettuare
cambiamenti che sono ovviamente corretti senza interrogare nessuno.
Ad esempio, un committer del progetto di documentazione può
correggere errori tipografici o grammaticali senza un confronto con
altri. D'altro canto, dagli sviluppatori che stanno per effettuare
cambiamenti profondi o complessi ci si aspetta che sottopongano i
cambiamenti a revisione prima di renderli effettivi. In casi
estremi, un membro del core team, con una funzione simile a un Capo
Architetto, può ordinare che i cambiamenti siano rimossi
dall'albero, un processo noto come marcia
indietro.
Tutti i committer ricevono una lettera che descrive ogni
modifica individuale, dunque non è possibile effettuare un
commit segretamente.Il Core Team. FreeBSD e NetBSD
hanno ognuno un core team che gestisce il progetto. I
core team si sono modificati nel corso del progetto, ed i loro
ruoli non sempre sono ben definiti. Non è necessario essere
uno sviluppatore per far parte del core team, anche se è
normale che sia così. Le regole
per il core team variano da un progetto ad un altro, ma in
generale chi ne fa parte ha più autorità
nell'indirizzamento del progetto rispetto agli altri membri.Questa organizzazione differisce da Linux in vari modi:Nessuna persona controlla il contenuto del sistema. In
pratica, questa differenza è sopravvalutata, poiché
il Capo Architetto può richiedere che il codice sia
rimosso, ed anche nel progetto Linux viene permesso a
molte persone di effettuare cambiamenti.D'altra parte, c'è un deposito
centrale, un punto singolo dove è possibile trovare i
sorgenti dell'intero sistema, incluse tutte le vecchie
versioni.I progetti BSD mantengono l'intero Sistema
Operativo, non solo il kernel. Questa distinzione
è utile solo marginalmente: né BSD né Linux
sono utili senza applicazioni. Le applicazioni usate su BSD sono
spesso le stesse usate su Linux.Come risultato di un mantenimento formalizzato
di un singolo CVS per l'albero dei sorgenti, lo sviluppo di BSD
è chiaro, ed è possibile accedere ad ogni versione del
sistema dal numero di release o dalla data.
Il CVS permette anche aggiornamenti incrementali del sistema: ad
esempio, il repository di FreeBSD viene aggiornato più o meno
100 volte al giorno. La maggior parte dei cambiamenti sono
piccoli.Release di BSDOgni progetto BSD fornisce il sistema in tre
release differenti. Come per Linux, alle release
vengono assegnati dei numeri come 1.4.1 o 3.5. Inoltre, il numero di
versione ha un suffisso che indica il suo scopo:la versione di sviluppo del sistema è chiamata
CURRENT. FreeBSD assegna un numero
alla CURRENT, ad esempio FreeBSD 5.0-CURRENT. NetBSD usa uno
schema di denominazione leggermente differente
ed aggiunge un suffisso di una singola lettera che indica
i cambiamenti nell'interfaccia interna, ad esempio NetBSD
1.4.3G. OpenBSD non assegna un numero
(OpenBSD-current).
Tutti gli sviluppi del sistema vanno in questo ramo.A intervalli regolari, tra le due e le quattro volte all'anno, i
progetti fanno uscire una versione RELEASE
del sistema, disponibile su CD-ROM e come libero download da siti
FTP, ad esempio OpenBSD 2.6-RELEASE o NetBSD 1.4-RELEASE.
La versione RELEASE è intesa per gli utenti finali ed
è la versione normale del sistema. NetBSD fornisce anche
patch release, versioni con solo piccole
correzioni, con una terza cifra, ad esempio NetBSD 1.4.2.Quando vengono trovati dei bug in una versione RELEASE,
vengono corretti, e le correzioni vengono aggiunte all'albero del
CVS. In FreeBSD, la versione risultante viene detta
STABLE, mentre in NetBSD ed OpenBSD continua
a chiamarsi RELEASE. Caratteristiche minori possono essere aggiunte
a questo ramo dopo un periodo di test nel ramo CURRENT.In contrasto, Linux mantiene due alberi di codice
differenti: la versione stabile e la versione di sviluppo.
Le versioni stabili hanno un numero di versione pari, come 2.0, 2.2 o
2.4. Le versioni di sviluppo hanno numero di versione dispari, come
2.1, 2.3 o 2.5. In ogni caso, il numero è seguito da un
ulteriore numero che indica la versione esatta. Inoltre, ogni
venditore aggiunge i suoi programmi utente o le sue utilità,
dunque anche il nome della distribuzione è importante. Ogni
venditore di distribuzione assegna anche un numero di versione alla
distribuzione, dunque una descrizione completa dovrebbe essere una
cosa del tipo TurboLinux 6.0 con kernel
2.2.14Quali versioni di BSD sono disponibili?In contrasto alle numerose distribuzioni Linux, ci sono solo
tre BSD open source. Ogni progetto BSD mantiene il suo albero dei
sorgenti ed il suo kernel. In pratica, comunque, ci sono meno
divergenze tra i codici dei programmi utente dei vari progetti di quante
ce ne siano in Linux.È difficile catalogare gli obiettivi di ogni progetto:
le differenze sono molto soggettive. Di base,FreeBSD punta alle alte prestazioni e alla facilità d'uso
per l'utente finale, ed è molto usato dai fornitori di
contenuti web. Funziona su PC e processori Alpha della Compaq.
Il progetto FreeBSD ha nettamente più utenti degli
altri.NetBSD punta alla massima portabilità: of course
it runs NetBSD, ovviamente ci gira NetBSD.
Funziona su macchine che vanno dai palmtop ai grossi
server, ed è anche stato usato dalla NASA in alcune missioni
spaziali. È una scelta particolarmente buona per il vecchio
hardware non Intel.OpenBSD punta alla sicurezza e alla purezza del codice: usa una
combinazione dei concetti open source e un rigoroso controllo
del codice per creare un sistema la cui correttezza sia
dimostrabile, rendendolo la scelta di organizzazioni attente alla
sicurezza come banche, borse e dipartimenti del governo
statunitense.
Come NetBSD, funziona su un gran numero di piattaforme.Ci sono anche altri due sistemi operativi BSD che non sono open
source, BSD/OS e il &macos; X della Apple:BSD/OS è il più antico dei derivati di 4.4BSD.
Non è open source, anche se licenze per il codice sorgente
sono disponibili ad un costo relativamente basso. Assomiglia a
FreeBSD in molti sensi.&macos;
X è l'ultima versione del sistema operativo per
la linea &macintosh; della Apple
Computer Inc.. L'anima BSD &unix; di questo sistema
operativo, Darwin, è
disponibile come un sistema operativo open source completamente
funzionante per computer x86 e PPC. Il sistema grafico Aqua/Quartz
e molti altri aspetti proprietari di &macos; X rimangono comunque
closed source. Numerosi sviluppatori di Darwin sono anche
committer di FreeBSD, e viceversa.Come differisce la licenza BSD dalla GNU Public?Linux è disponibile con licenza GNU General Public
License (GPL), che è pensata per eliminare il software
closed source. In particolare, ogni lavoro derivante da un prodotto
rilasciato sotto GPL deve essere fornito anche con il codice sorgente,
se richiesto. Al contrario, la licenza
BSD è meno restrittiva: le distribuzioni dei soli
binari sono permesse. Ciò è particolarmente attraente per
le applicazioni embedded.Cos'altro dovrei sapere?Poiché sono disponibili meno applicazioni per BSD che per
Linux, gli sviluppatori BSD hanno creato un pacchetto di
compatibilità con Linux, che permette ai programmi per Linux di
funzionare su BSD. Il pacchetto include sia modifiche al kernel, in
modo da permettere l'esecuzione corretta di chiamate di sistema
Linux, che file di compatibilità, come la libreria C. Non
c'è una differenza notevole nella velocità di esecuzione
tra una applicazione in esecuzione su una macchina Linux ed una
applicazione in esecuzione su una macchina BSD con pari
caratteristiche.La natura tutto da una sola fonte di BSD fa sì
che gli aggiornamenti siano molto più semplici da gestire
rispetto alla maggior parte dei casi in Linux. BSD gestisce gli
aggiornamenti della versione di libreria fornendo moduli di
compatibilità per le versioni precedenti, dunque è
possibile eseguire binari di parecchi anni prima senza problemi.Cosa dovrei usare, BSD o Linux?Cosa significa tutto questo in pratica? Chi dovrebbe usare BSD, chi
dovrebbe usare Linux?Questa è una domanda molto difficile a cui rispondere. Qui
ci sono alcune linee guida:Se non è rotto, non aggiustarlo: se usi
già un sistema operativo open source, e ne sei soddisfatto,
probabilmente non c'è ragione di cambiare.I sistemi BSD, in particolare FreeBSD, possono avere prestazioni
notevolmente migliori di Linux. Ma questo non avviene in tutti i
campi. In molti casi, c'è una differenza minima nelle
prestazioni. In alcuni casi, Linux può comportarsi meglio di
FreeBSD.In generale, i sistemi BSD hanno una reputazione migliore di
affidabilità, principalmente come risultato di una base di
codice più maturo.La licenza BSD può essere più attraente della
GPL.BSD può eseguire codice Linux, mentre Linux non
può eseguire codice BSD. Come risultato, c'è
più software disponibile per BSD che per Linux.Chi fornisce supporto, servizi, e training su BSD?BSD ha sempre supportato BSD/OS, e recentemente ha
annunciato contratti di supporto per FreeBSD.Inoltre, ognuno dei progetti ha una lista di consulenti a pagamento:
FreeBSD,
NetBSD,
e OpenBSD.
diff --git a/it_IT.ISO8859-15/articles/filtering-bridges/article.sgml b/it_IT.ISO8859-15/articles/filtering-bridges/article.sgml
index f25ec47788..059bc8adaf 100644
--- a/it_IT.ISO8859-15/articles/filtering-bridges/article.sgml
+++ b/it_IT.ISO8859-15/articles/filtering-bridges/article.sgml
@@ -1,435 +1,435 @@
%man;
%it-trademarks;
-
+
%trademarks;
]>
Filtering BridgesAlexDupre
- sysadmin@alexdupre.com
+ ale@FreeBSD.org$FreeBSD$
-
-
- &tm-attrib.freebsd;
- &tm-attrib.3com;
- &tm-attrib.intel;
- &tm-attrib.general;
-
+
+
+ &tm-attrib.freebsd;
+ &tm-attrib.3com;
+ &tm-attrib.intel;
+ &tm-attrib.general;
+ Spesso è utile dividere una rete fisica (come una Ethernet)
in due segmenti separati, senza dover creare sottoreti e usare un router
per collegarli assieme. Il dispositivo che collega due reti insieme in
questo modo è chiamato bridge. Un sistema FreeBSD con due
interfacce di rete è sufficiente per raggiungere lo scopo.Un bridge funziona individuando gli indirizzi del livello
MAC (indirizzi Ethernet) dei dispositivi collegati ad
ognuna delle sue interfacce di rete e inoltrando il traffico tra le due
reti solo se il mittente e il destinatario si trovano su segmenti
differenti. Sotto molti punti di vista un brigde è simile a uno
switch Ethernet con solo due porte.Perché usare un filtering bridge?Sempre più frequentemente, grazie all'abbassamento dei costi
delle connessioni a banda larga (xDSL) e a causa della riduzione del
numero di indirizzi IPv4 disponibili, molte società si ritrovano
collegate ad Internet 24 ore su 24 e con un numero esiguo (a volte nemmeno
una potenza di 2) di indirizzi IP. In situazioni come queste spesso
è desiderabile avere un firewall che regoli i permessi di ingresso
e uscita per il traffico da e verso Internet, ma una soluzione basata
sulle funzionalità di packet filtering dei router può non
essere applicabile, vuoi per problemi di suddivisione delle sottoreti,
vuoi perché il router è di proprietà del fornitore di
accesso (ISP), vuoi perché il router non
supporta tali funzionalità. È in questi casi che l'utilizzo
di un filtering bridge diventa altamente consigliato.Un firewall basato su bridge può essere configurato e inserito
direttamente tra il router xDSL e il vostro hub/switch Ethernet senza
alcun problema di assegnazione di indirizzi IP.La traduzione italiana di firewall è
muro anti incendio, nonmuro di fuoco come molti pensano. Nel corso
dell'articolo, comunque, manterrò i termini tecnici nella loro
lingua originale in modo da non creare confusione o
ambiguità.Metodi d'installazioneAggiungere le funzionalità di bridge a una macchina FreeBSD non
è difficile. Dalla release 4.5 è possibile caricare tali
funzionalità come moduli anziché dover ricompilare il
kernel, semplificando di gran lunga la procedura. Nelle prossime
sottosezioni spiegherò entrambi i metodi di installazione.Non seguite entrambe le istruzioni: le
procedure sono a esclusione. Scegliete
l'alternativa che meglio si adatta alle vostre esigenze e
capacità.Prima di continuare è necessario assicurarsi di avere almeno
due schede di rete Ethernet che supportino la modalità promiscua
sia in ricezione che in trasmissione, difatti devono essere in grado di
inviare pacchetti Ethernet con qualunque indirizzo, non solo il loro.
Inoltre, per avere un buon rendimento, le schede dovrebbero essere di
tipo PCI bus mastering. Le scelte migliori sono ancora le Intel
ðerexpress; Pro seguite dalle &tm.3com; 3c9xx subito dopo. Per
comodità nella configurazione del firewall può essere
utile avere due schede di marche differenti (che usino drivers
differenti) in modo da distinguere chiaramente quale interfaccia sia
collegata al router e quale alla rete interna.Configurazione del KernelCosì avete deciso di utilizzare il più vecchio e
collaudato metodo di installazione. Per prima cosa bisogna
aggiungere le seguenti righe al file di configurazione del
kernel:options BRIDGE
options IPFIREWALL
options IPFIREWALL_VERBOSELa prima riga serve a compilare il supporto per il bridge, la
seconda il firewall e la terza le funzioni di logging del firewall.
Adesso è necessario compilare e installare il nuovo kernel.
Si possono trovare le istruzioni nella sezione
Building and Installing a Custom Kernel dell'handbook.Caricamento dei ModuliSe avete deciso di usare il nuovo e più semplice metodo di
installazione, l'unica cosa da fare è aggiungere la seguente riga
al file /boot/loader.conf:bridge_load="YES"In questo modo all'avvio della macchina verrà caricato
insieme al kernel anche il modulo bridge.ko. Non
è necessario invece aggiungere una riga per il modulo
ipfw.ko in quanto verrà caricato in
automatico dallo script /etc/rc.network dopo aver
seguito i passi della prossima sezione.Preparativi finaliPrima di riavviare per caricare il nuovo kernel o i moduli richiesti
(a seconda del metodo che avete scelto in precedenza), bisogna effettuare
alcune modifiche al file /etc/rc.conf. La regola di
default del firewall è di rifiutare tutti i pacchetti IP. Per
iniziare attiviamo il firewall in modalità ,
in modo da verificare il suo funzionamento senza alcun problema di
filtraggio pacchetti (nel caso stiate eseguendo questa procedura da
remoto, tale accorgimento vi consentirà di non rimanere
erroneamente tagliati fuori dalla rete).
Inserite queste linee nel file /etc/rc.conf:firewall_enable="YES"
firewall_type="open"
firewall_quiet="YES"
firewall_logging="YES"La prima riga serve ad attivare il firewall (e a caricare il modulo
ipfw.ko nel caso non fosse già compilato nel
kernel), la seconda a impostarlo in modalità
(come descritto nel file
/etc/rc.firewall), la terza a non
visualizzare il caricamento delle regole e la quarta ad abilitare il
supporto per il logging.Per quanto riguarda la configurazione delle interfacce di rete, il
metodo più utilizzato è quello di assegnare un IP a solo una
delle schede di rete, ma il bridge funziona egualmente anche se entrambe o
nessuna delle interfacce ha IP settati. In quest'ultimo caso (IP-less) la
macchina bridge sarà ancora più nascosta in quanto
inaccessibile dalla rete: per configurarla occorrerà quindi entrare
da console o tramite una terza interfaccia di rete separata dal bridge. A
volte all'avvio della macchina qualche programma richiede di accedere alla
rete, per esempio per una risoluzione di dominio: in questo caso è
necessario assegnare un IP all'interfaccia esterna (quella collegata a
Internet, dove risiede il server DNS), visto che il
bridge verrà attivato alla fine della procedura di avvio. Questo
vuol dire che l'interfaccia fxp0 (nel nostro
caso) deve essere menzionata nella sezione ifconfig del file
/etc/rc.conf, mentre la xl0
no. Assegnare IP a entrambe le schede di rete non ha molto senso, a meno
che durante la procedura di avvio non si debba accedere a servizi presenti
su entrambi i segmenti Ethernet.C'è un'altra cosa importante da sapere. Quando si utilizza IP
sopra Ethernet ci sono due protocolli Ethernet in uso: uno è IP,
l'altro è ARP. ARP permette
la conversione dell'indirizzo IP di una macchina nel suo indirizzo
Ethernet (livello MAC). Affinché due macchine
separate dal bridge riescano a comunicare tra loro è necessario che
il bridge lasci passare i pacchetti ARP. Tale
protocollo non fa parte del livello IP, visto che è presente solo
con IP sopra Ethernet. Il firewall di FreeBSD agisce esclusivamente sul
livello IP e quindi tutti i pacchetti non IP (compreso
ARP) verranno inoltrati senza essere filtrati, anche se
il firewall è configurato per non lasciar passare nulla.Ora è arrivato il momento di riavviare la macchina e usarla
come in precedenza: appariranno dei nuovi messaggi riguardo al bridge e al
firewall, ma il bridge non sarà attivato e il firewall, essendo in
modalità , non impedirà nessuna
operazione.Se ci dovessero essere dei problemi, è il caso di scoprire ora
da cosa derivino e risolverli prima di continuare.Attivazione del BridgeA questo punto, per attivare il bridge, bisogna eseguire i seguenti
comandi (avendo l'accortezza di sostituire i nomi delle due interfacce di
rete fxp0 e xl0 con i
propri):&prompt.root; sysctl net.link.ether.bridge_cfg=fxp0:0,xl0:0
&prompt.root; sysctl net.link.ether.bridge_ipfw=1
&prompt.root; sysctl net.link.ether.bridge=1La prima riga specifica tra quali interfacce va attivato il bridge,
la seconda abilita il firewall sul bridge ed infine la terza attiva il
bridge.A questo punto dovrebbe essere possibile inserire la macchina tra
due gruppi di host senza che venga compromessa qualsiasi
possibilità di comunicazione tra di loro. Se è così,
il prossimo passo è quello di aggiungere le parti
net.link.ether.[blah]=[blah]
di queste righe al file /etc/sysctl.conf, in modo che
vengano eseguite all'avvio della macchina.Configurazione del FirewallOra è arrivato il momento di creare il proprio file con le
regole per il firewall, in modo da rendere sicura la rete interna.
Ci sono delle complicazioni nel fare questo, perché non tutte le
funzionalità del firewall sono disponibili sui pacchetti inoltrati
dal bridge. Inoltre, c'è una differenza tra i pacchetti che stanno
per essere inoltrati dal bridge e quelli indirizzati alla macchina locale.
In generale, i pacchetti che entrano nel bridge vengono processati dal
firewall solo una volta, non due come al solito; infatti vengono filtrati
solo in ingresso, quindi qualsiasi regola che usi
oppure non verrà mai eseguita. Personalmente
uso che è una sintassi più antica,
ma che ha un senso quando la si legge.
Un'altra limitazione è che si possono usare solo i comandi
e per i pacchetti filtrati
dal bridge. Cose avanzate come ,
o non sono disponibili.
Queste opzioni possono ancora essere usate, ma solo per il traffico da
e verso la macchina bridge stessa (sempre che le sia stato assegnato
un IP).Nuovo in FreeBSD 4.0 è il concetto di stateful filtering.
Questo è un grande miglioramento per il traffico
UDP, che consiste tipicamente di una richiesta in
uscita, seguita a breve termine da una risposta con la stessa coppia di
indirizzi IP e numeri di porta (ma con mittente e destinatario invertiti,
ovviamente). Per i firewall che non supportano il mantenimento di stato,
non c'è modo di gestire questo breve scambio di dati come una
sessione unica. Ma con un firewall che può
ricordarsi di un pacchetto UDP in
uscita e permette una risposta nei minuti successivi, gestire i
servizi UDP è semplice.
L'esempio seguente mostra come fare. La stessa cosa è
possibile farla con i pacchetti TCP. Questo
permette di evitare qualche tipo di attacco denial of service e altri
sporchi trucchi, ma tipicamente fa anche crescere velocemente la
tabella di stato.Vediamo un esempio di configurazione. Bisogna notare che all'inizio
del file /etc/rc.firewall ci sono già delle
regole standard per l'interfaccia di loopback
lo0, quindi non ce ne occuperemo più ora.
Le regole personalizzate andrebbero messe in un file a parte (per esempio
/etc/rc.firewall.local) e caricate all'avvio
modificando la riga del file /etc/rc.conf dove era
stata definita la modalità con:firewall_type="/etc/rc.firewall.local"Bisogna specificare il path completo
del file, altrimenti non verrà caricato con il rischio di
rimanere tagliati fuori dalla rete.Per il nostro esempio immaginiamo di avere l'interfaccia
fxp0 collegata all'esterno (Internet) e la
xl0 verso l'interno (LAN).
La macchina bridge ha assegnato l'IP
1.2.3.4
(è impossibile che il vostro ISP vi assegni un
indirizzo di classe A di questo tipo, ma per l'esempio va bene).# Le connessioni di cui abbiamo mantenuto lo stato vengono fatte passare subito
add check-state
# Esclude le reti locali definite nell'RFC 1918
add drop all from 10.0.0.0/8 to any in via fxp0
add drop all from 172.16.0.0/12 to any in via fxp0
add drop all from 192.168.0.0/16 to any in via fxp0
# Permette alla macchina bridge di connettersi con chi vuole
# (se la macchina è IP-less non includere questi comandi)
add pass tcp from 1.2.3.4 to any setup keep-state
add pass udp from 1.2.3.4 to any keep-state
add pass ip from 1.2.3.4 to any
# Permette agli host della rete interna di connettersi con chi vogliono
add pass tcp from any to any in via xl0 setup keep-state
add pass udp from any to any in via xl0 keep-state
add pass ip from any to any in via xl0
# Sezione TCP
# Permette SSH
add pass tcp from any to any 22 in via fxp0 setup keep-state
# Permette SMTP solo verso il mail server
add pass tcp from any to relay 25 in via fxp0 setup keep-state
# Permette i trasferimenti di zona solo dal name server secondario [dns2.nic.it]
add pass tcp from 193.205.245.8 to ns 53 in via fxp0 setup keep-state
# Lascia passare i controlli ident:
# è meglio che aspettare che vadano in timeout
add pass tcp from any to any 113 in via fxp0 setup keep-state
# Permette connessioni nel range di "quarantena".
add pass tcp from any to any 49152-65535 in via fxp0 setup keep-state
# Sezione UDP
# Permette DNS solo verso il name server
add pass udp from any to ns 53 in via fxp0 keep-state
# Permette connessioni nel range di "quarantena".
add pass udp from any to any 49152-65535 in via fxp0 keep-state
# Sezione ICMP
# Abilita le funzioni di 'ping'
add pass icmp from any to any icmptypes 8 keep-state
# Permette il passaggio dei messaggi di errori del comando 'traceroute'
add pass icmp from any to any icmptypes 3
add pass icmp from any to any icmptypes 11
# Tutto il resto è sospetto
add drop log all from any to anyColoro che hanno configurato un firewall in precedenza potrebbero aver
notato che manca qualcosa. In particolare, non ci sono regole contro lo
spoofing, difatti non abbiamo aggiunto:add deny all from 1.2.3.4/8 to any in via fxp0Ovvero, non far entrare dall'esterno pacchetti che affermano di venire
dalla rete interna. Questa è una cosa che solitamente viene fatta
per essere sicuri che qualcuno non provi a eludere il packet filter,
generando falsi pacchetti che sembrano venire dall'interno. Il problema
è che c'è almeno un host
sull'interfaccia esterna che non si può ignorare: il router.
Solitamente, però, gli ISP eseguono il controllo
anti-spoof sui loro router e quindi non ce ne dobbiamo preoccupare.L'ultima riga sembra un duplicato della regola di default, ovvero non
far passare nulla che non sia stato specificatamente permesso. In
verità c'è una differenza: tutto il traffico sospetto
verrà loggato.Ci sono due regole per permettere il traffico SMTP
e DNS verso il mail server e il name server, se ne
avete. Ovviamente l'intero set di regole deve essere personalizzato
per le proprie esigenze, questo non è altro che uno specifico
esempio (il formato delle regole è spiegato dettagliatamente nella
man page &man.ipfw.8;). Bisogna notare che, affinché
relay e ns
siano interpretati correttamente, la risoluzione dei nomi deve funzionare
prima che il bridge sia attivato. Questo è un
chiaro esempio che dimostra l'importanza di settare l'IP sulla corretta
scheda di rete. In alternativa è possibile specificare
direttamente l'indirizzo IP anziché il nome host (cosa necessaria
se la macchina è IP-less).Le persone che sono solite configurare un firewall probabilmente
avranno sempre usato una regola o
per i pacchetti
ident (porta 113 TCP). Sfortunatamente, questa non
è una scelta applicabile con il bridge, quindi la cosa migliore
è lasciarli passare fino alla destinazione. Finché la
macchina di destinazione non ha un demone ident attivo, questa tecnica
è relativamente sicura. L'alternativa è proibire le
connessioni sulla porta 113, creando qualche problema con servizi tipo
IRC (le richieste ident devono andare in
timeout).L'unica altra cosa un po' particolare che potete aver notato è
che c'è una regola per lasciar comunicare la macchina bridge e
un'altra per gli host della rete interna. Ricordate che questo è
dovuto al fatto che i due tipi di traffico prendono percorsi differenti
attraverso il kernel e di conseguenza anche dentro il packet filter. La
rete interna passerà attraverso il bridge, mentre la macchina
locale userà il normale stack IP per le connessioni. Perciò
due regole per gestire due casi differenti. Le regole in via
fxp0 funzionano in entrambi i casi.
In generale, se usate regole attraverso il
packet filter, dovrete fare un'eccezione per i pacchetti generati
localmente, in quanto non entrano tramite nessuna interfaccia.ContributiAlcune parti di questo articolo sono state prese, tradotte e
adattate da testi sui bridge, appartenenti alla documentazione di FreeBSD
in lingua inglese, a cura di Nick Sayer e Steve Peterson.Un grosso ringraziamento va a Luigi Rizzo per l'implementazione
delle funzionalità di bridging in FreeBSD e per il tempo che mi ha
dedicato rispondendo ad alcune mie domande a riguardo.
diff --git a/it_IT.ISO8859-15/articles/multi-os/article.sgml b/it_IT.ISO8859-15/articles/multi-os/article.sgml
index 290b5c5eac..73cd9896bc 100644
--- a/it_IT.ISO8859-15/articles/multi-os/article.sgml
+++ b/it_IT.ISO8859-15/articles/multi-os/article.sgml
@@ -1,794 +1,794 @@
%authors;
%it-trademarks;
-
+
%trademarks;
%translators;
]>
Installazione e Utilizzo di FreeBSD con altri Sistemi
OperativiJayRichmondjayrich@sysc.com6 Agosto 1996
-
- &tm-attrib.freebsd;
- &tm-attrib.ibm;
- &tm-attrib.linux;
- &tm-attrib.microsoft;
- &tm-attrib.powerquest;
- &tm-attrib.general;
-
+
+ &tm-attrib.freebsd;
+ &tm-attrib.ibm;
+ &tm-attrib.linux;
+ &tm-attrib.microsoft;
+ &tm-attrib.powerquest;
+ &tm-attrib.general;
+ Questo documento spiega come far coesistere felicemente
FreeBSD con altri sistemi operativi come Linux, &ms-dos;,
&os2;, e &windows; 95.
Un ringraziamento speciale va a: Annelise Anderson
andrsn@stanford.edu, Randall Hopper
rhh@ct.picker.com, e &a.jkh;.
- Traduzione a cura di &a.it.max;.
+ &trans.it.max;
IntroduzioneMolta gente non può far convivere questi sistemi operativi
senza avere a disposizione un hard disk di grosse dimensioni,
perciò sono state incluse informazioni speciali sui drive EIDE
di grosse dimensioni. Poiché ci sono così tante
combinazioni di possibili sistemi operativi e configurazioni di hard disk,
la potrebbe esserti di aiuto più
di altre. Contiene descrizioni di specifiche configurazioni che
usano molteplici sistemi operativi.Questo documento assume che tu abbia già fatto posto sul tuo
hard disk per un altro sistema operativo. Ogni volta che
ripartizioni il tuo hard disk, corri il rischio di distruggere
e quindi perdere i dati sulle partizioni originali. In ogni caso,
se il tuo hard disk è completamente occupato dal DOS, potresti
usare FIPS (incluso nel CDROM di FreeBSD nella directory
\TOOLS oppure via
ftp).
Ti permette di ripartizionare il tuo hard disk senza distruggere i
dati già contenuti. C'è anche un programma commerciale
chiamato &partitionmagic;, che ti permette
di ridimensionare e cancellare partizioni senza conseguenze.Panoramica sui Boot ManagerSi tratta solo di brevi descrizioni dei diversi boot manager che
potresti trovare. A seconda del tuo computer, potresti trovare
utile usarne più di uno sullo stesso sistema.Boot EasyQuesto è il boot manager standard fornito con FreeBSD.
Ha la possibilità di far partire qualsiasi cosa, incluso BSD,
&os2; (HPFS), &windows; 95 (FAT e FAT32), e Linux.
Le partizioni vengono scelte con i tasti funzione (F1-F12).Boot Manager di &os2;Questo fa partire FAT, FAT32, HPFS, FFS (FreeBSD), ed EXT2
(Linux). Le partizioni vengono scelte usando i tasti freccia.
L'&os2; Boot Manager è
l'unico ad usare una propria partizione separata, diversamente
dagli altri, che usano il master boot record (MBR). Di conseguenza,
deve essere installato prima del 1024esimo cilindro per evitare
problemi di avvio. Può far partire Linux usando LILO quando
questo è parte del settore di avvio, non dell'MBR.
Leggi gli HOWTO
di Linux sul World Wide Web per avere più
informazioni su come far partire Linux con il boot manager di
&os2;.OS-BSQuesta è un'alternativa a Boot Easy. Ti dà
più controllo sul processo di avvio, con la
possibilità di impostare la partizione di default da cui
partire e il timeout di avvio.
La versione beta di questo programma ti permette di avviare
scegliendo il sistema operativo con i tasti freccia. È
incluso nel cd di FreeBSD nella directory
\TOOLS oppure via ftp.LILO, o LInux LOaderQuesto è un boot manager limitato. Farà partire
FreeBSD, sebbene siano necessari alcuni accorgimenti e sistemazioni
nel file di configurazione.A proposito di FAT32FAT32 è il rimpiazzo al file system FAT incluso nella Release
Beta SR2 di Microsoft, che dovrebbe essere installata
con &windows; 95 a partire dalla fine del 1996. Converte il
normale file system FAT e ti permette di usare cluster di
dimensioni più piccole per hard disk di dimensioni maggiori.
Inoltre FAT32 modifica il settore di avvio tradizionale e la tabella
di allocazione, rendendola incompatibile con alcuni Boot
Manager.Una Installazione TipicaDiciamo che ho due grandi hard disk EIDE e voglio installarci
FreeBSD, Linux, e &windows; 95.Ecco come potrei fare usando questi due hard disk:/dev/wd0 (Primo hard disk)/dev/wd1 (Secondo hard disk)Tutti e due hanno 1416 cilindri.Parto dalla partizione &ms-dos; o dal dischetto di avvio
di &windows; 95 che contiene l'utility FDISK.EXE
e creo una piccola partizione primaria da 50 MB
(35-40 per &windows; 95, più un po' di spazio per respirare)
sul primo disco. Creo anche una partizione più grande sul
secondo hard disk per le applicazioni di &windows; e per i
dati.Faccio ripartire ed installo &windows; 95 (più facile a
dirsi che a farsi) sulla partizione C:.La prossima cosa che farò sarà installare Linux.
Non sono sicuro per le altre distribuzioni, ma la Slackware include
LILO (guarda la ). Quando ripartiziono il
mio hard disk con l'fdisk di Linux,
metterò tutto ciò che riguarda Linux sul primo hard
disk (probabilmente 300 MB per una partizione di
root decente e un po' di spazio di swap).Dopo aver installato Linux, quando viene chiesto di
installare LILO, assicurati di installarlo sul
settore di avvio della partizione di Linux, non
nell'MBR (Master Boot Record).La parte rimanente di hard disk va a FreeBSD.
Assicurati anche che la slice root di FreeBSD
non vada oltre il 1024esimo cilindro. (Il 1024esimo
cilindro è circa intorno ai 528 MB in un disco ipotetico,
il mio, di 720 MB). Userò il resto dell'hard disk
(circa 270 MB) per /usr e
/. Il resto del secondo hard
disk (la grandezza varia a seconda di quanto spazio
ho lasciato agli applicativi e ai dati per &windows;
quando ho creato la partizione nel primo passo) può
essere usata per /usr/src
e per lo spazio di swap.Se visualizzato con l'utility fdisk
di &windows; 95, l'hard disk dovrebbe risultare in questo modo:
---------------------------------------------------------------------
Display Partition Information
Current fixed disk drive: 1
Partition Status Type Volume_Label Mbytes System Usage
C: 1 A PRI DOS 50 FAT** 7%
2 A Non-DOS (Linux) 300 43%
Total disk space is 696 Mbytes (1 Mbyte = 1048576 bytes)
Press Esc to continue
---------------------------------------------------------------------
Display Partition Information
Current fixed disk drive: 2
Partition Status Type Volume_Label Mbytes System Usage
D: 1 A PRI DOS 420 FAT** 60%
Total disk space is 696 Mbytes (1 Mbyte = 1048576 bytes)
Press Esc to continue
---------------------------------------------------------------------
** Potrebbe essere FAT16 o FAT32 se stai usando l'aggiornamento OEM
SR2. Guarda la .Installazione di FreeBSD. Assicurati di avviare il computer
con il primo hard disk configurato con NORMAL nel BIOS.
Se non è così, dovrai settare la vera geometria
del disco all'avvio (per arrivare a fare ciò, fai partire
&windows; 95 e consulta Microsoft Diagnostics
(MSD.EXE), o controlla il BIOS) con il
parametro hd0=1416,16,63 dove
1416 è il numero di cilindri sull'hard disk,
16 è il numero di testine per
traccia, o heads per track, e
63 è il numero di settori per
traccia sul drive.Quando partiziono l'hard disk, cerco sempre di mettere Boot
Easy sul primo hard disk. Non mi preoccupo del secondo hard
disk, non parte nulla da quello.Al riavvio, Boot Easy dovrebbe riconoscere le tre partizioni
avviabili, cioè quella DOS (ovvero &windows; 95), Linux, e
BSD (FreeBSD).Considerazioni SpecialiMolti sistemi operativi sono molto pignoli su come e dove devono
essere messi sull'hard disk. &windows; 95 deve essere sulla prima
partizione primaria sul primo hard disk. &os2; fa eccezione. Può
essere installato in una partizione primaria o estesa sul primo o sul
secondo hard disk. Se non sei sicuro, mantieni la parte avviabile di
partizione sotto il 1024esimo cilindro.Se installi &windows; 95 su un sistema BSD esistente, questo
distruggerà l'MBR, e dovrai reinstallare il boot
manager precedente. Boot Easy può essere reinstallato usando
l'utility BOOTINST.EXE inclusa nella directory
\TOOLS sul cdrom, oppure
via ftp.
Puoi anche ricominciare l'installazione e andare all'editor delle
partizioni. Da lì, marcare la partizione di FreeBSD come
avviabile, scegliere Boot Manager, e quindi digitare W per scrivere le
informazioni nell'MBR. Puoi ora riavviare, e Boot Easy dovrebbe
riconoscere &windows; 95 e DOS.Ricordati che &os2; può leggere partizioni FAT e HPFS, ma non
FFS (FreeBSD) o EXT2 (Linux). Diversamente &windows; 95 può
leggere e scrivere solo su FAT o FAT32 (guarda la ).
FreeBSD può leggere gran parte degli altri file system, ma al
momento non può leggere partizioni HPFS. Linux può leggere
partizioni HPFS, ma non può scrivervi. Versioni recenti del kernel
di Linux (2.x) possono leggere e scrivere su partizioni di &windows; 95 di
tipo VFAT (VFAT è ciò che permette a &windows; 95 di avere
i nomi di file lunghi - è molto simile alla FAT).
Linux può leggere e scrivere sulla maggior parte dei file system.
Capito? Lo spero...Esempi(La sezione ha bisogno di lavoro, per favore spedisci
il tuo esempio a jayrich@sysc.com).FreeBSD + &windows; 95: Se hai installato FreeBSD dopo &windows; 95,
dovresti vedere DOS nel menu di Boot Easy. Questo
è &windows; 95. Se hai installato &windows; 95 dopo FreeBSD, leggi
la sopra.
Fin quando il tuo hard disk non ha più di 1024 cilindri, non
dovrebbero esserci problemi.
Se una partizione va oltre il 1024esimo cilindro, e hai
messaggi di errore come invalid system disk sotto
DOS (&windows; 95) e FreeBSD non parte, prova a cercare una opzione nel
BIOS chiamata > 1024 cylinder support o
NORMAL/LBA mode.
DOS potrebbe necessitare dell'LBA (Logical Block Addressing -
Indirizzamento Logico dei Blocchi) per partire correttamente. Se l'idea
di cambiare delle impostazioni nel BIOS ogni volta che si accende il
computer non ti piace, puoi far partire FreeBSD da DOS con l'utility
FBSDBOOT.EXE che trovi sul CD (dovrebbe trovare la
tua partizione FreeBSD e farla partire).FreeBSD + &os2; + &windows; 95: Nulla di nuovo qui. Il boot manager
di &os2; può far partire tutti questi sistemi operativi,
cosicché non dovrebbero esserci problemi.FreeBSD + Linux: Puoi usare Boot Easy per far partire tutti e due i
sistemi operativi.FreeBSD + Linux + &windows; 95: (guarda la )Altre Fonti di AiutoCi sono molti HOW-TO su
Linux che trattano come affrontare il problema di avere
più sistemi operativi sullo stesso hard disk.Il Linux+DOS+Win95+OS2
mini-HOWTO offre aiuto su come configurare il boot manager di
&os2; e il Linux+FreeBSD
mini-HOWTO potrebbe essere anch'esso interessante.
Anche il Linux-HOWTO
è di grande aiuto.L'&windowsnt;
Loader Hacking Guide fornisce buone informazioni sul
multibooting di &windowsnt;, '95, e DOS con altri sistemi
operativi.E il pacchetto di Hale Landis, How It Works contiene
alcune utili informazioni su tutti i tipi di geometrie dei drive e su
argomenti legati al processo di avvio. Puoi trovarlo su .Inoltre non perderti la documentazione del kernel di FreeBSD sul
processo di avvio, disponibile nella distribuzione dei sorgenti del kernel
(si scompatta in file:/usr/src/sys/i386/boot/biosboot/README.386BSD.Dettagli Tecnici(Contributo di Randall Hopper,
rhh@ct.picker.com)Questa sezione prova a fornire abbastanza informazioni di base
sugli hard disk e sul processo di avvio così da
essere poi capaci di determinare le cause dei problemi più
frequenti che potreste affrontare al momento dell'installazione e della
configurazione di più sistemi operativi. Inizia con un
linguaggio semplice, così potresti voler scorrere la pagina fino a
quando non ti sembri difficile e cominciare quindi da quel punto a
leggere.Introduzione agli Hard DiskSono generalmente usati tre termini fondamentali per descrivere
l'allocazione dei dati sull'hard disk: Cylinders (Cilindri), Heads
(Testine), e Sectors (Settori). Non è particolarmente importante
sapere esattamente cosa significano questi termini e quale sia il loro
compito specifico, ma interessa sapere che, insieme, identificano dove
si trovano fisicamente i dati sull'hard disk.Ogni hard disk ha un particolare numero di cilindri, di testine, e
di settori per ogni parte di cilindro relativa a una singola testina
(che generalmente viene chiamato track, o traccia).
Questi dati contribuiscono a determinare la geometria
fisica del disco dell'hard disk. Ci sono
generalmente 512 byte per settore, e 63 settori per traccia, mentre
il numero di cilindri e testine varia a seconda del tipo di hard disk.
In questo modo puoi trovare la quantità di dati che il disco
potrebbe contenere semplicemente calcolando:(numero di cilindri) × (numero di testine) × (63
settori/traccia) × (512 byte/settore)Per esempio, sul mio Western Digital AC31600 EIDE, questo
è:(3148 cilindri) × (16 testine) × (63
settori/traccia) × (512 byte/settore)che sarebbe 1,624,670,208 byte, o circa 1.6 Giga.Puoi scoprire la geometria fisica del disco (cioè il numero
di cilindri, testine, e il fattore settori/tracciati) del tuo hard disk
usando ATAID o altri programmi reperibili su Internet. Probabilmente il
tuo hard disk ti è stato venduto con queste informazioni.
Comunque stai attento: se stai usando l'opzione LBA del BIOS (vedi la
), non puoi usare un qualsiasi programma per
conoscere la geometria fisica. Questo perché molti programmi (ad
esempio MSD.EXE o l'fdisk di FreeBSD) non
identificano la geometria fisica del disco, fanno invece riferimento
alla geometria traslata (Numeri virtuali usando
LBA). Continua a leggere per saperne di più.Un altro aspetto interessante di questi termini. Dati 3
numeri—un numero di cilindri, un numero di testine, e un numero
di settori per tracciato—si può identificare uno specifico
settore assoluto (un blocco di 512 byte di dati) sull'hard disk. I
cilindri e le testine sono numerati partendo da 0, e i settori sono
numerati partendo da 1.Per quelli che sono interessati a dettagli più tecnici,
informazioni sulla geometria dei dischi, settori di avvio, BIOS, e
altro, possono trovare grandi quantità di informazioni in
Internet. Basta fare una ricerca con Lycos, Yahoo e altri digitando
boot sector o master boot record.
Tra le numerose informazioni utili che si possono trovare c'è il
pacchetto di documentazione How It Works (in
italiano Come Funziona) di Hale Landis. Guarda la
per alcuni puntatori a questo
pacchetto.Ok, troppa terminologia finora. Adesso parliamo del processo di
avvio.Il Processo di AvvioSul primo settore del tuo disco (Cyl 0, Head 0, Sector 1) risiede
il Master Boot Record (MBR). Questo contiene una mappa del tuo disco.
Identifica fino a 4 partizioni, ciascuna delle
quali è uno spazio, una parte, di quel disco. FreeBSD chiama
queste partizioni slices per evitare confusione
con le sue partizioni, di cui ora non parleremo.
Ciascuna partizione può contenere un sistema operativo
diverso.Ogni elemento che rappresenta una partizione presente nell'MBR ha un
Partition ID, un valore Start
Cylinder/Head/Sector, e un valore End
Cylinder/Head/Sector. Il Partition ID mostra di che tipo
di partizione si tratta (di che sistema operativo) e i valori di
inizio/fine dicono dove questa si trova. La
mostra una lista di partition ID più comuni.
Partition IDID (hex)Descrizione01DOS12 primaria (12-bit FAT)04DOS16 primaria (16-bit FAT)05DOS estesa06DOS primaria di grande dimensione (> 32MB)0A&os2;83Linux (EXT2FS)A5FreeBSD, NetBSD, 386BSD (UFS)
Nota che non tutte le partizioni sono avviabili (per esempio quelle
DOS estese). Alcune lo sono, altre no. Ciò che rende una
partizione avviabile è la configurazione del Partition
Boot Sector che si trova all'inizio di ciascuna
partizione.Quando configuri il tuo boot manager preferito, questo cerca gli
elementi nella tavola delle partizioni sull'MBR di tutti i tuoi hard
disk e fa in modo che tu possa dare un nome a tutte gli elementi della
lista. Quindi all'avvio, il boot manager viene invocato da un codice
particolare presente nell'MBR del primo hard disk che viene rilevato sul
tuo sistema. Questo guarda la tavola delle partizioni dell'MBR
corrispondente alla partizione che hai scelto, usa l'informazione sullo
Start Cylinder/Head/Sector per quella partizione, carica il Partition
Boot Sector per quella partizione, e sli dà il controllo.
Quel settore di avvio per la partizione contiene abbastanza informazioni
per cominciare a caricare il sistema operativo di quella
partizione.Un particolare che abbiamo sorvolato e che è importante
conoscere. Tutti gli hard disk hanno l'MBR. Ad ogni modo, quello
importante è quello del disco che viene rilevato per primo dal
BIOS. Se hai solo hard disk IDE, è il primo disco IDE
(cioè il disco primario del controller primario).
Stessa cosa per i sistemi SCSI. Se hai sia
SCSI che IDE invece, i dischi IDE vengono riconosciuti per primi dal
BIOS, quindi il primo disco IDE è quello che viene riconosciuto
per primo. Il boot manager che installerai si troverà quindi
sull'MBR del primo disco riconosciuto come descritto.Limitazioni sull'Avvio e AvvertimentiOra un po' di cose interessanti alle quali devi stare
attento.Il maledetto limite dei 1024 cilindri e l'aiuto dell'LBA del
BIOSLa prima parte del processo di avvio viene effettuata attraverso
il BIOS, (se questo è un termine nuovo per te, il BIOS è
un chip contenente del software presente sulla scheda madre che
contiene il codice di avviamento per il computer). Quindi, questa
prima parte del processo è soggetta alle limitazioni
dell'interfaccia del BIOS.L'interfaccia BIOS usata per leggere gli hard disk in questo
momento (INT 13H, Subfunction 2) alloca 10 bit per il Cylinder Number,
8 bit per l'Head Number, e 6 bit per il Sector Number. Questo porta
gli utenti ad essere sottoposti a dei limiti (per esempio i boot
manager installati nell'MBR così come i loader installati nei
Boot Sector) che ora vediamo:1024 cilindri, massimo256 testine, massimo64 settori/traccia, massimo (in realtà 63,
0 non è disponibile)Ora, hard disk grossi hanno molti cilindri, ma non molte testine,
quindi invariabilmente con grandi hard disk il numero di cilindri
sarà più alto di 1024. A causa di questo e della
situazione dell'interfaccia BIOS, non puoi far partire un sistema
operativo da qualsiasi punto del disco. Il codice di avvio (il boot
manager e il loader del sistema operativo devono essere nei settori di
avvio di tutte le partizioni avviabili) deve risiedere entro il limite
dei 1024 cilindri. In pratica, se il tuo hard disk è generico
e contiene 16 testine, questo si tramuta in:1024 cilindri/disco × 16 testine/disco × 63
settori/traccia × 512 byte/settoreche è intorno al summenzionato limite dei 528MB.Qui è dove entra in gioco l'LBA (Logical Block Addressing,
Indirizzamento Logico dei Blocchi) del BIOS. L'LBA del BIOS fornisce
all'utente delle API del BIOS accesso ai cilindri fisici oltre al
1024esimo attraverso l'interfaccia BIOS ridefinendo un cilindro.
Quindi, rimappa cilindri e testine, facendo sembrare al BIOS che il
computer contenga meno cilindri e più testine di quanto in
realtà non ne abbia.
In altre parole, si avvantaggia del fatto che gli hard disk hanno
relativamente poche testine e molti cilindri semplicemente bilanciando
tra cilindri e testine facendo in modo che tutti e due i numeri
rimangano sotto la soglia (1024 cilindri, 256 testine).Con l'LBA del BIOS, la limitazione agli hard disk è
virtualmente eliminata (beh, spostata ad 8 Gigabyte). Se hai un BIOS
che supporta l'LBA, puoi mettere FreeBSD o qualsiasi altro OS in
qualsiasi parte tu voglia senza toccare il limite dei 1024
cilindri.Per usare ancora l'esempio del mio Western Digital da 1.6
Giga, la sua geometria fisica è:(3148 cilindri, 16 testine, 63 settori/traccia, 512
byte/settore)Ad ogni modo, il mio LBA del BIOS rimappa questo in:(787 cilindri, 64 testine, 63 settori/traccia, 512
byte/settore)dandomi la stessa grandezza effettiva di disco, ma con numero di
cilindri e testine entro i limiti dell'API del BIOS (casualmente,
ho sia Linux che FreeBSD installati su uno dei miei hard disk sopra il
1024esimo cilindro fisico, e tutti e due partono perfettamente, grazie
all'LBA del BIOS).Boot Manager e Allocazione del DiscoUn altro punto di cui tener conto al momento al momento
dell'installazione di un boot manager, è quello di ricordarsi
di allocare spazio per il tuo boot manager. È meglio aver
presente fin da subito questo problema, per non accorgersene troppo
tardi e dover quindi reinstallare uno o più sistemi
operativi.Se hai seguito il discorso nella a
proposito del Master Boot Sector (dove si trova l'MBR), dei Partition
Boot Sectors, e dell processo di avvio, potresti esserti chiesto
esattamente dove quel piccolo boot manager risiede sul tuo hard disk.
Bene, alcuni boot manager sono abbastanza piccoli da risiedere nel
Master Boot Sector (Cilindro 0, Testina 0, Settore 0) insieme alla
tabella delle partizioni. Alcuni invece hanno bisogno di un po' di
spazio in più e si estendono su alcuni settori oltre il Master
Boot Sector nella traccia del Cilindro 0 Testina 0, dato che questa
è tipicamente libera.Ecco qui. Alcuni sistemi operativi (incluso FreeBSD) fanno in
modo che le loro partizioni possano cominciare subito dopo il Master
Boot Sector, cioè al cilindro 0, testina 0, settore 2 se vuoi.
Infatti, se dai al sysinstall di FreeBSD un disco con una parte
iniziale vuota oppure un disco vuoto, quello è il punto da cui
comincerà la partizione FreeBSD di default (o almeno lo ha
fatto quando sono caduto in questa trappola). Poi quando vai ad
installare il tuo boot manager, se è uno che occupa alcuni
settori oltre all'MBR, andrà a sovrascrivere la parte iniziale
dei dati della prima partizione. Nel caso di FreeBSD, questo
sovrascrive il label del disco, e fa in modo da rendere non avviabile
la partizione di FreeBSD.Il modo più semplice per eliminare questo problema (e
lasciarti la flessibilità di provare in seguito differenti boot
manager) è quello di lasciare sempre la prima traccia del tuo
hard disk completamente libera quando partizioni il tuo hard disk.
Ciò significa lasciare libero lo spazio tra il cilindro 0,
testina 0, settore 2 fino a cilindro 0, testina 0, settore 63, e
cominciare la prima partizione sul cilindro 0, testina 1, settore 1.
Per ciò che vale, quando crei una partizione DOS all'inizio del
tuo hard disk, il DOS lascia sempre questo spazio libero di default
(ecco perché molti boot manager presumono che sia libero).
Quindi creare una partizione DOS all'inizio del disco toglie questi
problemi tutti insieme. Mi piace fare da solo, creando una partizione
DOS da 1 mega all'inizio, perché questo evita che cambino le
lettere dei drive DOS quando ripartiziono in seguito.Come riferimento, i seguenti boot manager usano il Master Boot
Sector per immagazzinare il loro codice e i loro dati:OS-BS 1.35Boot EasyLILOQuesti boot manager usano alcuni settori addizionali dopo
il Master Boot Sector:OS-BS 2.0 Beta 8 (settori 2-5)Boot Manager di &os2;Cosa fare se il tuo computer non parte?In alcuni momenti quando installi dei boot manager, potresti
lasciare l'MBR in uno stato in cui il computer non riesce più a
partire. Questo è spiacevole, ma possibile quando si utilizza
FDISK su di un boot manager già installato.Se hai una partizione DOS avviabile sul tuo hard disk, puoi
partire da un floppy DOS, e poi eseguire il comando:A:\> FDISK /MBRPer mettere il codice originale di avvio del DOS nel sistema.
Puoi ora avviare DOS (e solamente DOS) dall'hard disk.
Alternativamente, puoi far ripartire il programma di installazione del
tuo boot manager da un floppy avviabile.
diff --git a/it_IT.ISO8859-15/articles/new-users/article.sgml b/it_IT.ISO8859-15/articles/new-users/article.sgml
index 0329f8496c..ff079dccb7 100644
--- a/it_IT.ISO8859-15/articles/new-users/article.sgml
+++ b/it_IT.ISO8859-15/articles/new-users/article.sgml
@@ -1,1085 +1,1092 @@
%man;
-
-%freebsd;
+
+%freebsd;
%it-trademarks;
-
+
%trademarks;
%mailing-lists;
%translators;
]>
Per chi è alle Prime Armi sia con FreeBSD che con
&unix;AnneliseAndersonandrsn@andrsn.stanford.edu15 Agosto 1997
-
- &tm-attrib.freebsd;
- &tm-attrib.ibm;
- &tm-attrib.microsoft;
- &tm-attrib.netscape;
- &tm-attrib.opengroup;
- &tm-attrib.general;
-
+
+ &tm-attrib.freebsd;
+ &tm-attrib.ibm;
+ &tm-attrib.microsoft;
+ &tm-attrib.netscape;
+ &tm-attrib.opengroup;
+ &tm-attrib.general;
+ Congratulazioni per aver installato FreeBSD! Questa introduzione
é per chi é alle prime armi con FreeBSD
e &unix;—perciò comincia dalle basi.
Stai certamente usando la versione 2.0.5 o una più recente di
- FreeBSD distribuita da BSDi o FreeBSD.org, il tuo sistema ha (per il
- momento) un solo utente (te stesso)—e sei probabilmente abbastanza
- bravo con DOS/&windows; o &os2;.
+ &os; distribuita da &os;.org, il tuo sistema ha (per il momento) un
+ solo utente (te stesso)—e sei probabilmente abbastanza bravo
+ con DOS/&windows; o &os2;.
- Traduzione a cura di &a.it.max;.
+ &trans.it.max;
Entrare ed Uscire dal SistemaEntra (quando vedi login:) come l'utente che
hai creato durante l'installazione oppure come
- root. (La tua installazione di FreeBSD dovrebbe
- già avere un account di root;
- root può andare ovunque e fare qualsiasi cosa, anche cancellare
- file essenziali, perciò stai attento!) I simboli &prompt.user; e
- &prompt.root; che incontrerai più avanti simboleggiano il prompt
- (i tuoi potrebbero essere differenti), dove &prompt.user; indica un utente
- ordinario e &prompt.root; indica root.
+ root. (La tua installazione di FreeBSD dovrebbe
+ già avere un account di root; che può
+ andare ovunque e fare qualsiasi cosa, anche cancellare file essenziali,
+ perciò stai attento!) I simboli &prompt.user; e &prompt.root;
+ che incontrerai più avanti simboleggiano il prompt (i tuoi
+ potrebbero essere differenti), dove &prompt.user; indica un utente
+ ordinario e &prompt.root; indica root.
Per uscire (e ritrovarsi con un nuovo prompt login:)
scrivi&prompt.root; exittante volte quanto serve. Sì, premi
invio dopo ogni comando, e ricordati che &unix; fa
distinzione tra maiuscole e minuscole—perciò
exit, non EXIT.Per spegnere il computer digita&prompt.root; /sbin/shutdown -h nowO per riavviarlo digita&prompt.root; /sbin/shutdown -r nowoppure&prompt.root; /sbin/rebootPuoi anche riavviarlo premendo
CtrlAltCanc.
Lasciagli un po' di tempo per compiere il suo lavoro. Questo equivale a
/sbin/reboot nelle versioni più recenti di
FreeBSD ed è molto meglio che premere il bottone di reset.
Non vorrai mica reinstallare tutto da capo, vero?Aggiungere un Utente con Privilegi di RootSe non hai creato un utente durante l'installazione e quindi
- sei entrato nel sistema come root, dovresti probabilmente crearne
- uno ora tramite
+ sei entrato nel sistema come root, dovresti
+ probabilmente crearne uno ora tramite
&prompt.root; adduserLa prima volta che aggiungi un utente, il sistema dovrebbe chiederti
di inserire delle impostazioni di default da applicare. Potresti volere
come shell &man.csh.1; invece di &man.sh.1;, se ti viene consigliato
sh come default. Altrimenti premi solo invio
per accettare i valori proposti. Questi dati vengono salvati in
/etc/adduser.conf, un file modificabile
successivamente a mano.Supponiamo che tu voglia creare l'utente jack di
- nome reale Jack Benimble. Assegna a jack una
- password per ragioni di sicurezza (anche i bambini che gironzolano per
- casa potrebbero mettere le mani sulla tastiera). Quando ti viene chiesto
- se vuoi invitare jack in un altro gruppo, digita
+ nome reale Jack Benimble. Assegna a
+ jack una password per ragioni di sicurezza (anche i
+ bambini che gironzolano per casa potrebbero mettere le mani sulla
+ tastiera). Quando ti viene chiesto se vuoi invitare
+ jack in un altro gruppo, digita
wheelLogin group is ``jack''. Invite jack into other groups: wheelQuesto ti permetterà di entrare come l'utente
jack e usare il comando &man.su.1;
- per diventare root. A quel punto non sarai più preso in giro per
- essere entrato direttamente come root.
+ per diventare root. A quel punto non sarai
+ più preso in giro per essere entrato direttamente come
+ root.
Puoi uscire da adduser in qualsiasi momento
premendo CtrlC,
e alla fine avrai l'opportunità di approvare il nuovo utente oppure
premere n per non farlo. Potresti voler creare un
- secondo utente (jill?) cosicché quando andrai a modificare i file
- di jack avrai un'ancora di salvezza in caso qualcosa vada male.
+ secondo utente cosicché quando andrai a modificare i file
+ di jack avrai un'ancora di salvezza in caso qualcosa
+ vada male.
Una volta fatto questo, usa exit per tornare al
prompt di login ed entrare come jack.
In generale è meglio cercare di lavorare da utente normale
- in modo da non avere il potere—e il rischio—di root.
+ in modo da non avere il potere—e il rischio—di
+ root.
Se hai già creato un utente e vuoi che quell'utente sia in
- grado di usare su per diventare root, puoi entrare come
- root e modificare il file /etc/group, aggiungendo
- jack alla prima linea (il gruppo wheel). Ma
- prima devi fare pratica con &man.vi.1;, l'editor di testo—oppure
- usa il più semplice &man.ee.1;, installato sulle recenti
- versioni di FreeBSD.
+ grado di usare su per diventare
+ root, puoi entrare come root e
+ modificare il file /etc/group, aggiungendo
+ jack alla prima linea (il gruppo
+ wheel). Ma prima devi fare pratica con
+ &man.vi.1;, l'editor di testo—oppure usa il più semplice
+ &man.ee.1;, installato sulle recenti versioni di FreeBSD.
Per cancellare un utente, usa il comando
rmuser.Diamoci un'occhiata in giroUna volta avuto accesso come utente normale, guardati in giro e prova
alcuni dei comandi che ti daranno accesso alle fonti di aiuto e di
informazioni su FreeBSD.Ecco qui una lista di comandi e le loro funzioni:idTi dice chi sei!pwdTi mostra dove sei—la directory in cui stai
lavorando.lsTi mostra una lista dei file contenuti nella directory.ls Ti mostra un elenco dei file contenuti nella directory ponendo
* dopo i file eseguibili,
/ dopo le directory, e
@ dopo i collegamenti simbolici.ls Mostra un elenco di file nel formato lungo—grandezza,
data, permessi.ls Mostra una lista dei file nascosti, cioè con un
punto davanti al nome, insieme agli altri.
- Se sei root, i file puntati vengono mostrati anche
- senza l'opzione .
+ Se sei root, i file puntati
+ vengono mostrati anche senza l'opzione .
cdCambia la directory di lavoro. cd
.. torna alla directory
superiore; nota lo spazio dopo cd. cd
/usr/local va nella directory
specificata. cd ~ va
nella directory home dell'utente collegato in quel
momento—per esempio, /usr/home/jack.
Prova cd /cdrom, e poi
ls, per scoprire se il tuo CDROM è
montato e funziona.view
nomefileMostra il contenuto del file (chiamato
nomefile) senza modificarlo.
Prova view
/etc/fstab.
- :q per uscire.
+ Digita :q per uscire.
cat nomefileMostra nomefile sullo schermo.
Se è troppo lungo e ne puoi vedere solo la fine,
premi BlocScorr e usa
freccia-su per muoverti in alto; puoi usare
BlocScorr anche con le pagine man. Premi ancora
BlocScorr per uscire dallo scorrimento. Potresti
provare cat con alcuni dei file
nascosti presenti nella tua directory home—cat
.cshrc, cat
.login, cat
.profile.Noterai degli alias in .cshrc per
alcuni dei comandi ls (sono molto
convenienti). Puoi creare degli altri alias modificando
.cshrc. Puoi far sì che questi alias
diventino disponibili a tutti gli utenti mettendoli nel file
di configurazione generale di csh,
/etc/csh.cshrc.Ottenere Aiuto e InformazioniEcco alcune risorse utili per ottenere aiuto.
Testo è qualcosa che puoi
digitare a tuo piacere—normalmente si tratta di un comando
o del nome di un file.apropos
testoTutto ciò che contiene la stringa
testo nel database
whatis.man
testoMostra la pagina man di testo,
la maggior risorsa di documentazione per i sistemi Un*x.
man ls ti dirà
tutti i modi possibili per usare il comando ls.
Premi Invio per muoverti nel testo,
CtrlB
per andare indietro di una pagina,
CtrlF
per andare avanti, q oppure
CtrlC
per uscire.which
testoTi dice dove si trova il comando
testo nel path dell'utente.locate
testoTi dice tutte le directory nei path dell'utente in cui si trova
il comando testo.whatis
testoTi dice che cosa fa il comando
testo e la sua pagina man.
Digitando whatis * ti verranno presentate tutte
le pagine man associate agli eseguibili presenti nella directory
corrente.whereis
testoTrova il file testo, dandoti il suo
percorso completo.Potresti voler provare ad usare whatis con
alcuni comandi utili come cat,
more, grep,
mv, find,
tar, chmod,
chown, date, e
script. more ti permette
di leggere una pagina alla volta come in DOS, ad esempio, ls -l |
more oppure more
nomefile.
* ha valore assoluto—per esempio, ls
w* mostra tutti i file che cominciano con
w.Per caso alcuni di questi comandi non funzionano correttamente? Sia
&man.locate.1;, sia &man.whatis.1; dipendono da
un database che viene ricostruito settimanalmente. Se la tua macchina
non sarà lasciata accesa per il fine settimana (usando FreeBSD),
può darsi che tu voglia usare i comandi per la manutenzione
- giornaliera, settimanale, e mensile ogni tanto. Falli partire come root
- e lascia loro il tempo di finire il lavoro prima di farne partire un
- altro.
+ giornaliera, settimanale, e mensile ogni tanto. Falli partire come
+ root e lascia loro il tempo di finire il lavoro
+ prima di farne partire un altro.
&prompt.root; periodic dailyoutput tralasciato
&prompt.root; periodic weeklyoutput tralasciato
&prompt.root; periodic monthlyoutput tralasciatoSe ti stufi di aspettare, premi
AltF2 per
avere un'altra console virtuale, e poterti loggare
nuovamente. Dopotutto è un sistema multi-utente, e multi-tasking.
Probabilmente questi comandi produrranno dei messaggi sullo
schermo quando lavorano; puoi digitare
clear per pulire lo schermo.
Quando hanno finito, dovresti dare un'occhiata a
/var/mail/root e
/var/log/messages.Usare tali comandi fa parte dell'amministrazione di
sistema—e come utente singolo di un sistema &unix;,
sei tu l'amministratore del sistema. Praticamente l'unica cosa
- per la quale è necessario che tu sia root è
- l'amministrazione. Queste responsabilità
- non vengono trattate bene nemmeno in quei grossi libri
- su &unix;, che sembrano dedicare troppo spazio all'uso dei menu
- nei windows manager. Potresti voler leggere uno dei più
- interessanti libri sull'amministrazione di sistema, come
- UNIX System Administration Handbook di Evi Nemeth
- et.al. (Prentice-Hall, 1995, ISBN 0-13-15051-7)—la seconda edizione
- con la copertina rossa; oppure Essential System
- Administration di Æleen Frisch (O'Reilly &
- Associates, 1993, ISBN 0-937175-80-3). Io ho usato quello di
- Nemeth.
+ per la quale è necessario che tu sia root
+ è l'amministrazione. Queste responsabilità non vengono
+ trattate bene nemmeno in quei grossi libri su &unix;, che sembrano
+ dedicare troppo spazio all'uso dei menu nei windows manager. Potresti
+ voler leggere uno dei più interessanti libri sull'amministrazione
+ di sistema, come UNIX System Administration
+ Handbook di Evi Nemeth et.al. (Prentice-Hall, 1995,
+ ISBN 0-13-15051-7)—la seconda edizione con la copertina rossa;
+ oppure Essential System Administration di
+ Æleen Frisch (O'Reilly & Associates, 2002, ISBN 0-596-00343-9).
+ Io ho usato quello di Nemeth.
Modificare File di TestoPer poter configurare il tuo sistema, devi modificare dei file. Molti
di questi saranno in /etc; e avrai bisogno
- del comando su per diventare root e poter così
- modificarli. Puoi usare il semplice editor ee, ma
- alla lunga risulta più utile imparare vi.
- C'é un eccellente tutorial su vi in
- /usr/src/contrib/nvi/docs/tutorial se lo hai
- installato; altrimenti puoi scaricarlo via FTP da
- ftp.cdrom.com dalla directory
- FreeBSD/FreeBSD-current/src/contrib/nvi/docs/tutorial.
+ del comando su per diventare root
+ e poter così modificarli. Puoi usare il semplice editor
+ ee, ma alla lunga risulta più utile imparare
+ vi. C'é un eccellente tutorial su
+ vi in
+ /usr/src/contrib/nvi/docs/tutorial se hai installato
+ i sorgenti di sistema.
Prima di modificare un file, dovresti farne una copia.
Supponiamo tu voglia modificare /etc/rc.conf. Puoi
semplicemente usare cd /etc per andare in
/etc e fare:&prompt.root; cp rc.conf rc.conf.origQuesto copierà rc.conf in
rc.conf.orig, e potrai successivamente copiare
rc.conf.orig in
rc.conf per tornare all'originale. Ma ancora meglio
sarà spostare (rinominare) il file per poi ricopiarlo con il nome
originale:&prompt.root; mv rc.conf rc.conf.orig
&prompt.root; cp rc.conf.orig rc.confperché il comando mv mantiene
la data e il proprietario originali del file. Puoi ora modificare
rc.conf. Se vuoi tornare all'originale,
potresti fare mv rc.conf rc.conf.myedit
(assumendo che vuoi tenere la versione modificata) e
quindi fare&prompt.root; mv rc.conf.orig rc.confper tornare allo stato iniziale.Per modificare un file, digita&prompt.root; vi nomefileMuoviti nel testo con i tasti freccia.
Esc mette vi
in modalità comando. Ecco qui alcuni dei comandi:xcancella la lettera su cui si trova il cursoreddcancella l'intera riga (anche se va a capo sullo schermo)iinserisci del testo nella posizione del cursoreainserisci del testo dopo il cursoreQuando digiti i o a,
puoi inserire del testo. Esc ti riporta in
modalità comando dove puoi digitare:wper salvare le modifiche sul disco e continuare a
modificare il file:wqper salvare le modifiche e uscire:q!per uscire senza salvare le modifiche/testoper spostare il cursore su testo;
/Invio
per trovare la prossima occorrenza di
testo.Gper andare alla fine del filenGper andare alla riga n del
file, dove n è un numeroCtrlLper ridisegnare lo schermoCtrlb e
Ctrlfvai avanti e indietro di una pagina, come succede con
more e view.Fai un po' di pratica con vi nella tua directory
home creando un nuovo file digitando vi
nomefile e aggiungendo
e cancellando del testo, salvando il file, e riaprendolo di nuovo.
vi è pieno di sorprese perché è
abbastanza complesso, e ti capiterà di digitare un comando che
farà di sicuro qualcosa che non ti aspetti. (Alcune persone
preferiscono vi—è più potente
dell'EDIT del DOS—scopri il comando :r)
Usa Esc una o più volte per essere sicuro di
essere in modalità comando e continua da lì quando hai dei
problemi, salva spesso con :w, e usa
:q! per uscire e ricominciare (dal tuo ultimo
:w) quando ne hai bisogno.Ora puoi usare cd per andare in
- /etc, su per diventare root,
- vi per modificare il file
- /etc/group, e aggiungere un utente al gruppo wheel
- cosicché possa avere privilegi di root. Aggiungi solo una virgola
- e il nome di login dell'utente alla fine della prima riga del file, premi
+ /etc, su per diventare
+ root, vi per modificare il file
+ /etc/group, e aggiungere un utente al gruppo
+ wheel cosicché possa avere privilegi di
+ root. Aggiungi solo una virgola e il nome di login
+ dell'utente alla fine della prima riga del file, premi
Esc, e usa :wq per salvare
il file su disco e uscire. La modifica ha effetto immediato. (Non hai
lasciato uno spazio dopo la virgola, vero?)Stampa di File da DOSA questo punto la tua stampante non funzionerà ancora sotto
FreeBSD, ecco quindi un sistema per creare un file da una pagina man,
metterlo su un floppy, e quindi stamparlo da DOS. Supponiamo che tu
voglia leggere attentamente come cambiare i permessi sui file (abbastanza
importante). Puoi usare man chmod per leggere come
fare. Il comando&prompt.user; man chmod | col -b > chmod.txttoglierà gli elementi di formattazione e manderà il
tutto sul file chmod.txt al posto di mostrare il
contenuto sullo schermo. Ora metti un dischetto formattato DOS nel
- lettore, digita su per diventare root, e scrivi
+ lettore, digita su per diventare
+ root, e scrivi
&prompt.root; /sbin/mount -t msdos /dev/fd0 /mntper montare il floppy su /mnt.
- Ora (non hai più bisogno di essere root, e puoi digitare
- exit per tornare ad essere l'utente jack) puoi
- andare nella directory in cui hai creato chmod.txt e
- copiare il file sul floppy digitando:
+ Ora (non hai più bisogno di essere root,
+ e puoi digitare exit per tornare ad essere l'utente
+ jack) puoi andare nella directory in cui hai creato
+ chmod.txt e copiare il file sul floppy
+ digitando:&prompt.user; cp chmod.txt /mnte usare ls /mnt per vedere il
contenuto di /mnt, che dovrebbe contenere il file
chmod.txt.In particolare potresti voler creare un file con l'output di
/sbin/dmesg digitando&prompt.user; /sbin/dmesg > dmesg.txte copiare dmesg.txt sul floppy.
/sbin/dmesg è il file di log di avvio, ed
è importante comprenderlo perché ti mostra cosa ha trovato
FreeBSD all'avvio. Se poni delle domande sulla &a.questions;
o su un gruppo USENET—del tipo FreeBSD non trova il mio drive
per i nastri, che cosa faccio?—la gente vorrà
sapere cosa mostra il tuo dmesg.
- Ora devi smontare il floppy (da root) per poter togliere
- il disco
+ Ora devi smontare il floppy (da root) per poter
+ togliere il disco&prompt.root; /sbin/umount /mnte riavviare per tornare in DOS. Copia questo file in una
directory DOS, richiamali con l'EDIT del DOS, Notepad o Wordpad di
&windows;, o un editor di testi, fai una piccola modifica in modo che
il file debba essere salvato, e stampa come faresti da DOS o
&windows;. Spera che funzioni! Le pagine man vengono meglio se
stampate con il comando DOS print. (Copiare i file
da FreeBSD su una partizione DOS montata è ancora in alcuni casi
rischioso.)Far funzionare la stampante sotto FreeBSD consiste nel creare
un opportuno elemento in /etc/printcap e
creare una directory di spool corrispondente in
/var/spool/output. Se la tua stampante è su
lpt0 (ciò che DOS chiama
LPT1), devi solo andare in
- /var/spool/output e (da root) creare la
- directory lpd digitando: mkdir
- lpd, se non è già presente. A quel punto la
+ /var/spool/output e (da root)
+ creare la directory lpd digitando: mkdir
+ lpd, se non è già presente. A quel punto la
stampante dovrebbe rispondere quando il sistema parte, e
lp o lpr dovrebbero mandare un
file alla stampante. Che il file venga stampato o meno è solo
questione di configurazione, che è discussa nel Manuale di FreeBSD.Altri Comandi Utilidfmostra lo spazio disponibile e tutte le partizioni
montate.ps auxmostra i processi in esecuzione. ps ax
è una forma contratta.rm nomefilecancella nomefile.rm -R dircancella la directory dir e tutte le
sottodirectory—attenzione!ls -Rmostra il contenuto della directory e delle sue
sottodirectory; io usavo una variante, ls -AFR >
where.txt, per avere una lista dei file in
/ e (separatamente)
/usr prima che scoprissi dei metodi migliori
per cercare i file.passwd
- per cambiare la password dell'utente (o di root)
+ per cambiare la password dell'utente (o di
+ root)man hierpagina man sul file system di &unix;Usa find per trovare nomefile
in /usr o nelle sue sottodirectory digitando&prompt.user; find /usr -name "nomefile"Puoi usare * come identificatore universale in
"nomefile"
(che dovrebbe essere tra virgolette). Se dici a
find di cercare in /
anziché /usr cercherà il/i file su
tutti i file system montati, inclusi i CDROM e le partizioni DOS.Un libro eccellente che tratta i comandi e le utility di &unix;
è Unix for the Impatient di Abrahams &
Larson (2nd ed., Addison-Wesley, 1996).
- Ci sono anche un sacco di informazioni su &unix; su Internet. Guarda
- Unix Reference
- Desk.
+ Ci sono anche un sacco di informazioni su &unix; su Internet.
Prossimi PassiDovresti ora avere gli strumenti necessari per girare nel sistema e
modificare i file, così da poter rendere tutto funzionante. Ci
sono un sacco di informazioni nel Manuale di FreeBSD (che è
probabilmente sul tuo disco rigido) e sul sito web di FreeBSD. Una
grande scelta di package e port è presente sul CDROM così
come sul sito web. Il manuale ti spiega come usarli
(prendi il package se esiste, con pkg_add
/cdrom/packages/All/nomepackage,
dove nomepackage è il nome del file del
package). Il CDROM ha una lista di package e di port
con delle brevi descrizioni in cdrom/packages/index,
cdrom/packages/index.txt, e
cdrom/ports/index, e con descrizioni più ampie
in /cdrom/ports/*/*/pkg/DESCR, dove
* rappresenta rispettivamente sottodirectory di tipi di
programmi e nomi di programmi.Se trovi il manuale troppo difficile su come installare i port dal
CDROM (con il sistema di lndir e altro), ecco come
funziona normalmente:Trova il port che vuoi, supponiamo kermit.
Ci sarà una directory per lui sul CDROM. Copia la
sottodirectory in /usr/local (un buon posto
perché il software che aggiungi sia disponibile a tutti gli utenti)
con:&prompt.root; cp -R /cdrom/ports/comm/kermit /usr/localQuesto dovrebbe portarti ad avere la sottodirectory
/usr/local/kermit che contiene tutti i file
presenti nella sottodirectory kermit del CDROM.Ora, crea la directory
/usr/ports/distfiles se non esiste ancora,
usando mkdir. Poi controlla
/cdrom/ports/distfiles cercando un file
con il nome che indica che si tratta del port esatto. Copia quel file in
/usr/ports/distfiles; nelle versioni più
recenti puoi saltare questo passo, perché FreeBSD lo farà
per te. Nel caso di kermit, non c'è nessun
distfile.Quindi entra con cd nella sottodirectory di
/usr/local/kermit che contiene il file
Makefile. Digita&prompt.root; make all installDurante questo processo il port userà FTP per scaricare
i file compressi che non ha trovato sul CDROM o in
/usr/ports/distfiles. Se la tua connessione
non funziona ancora e non c'è nessun file per il port in
/cdrom/ports/distfiles, dovrai
recuperare il distfile usando un'altra macchina e poi copiarlo in
/usr/ports/distfiles da un dischetto o dalla
partizione DOS. Leggi Makefile (usando
cat o more oppure
view) per scoprire dove andare (il sito principale
di distribuzione) per trovare il file e conoscere il suo nome. Il nome
verrà troncato quando scaricato da DOS, e dopo averlo trasferito
in /usr/ports/distfiles dovrai
rinominarlo (usando il comando mv) nel suo
nome originale cosicché possa essere trovato. (Usa il
trasferimento di file binario!)
Quindi torna in /usr/local/kermit, trova la
directory contenente Makefile, e digita
make all install.Un'altra cosa che può succedere quando si installa un port o un
package è che questi abbiano bisogno di un altro programma. Se
l'installazione si ferma con un messaggio can't find
unzip o simile, potresti dover installare il
package o il port di unzip prima di proseguire.Una volta installato, digita rehash per far
sì che FreeBSD rilegga i file contenuti nel path e sappia quali
sono presenti.
(Se trovi un sacco di messaggi path not found
quando usi whereis o which, dovresti
fare delle aggiunte all'elenco delle directory nel
file .cshrc nella tua directory home.
L'elenco dei path in &unix; fa la stessa
cosa che fa in DOS, tranne che la directory corrente (di
default) non si trova nel path per ragioni di sicurezza; se il comando
che vuoi eseguire è nella directory in cui ti trovi, devi digitare
./ prima del nome del comando; niente
spazio dopo la barra.)Potresti volere la versione più recente di &netscape;
dal loro sito FTP.
(&netscape; necessita dell'X Window System.) Ora c'é una versione
per FreeBSD, quindi dà un'occhiata in giro. Usa solo
gunzip nomefile e
tar xvf nomefile sul file,
sposta il binario in /usr/local/bin o qualche altro
posto in cui vengono tenuti i binari, esegui rehash, e
quindi aggiungi le seguenti linee a .cshrc in tutte
le directory home degli utenti oppure (più semplicemente) in
/etc/csh.cshrc, il file di configurazione globale di
csh:setenv XKEYSYMDB /usr/X11R6/lib/X11/XKeysymDB
setenv XNLSPATH /usr/X11R6/lib/X11/nlsQuesto assume che il file XKeysymDB
e la directory nls siano in
/usr/X11R6/lib/X11; se non lo sono, trovale
e mettile lì.Se hai originariamente installato &netscape; dal CDROM (o via
FTP), non sostituire /usr/local/bin/netscape
con il nuovo binario di netscape; questo è solo uno script di shell
che imposta le variabili di ambiente per te. Rinomina invece
il nuovo binario in netscape.bin e rimpiazza il
vecchio binario, che dovrebbe essere
/usr/local/netscape/netscape.Il tuo Ambiente di LavoroLa shell è la parte più importante del tuo ambiente
di lavoro. In DOS, la shell è solitamente command.com. La shell
è ciò che interpreta i comandi che digiti sulla linea di
comando, e quindi comunica con il resto del sistema operativo.
Puoi anche scrivere script di shell, che sono come i file batch di
DOS: una serie di comandi che devono essere eseguiti senza il tuo
intervento.Due shell vengono normalmente installate con FreeBSD:
csh e sh.
csh è buona per lavoro da linea di comando, ma
gli script dovrebbero essere scritti usando sh (o
bash). Puoi scoprire che shell hai
digitando echo $SHELL.csh è una buona shell, ma
tcsh fa tutto ciò che csh
fa e anche altro. Ti permette di richiamare i comandi usando
le frecce e ti permette di modificarli. Ha l'auto-completamento dei nomi
di file con tab (csh usa Esc), e
ti permette di tornare alla directory in cui eri digitando
cd -. È anche più semplice alterare il
prompt con tcsh. Ti rende la vita più
facile.Ecco tre semplici passi per installare una nuova shell:Installa la shell tramite port o package, come faresti
con un qualsiasi altro port o package. Usa
rehash e which tcsh
(assumendo che tu stia installando tcsh) per
essere sicuro di averla installata.
- Da root, modifica /etc/shells, aggiungendo
- una riga nel file per la nuova shell, in questo caso
+ Da root, modifica
+ /etc/shells, aggiungendo una riga nel file per
+ la nuova shell, in questo caso
/usr/local/bin/tcsh, e salva il file.
(Alcuni port lo fanno per te.)Usa il comando chsh per cambiare
permanentemente la tua shell in tcsh, o digita
tcsh al prompt per cambiare la shell senza
dover uscire dal sistema per poi rientrare.
- Può essere pericoloso cambiare la shell di root in qualcosa
- di diverso da sh o csh su
- versioni più recenti di FreeBSD e di &unix;; potresti
- non avere una shell funzionante se il sistema entra in modalità
- singolo utente. La soluzione è usare su -m
- per diventare root, che ti dà tcsh come shell
- di root, poiché la shell è parte del tuo ambiente.
- Puoi rendere tutto ciò permanente aggiungendo al
- tuo .tcshrc un alias con:
+ Può essere pericoloso cambiare la shell di
+ root in qualcosa di diverso da
+ sh o csh su versioni più
+ recenti di FreeBSD e di &unix;; potresti non avere una shell
+ funzionante se il sistema entra in modalità singolo utente.
+ La soluzione è usare su -m per diventare
+ root, che ti dà tcsh come
+ shell di root, poiché la shell è
+ parte del tuo ambiente. Puoi rendere tutto ciò permanente
+ aggiungendo al tuo .tcshrc un alias con:alias su su -mQuando tcsh parte, legge i file
/etc/csh.cshrc e
/etc/csh.login, come farebbe
csh. Leggerà anche il file
.login nella tua directory home ed anche
.cshrc, a meno che tu non abbia un file
.tcshrc. Puoi crearlo copiando
.cshrc in .tcshrc.Ora che hai installato tcsh, puoi sistemare
il tuo prompt. Puoi trovare i dettagli nella pagina man di
tcsh, ma ecco qui una linea da mettere nel tuo
.tcshrc che ti dirà quanti comandi hai
digitato, che ore sono, e in che directory
ti trovi. Produce anche un > se sei un
- utente normale e un # se sei root, ma
- tsch lo farebbe in ogni caso:
+ utente normale e un # se sei root,
+ ma tcsh lo farebbe in ogni caso:
set prompt = "%h %t %~ %# "Questa dovrebbe andare nella stessa posizione della linea di
prompt corrente se ce n'è una, o sotto "if($?prompt) then" in caso
contrario. Commenta la vecchia riga; così potrai tornare a quella
vecchia se la preferirai. Non dimenticare gli spazi e le virgolette.
Puoi far rileggere .tcshrc digitando
source .tcshrc.Puoi avere una lista delle variabili di sistema che sono state
impostate digitando env al prompt.
Il risultato ti mostrerà il tuo editor di default, il pager, e il
tipo di terminale, tra le altre possibili variabili. Un comando
utile se ti connetti al sistema da una postazione remota e non riesci ad
eseguire un programma perché il terminale non ne è capace
è setenv TERM vt100.Altro
- Da root puoi smontare il CDROM con
+ Da tcsh puoi smontare il CDROM con
/sbin/umount /cdrom, toglilo dal lettore,
inseriscine un altro, e montalo con
/sbin/mount_cd9660 /dev/cd0a /cdrom assumendo che
cd0a sia il nome di dispositivo del tuo lettore di
CDROM. La versione più recente di FreeBSD ti permette di montare
il CDROM solo con /sbin/mount /cdrom.Usare il live file system—il secondo cd del set
di FreeBSD—è
utile se hai poco spazio a disposizione. Ciò che si trova
sul live file system cambia da release a release. Potresti
provare ad eseguire dei giochi dal CDROM. Questo comporta l'uso di
lndir, che viene installato con l'X Window
System, per dire ai programmi dove trovare i file necessari, poiché
questi si trovano nel file system /cdrom
anziché /usr e le sue
sottodirectory, che è dove dovrebbero essere. Leggi
man lndir per avere più informazioni.I Commenti sono BenvenutiSe usi questa guida, sarei interessata a sapere dove non è
chiara, ciò che è stato tralasciato e che vorresti venisse
incluso, e sapere se tutto ciò è stato utile. I miei
ringraziamenti vanno a Eugene W. Stark, professore di informatica a
SUNY-Stony Brook, e John Fieber per i suoi utili commenti.Annelise Anderson, andrsn@andrsn.stanford.eduPer questioni legate alla traduzione, o se avete commenti da poter
esprimere solo in italiano, non esitate a contattarmi. Come per l'autrice
originale, ogni genere di commenti è ben accetto.Massimiliano Stucchi, stucchi@willystudios.com
diff --git a/it_IT.ISO8859-15/articles/vm-design/article.sgml b/it_IT.ISO8859-15/articles/vm-design/article.sgml
index 8963bf39f9..4275d701de 100644
--- a/it_IT.ISO8859-15/articles/vm-design/article.sgml
+++ b/it_IT.ISO8859-15/articles/vm-design/article.sgml
@@ -1,1059 +1,1059 @@
%man;
-
-%freebsd;
+
+%freebsd;
%it-trademarks;
-
+
%trademarks;
%translators;
]>
Elementi di progettazione del sistema di VM di FreeBSDMatthewDillondillon@apollo.backplane.com
-
- &tm-attrib.freebsd;
- &tm-attrib.linux;
- &tm-attrib.microsoft;
- &tm-attrib.opengroup;
- &tm-attrib.general;
-
+
+ &tm-attrib.freebsd;
+ &tm-attrib.linux;
+ &tm-attrib.microsoft;
+ &tm-attrib.opengroup;
+ &tm-attrib.general;
+ Il titolo è in realtà solo un modo complicato per dire
che cercherò di descrivere l'intera enchilada della memoria
virtuale (VM), sperando di farlo in una maniera che chiunque possa
seguire.
Nell'ultimo anno mi sono concentrato su un certo numero di sottosistemi
principali del kernel in FreeBSD, trovando quelli della VM (la memoria
virtuale) e dello Swap i più interessanti, e considerando quello
di NFS un lavoretto necessario.
Ho riscritto solo piccole porzioni di quel codice. Nell'arena
della VM la sola grossa riscrittura che ho affrontato è stata
quella del sottosistema di swap.
La maggior parte del mio lavoro è stato di pulizia e
mantenimento, con solo alcune moderate riscritture di codice e
nessuna correzione rilevante a livello algoritmico nel sottosistema
della VM. Il nocciolo della base teorica del sottosistema
rimane immutato ed un bel po' del merito per gli sforzi di
modernizzazione negli ultimi anni appartiene a John Dyson e David
Greenman. Poiché non sono uno storico come Kirk non
tenterò di marcare tutte le varie caratteristiche con i nomi
delle relative persone, perché sbaglierei
invariabilmente.
- Traduzione a cura di &a.it.surrender;.
+ &trans.it.surrender;
Questo articolo è stato pubblicato in origine nel numero di
gennaio 2000 di DaemonNews.
Questa versione dell'articolo può includere aggiornamenti da
parte di Matt e di altri autori per riflettere i cambiamenti
nell'implementazione della VM di FreeBSD.IntroduzionePrima di andare avanti con la descrizione del progetto effettivo
della VM spendiamo un po' di tempo sulla necessità di mantenere
e modernizzare una qualunque base di codice longeva.
Nel mondo della programmazione, gli algoritmi tendono ad essere più
importanti del codice ed è dovuto alle radici accademiche
di BSD che si è prestata grande attenzione alla progettazione
algoritmica sin dal principio.
Una maggiore attenzione al design in genere conduce ad una base di codice
flessibile e pulita che può essere modificata abbastanza
semplicemente, estesa, o rimpiazzata nel tempo.
Mentre BSD viene considerato un sistema operativo vecchio
da alcune persone, quelli di noi che lavorano su di esso tendono
a considerarlo come una base di codice matura
che ha vari componenti modificati, estesi, o rimpiazzati con codice
moderno. Questa si è evoluta, e FreeBSD è all'avanguardia,
non importa quanto possa essere vecchio qualche pezzo di codice.
Questa è una distinzione importante da fare ed una di quelle che
sfortunatamente sfuggono alla maggior parte delle persone. Il più
grande errore che un programmatore possa fare è non imparare
dalla storia, e questo è precisamente l'errore che molti sistemi
operativi moderni hanno commesso. &windowsnt; è il miglior esempio
di questo, e le conseguenze sono state disastrose. Anche Linux commette
questo errore a un certo livello—abbastanza perché noi
appassionati di BSD possiamo scherzarci su ogni tanto, comunque.
Il problema di Linux è semplicemente la mancanza di esperienza e
di una storia con la quale confrontare le idee, un problema che sta
venendo affrontato rapidamente dalla comunità Linux nello stesso
modo in cui è stato affrontato da quella BSD—con il continuo
sviluppo di codice. La gente di &windowsnt;, d'altro canto, fa
ripetutamente gli stessi errori risolti da &unix; decadi fa e poi impiega
anni nel risolverli. E poi li rifanno, ancora, e ancora.
Soffrono di un preoccupante caso di non è stato progettato
qui e di abbiamo sempre ragione perché il nostro
dipartimento marketing dice così. Io ho pochissima
tolleranza per chiunque non impari dalla storia.La maggior parte dell'apparente complessità di progettazione di
FreeBSD, specialmente nel sottosistema VM/Swap, è una conseguenza
diretta dell'aver dovuto risolvere importanti problemi di prestazioni
legati a varie condizioni. Questi problemi non sono dovuti a cattivi
progetti algoritmici ma sorgono invece da fattori ambientali.
In ogni paragone diretto tra piattaforme, questi problemi
diventano più evidenti quando le risorse di sistema cominciano ad
essere stressate.
Mentre descrivo il sottosistema VM/Swap di FreeBSD il lettore
dovrebbe sempre tenere a mente almeno due punti. Primo, l'aspetto
più importante nel design prestazionale è ciò che
è noto come Ottimizzazione del Percorso Critico.
Accade spesso che le ottimizzazioni prestazionali aggiungano
un po di impurità al codice per far migliorare il percorso critico.
Secondo, un progetto solido e generalizzato, funziona meglio di
un progetto pesantemente ottimizzato, alla lunga. Mentre un progetto
generale può alla fin fine essere più lento di un sistema
pesantemente ottimizzato quando vengono implementati inizialmente, il
progetto generalizzato tende ad essere più semplice da adattare
alle condizioni variabili mentre quello pesantemente ottimizzato finisce
per dover essere gettato via. Ogni base di codice che dovrà
sopravvivere ed essere mantenibile per anni deve dunque essere progettata
con attenzione fin dall'inizio anche se questo può portare a
piccoli peggioramenti nelle prestazioni.
Vent'anni fa c'era ancora gente che sosteneva che programmare in assembly
era meglio che programmare in linguaggi di alto livello, perché
si poteva produrre codice che era dieci volte più veloce. Oggi,
la fallacia di tale argomento è ovvia—così come i
paralleli con il design algoritmico e la generalizzazione del
codice.Oggetti VMIl modo migliore per iniziare a descrivere il sistema di VM di FreeBSD
è guardandolo dalla prospettiva di un processo a livello
utente. Ogni processo utente vede uno spazio di indirizzamento della VM
singolo, privato e contiguo, contenente molti tipi di oggetti di memoria.
Questi oggetti hanno varie caratteristiche.
Il codice del programma e i dati del programma sono effettivamente
un singolo file mappato in memoria (il file binario che è stato
eseguito), ma il codice di programma è di sola lettura mentre i
dati del programma sono copy-on-write I dati copy on write sono dati che vengono copiati solo al momento
della loro effettiva modifica. Il BSS del programma è solamente una zona di memoria
allocata e riempita con degli zero su richiesta, detta in inglese
demand zero page fill.
Nello spazio di indirizzamento possono essere mappati anche file
arbitrari, che è in effetti il meccanismo con il quale funzionano
le librerie condivise. Tali mappature possono richiedere modifiche per
rimanere private rispetto al processo che le ha effettuate.
La chiamata di sistema fork aggiunge una dimensione completamente nuova
al problema della gestione della VM in cima alla complessità
già data.Una pagina di dati di un programma (che è una basilare pagina
copy-on-write) illustra questa complessità. Un programma binario
contiene una sezione di dati preinizializzati che viene inizialmente
mappata direttamente in memoria dal file del programma.
Quando un programma viene caricato nello spazio di memoria virtuale di un
processo, questa area viene inizialmente copiata e mappata in memoria dal
binario del programma stesso, permettendo al sistema della VM di
liberare/riusare la pagina in seguito e poi ricaricarla dal binario.
Nel momento in cui un processo modifica questi dati, comunque, il
sistema della VM deve mantenere una copia privata della pagina per quel
processo. Poiché la copia privata è stata modificata, il
sistema della VM non può più liberarlo, poiché non ci
sarebbe più nessuna possibilità di recuperarlo in
seguito.Noterai immediatamente che quella che in origine era soltanto
una semplice mappatura di un file è diventata qualcosa di
più complesso.
I dati possono essere modificati pagina per pagina
mentre una mappatura di file coinvolge molte pagine alla volta.
La complessità aumenta ancora quando un processo esegue una fork.
Quando un processo esegue una fork, il risultato sono due
processi—ognuno con il proprio spazio di indirizzamento privato,
inclusa ogni modifica fatta dal processo originale prima della chiamata a
fork(). Sarebbe stupido per un sistema di VM creare
una copia completa dei dati al momento della fork()
perché è abbastanza probabile che almeno uno dei due
processi avrà bisogno soltanto di leggere da una certa pagina da
quel momento in poi, permettendo di continuare ad usare la
pagina originale. Quella che era una pagina privata viene di nuovo
resa una copy-on-write, poiché ogni processo (padre e figlio) si
aspetta che i propri cambiamenti rimangano privati per loro e non abbiano
effetti sugli altri.FreeBSD gestisce tutto ciò con un modello a strati di oggetti
VM. Il file binario originale del programma risulta come lo strato di
Oggetti VM più basso.
Un livello copy-on-write viene messo sopra questo per mantenere quelle
pagine che sono state copiate dal file originale.
Se il programma modifica una pagina di dati appartenente al file originale
il sistema dell VM prende un page fault Un page fault, o mancanza di pagina,
corrisponde ad una mancanza di una determinata pagina di memoria a un
certo livello, ed alla necessità di copiarla da un livello
più lento. Ad esempio se una pagina di memoria è stata
spostata dalla memoria fisica allo spazio di swap su disco, e viene
richiamata, si genera un page fault e la pagina viene di nuovo copiata
in ram. e fa una copia della pagina nel livello più alto.
Quando un processo effettua una fork, vengono aggiunti altri livelli di
Oggetti VM. Tutto questo potrebbe avere un po' più senso con un
semplice esempio.
Una fork() è un'operazione comune per ogni
sistema *BSD, dunque questo esempio prenderà in considerazione un
programma che viene avviato ed esegue una fork. Quando il processo viene
avviato, il sistema della VM crea uno starto di oggetti, chiamiamolo
A:+---------------+
| A |
+---------------+Un'immagineA rappresenta il file—le pagine possono essere
spostate dentro e fuori dal mezzo fisico del file se necessario.
Copiare il file dal disco è sensato per un programma,
ma di certo non vogliamo effettuare il page out La copia dalla memoria al disco, l'opposto del page in, la
mappatura in memoria. e sovrascrivere l'eseguibile.
Il sistema della VM crea dunque un secondo livello, B, che verrà
copiato fisicamente dallo spazio di swap:+---------------+
| B |
+---------------+
| A |
+---------------+Dopo questo, nella prima scrittura verso una pagina, viene creata una
nuova pagina in B, ed il suo contenuto viene inizializzato con i dati di
A. Tutte le pagine in B possono essere spostate da e verso un dispositivo
di swap. Quando il programma esegue la fork, il sistema della VM crea
due nuovi livelli di oggetti—C1 per il padre e C2 per il
figlio—che restano sopra a B:+-------+-------+
| C1 | C2 |
+-------+-------+
| B |
+---------------+
| A |
+---------------+In questo caso, supponiamo che una pagina in B venga modificata dal
processo genitore. Il processo subirà un fault di copy-on-write e
duplicherà la pagina in C1, lasciando la pagina originale in B
intatta.
Ora, supponiamo che la stessa pagina in B venga modificata dal processo
figlio. Il processo subirà un fault di copy-on-write e
duplicherà la pagina in C2.
La pagina originale in B è ora completamente nascosta poiché
sia C1 che C2 hanno una copia e B potrebbe teoricamente essere distrutta
(se non rappresenta un vero file).
Comunque, questo tipo di ottimizzazione non è triviale da
realizzare perché è di grana molto fine.
FreeBSD non effettua questa ottimizzazione.
Ora, supponiamo (come è spesso il caso) che
il processo figlio effettui una exec(). Il suo
attuale spazio di indirizzamento è in genere rimpiazzato da un
nuovo spazio di indirizzamento rappresentante il nuovo file.
In questo caso il livello C2 viene distrutto:+-------+
| C1 |
+-------+-------+
| B |
+---------------+
| A |
+---------------+In questo caso, il numero di figli di B scende a uno, e tutti gli
accessi a B avvengono attraverso C1. Ciò significa che B e C1
possono collassare insieme in un singolo strato.
Ogni pagina in B che esista anche in C1 viene cancellata da
B durante il crollo. Dunque, anche se l'ottimizzazione nel passo
precedente non era stata effettuata, possiamo recuperare le pagine morte
quando il processo esce o esegue una exec().Questo modello crea un bel po' di problemi potenziali. Il primo
è che ci si potrebbe ritrovare con una pila abbastanza profonda di
Oggetti VM incolonnati che costerebbe memoria e tempo per la ricerca
quando accadesse un fault. Può verificarsi un ingrandimento della
pila quando un processo esegue una fork dopo l'altra (che sia il padre o
il figlio). Il secondo problema è che potremmo ritrovarci con
pagine morte, inaccessibili nella profondità della pila degli
Oggetti VM. Nel nostro ultimo esempio se sia il padre che il figlio
modificano la stessa pagina, entrambi hanno una loro copia della pagina e
la pagina originale in B non è più accessibile
da nessuno. Quella pagina in B può essere liberata.FreeBSD risolve il problema della profondità dei livelli con
un'ottimizzazione speciale detta All Shadowed Case (caso
dell'oscuramento totale).
Questo caso accade se C1 o C2 subiscono sufficienti COW fault (COW
è l'acronimo che sta per copy on write) da oscurare completamente
tutte le pagine in B.
Ponimo che C1 abbia raggiunto questo livello. C1 può ora
scavalcare B del tutto, dunque invece di avere C1->B->A e C2->B->A adesso
abbiamo C1->A e C2->B->A.
ma si noti cos'altro è accaduto—ora B ha solo un riferimento
(C2), dunque possiamo far collassare B e C2 insieme.
Il risultato finale è che B viene cancellato
interamente e abbiamo C1->A e C2->A. Spesso accade che B contenga un
grosso numero di pagine e ne' C1 ne' C2 riescano a oscurarlo
completamente. Se eseguiamo una nuova fork e creiamo un insieme di
livelli D, comunque, è molto più probabile che uno dei
livelli D sia eventualmente in grado di oscurare completamente l'insieme
di dati più piccolo rappresentato da C1 o C2. La stessa
ottimizzazione funzionerà in ogni punto nel grafico ed il
risultato di ciò è che anche su una macchina con
moltissime fork le pile degli Oggetti VM tendono a non superare una
profondità di 4. Ciò è vero sia per il padre che per
il figlio ed è vero nel caso sia il padre a eseguire la fork ma
anche se è il figlio a eseguire fork in cascata.Il problema della pagina morta esiste ancora nel caso C1 o C2 non
oscurino completamente B. A causa delle altre ottimizzazioni questa
eventualità
non rappresenta un grosso problema e quindi permettiamo semplicemente
alle pagine di essere morte. Se il sistema si trovasse con poca memoria
le manderebbe in swap, consumando un po' di swap, ma così
è.Il vantaggio del modello ad Oggetti VM è che
fork() è estremamente veloce, poiché
non deve aver luogo nessuna copia di dati effettiva. Lo svantaggio
è che è possibile costruire un meccanismo a livelli di
Oggetti VM relativamente complesso che rallenterebbe la gestione dei page
fault, e consumerebbe memoria gestendo le strutture degli Oggetti VM.
Le ottimizazioni realizzate da FreeBSD danno prova di ridurre
i problemi abbastanza da poter essere ignorati, non lasciando
nessuno svantaggio reale.Livelli di SWAPLe pagine di dati private sono inizialmente o pagine
copy-on-write o pagine zero-fill.
Quando avviene un cambiamento, e dunque una copia, l'oggetto di copia
originale (in genere un file) non può più essere utilizzato
per salvare la copia quando il sistema della VM ha bisogno di
riutilizzarla per altri scopi. A questo punto entra in gioco lo SWAP. Lo
SWAP viene allocato per creare spazio dove salvare memoria che altrimenti
non sarebbe disponibile. FreeBSD alloca la struttura di gestione di
un Oggetto VM solo quando è veramente necessario.
Ad ogni modo, la struttura di gestione dello swap ha avuto storicamente
dei problemi.Su FreeBSD 3.X la gestione della struttura di swap prealloca un
array che contiene l'intero oggetto che necessita di subire
swap—anche se solo poche pagine di quell'oggetto sono effettivamente
swappate questo crea una frammentazione della memoria del kernel quando
vengono mappati oggetti grandi, o processi con grandi dimensioni
all'esecuzione (large runsizes, RSS). Inoltre, per poter tenere traccia
dello spazio di swap, viene mantenuta una lista dei buchi
nella memoria del kernel, ed anche questa tende ad essere pesantemente
frammentata. Poiché la lista dei buchi è una
lista lineare, l'allocazione di swap e la liberazione hanno prestazioni
non ottimali O(n) per ogni pagina.
Questo richiede anche che avvengano allocazioni di memoria
durante il processo di liberazione dello swap, e questo crea
problemi di deadlock, blocchi senza uscita, dovuti a scarsa memoria.
Il problema è ancor più esacerbato dai buchi creati a causa
dell'algoritmo di interleaving.
Inoltre il blocco di swap può divenire frammentato molto facilmente
causando un'allocazione non contigua. Anche la memoria del Kernel deve
essere allocata al volo per le strutture aggiuntive di gestione dello
swap quando avviene uno swapout. È evidente che c'era molto spazio
per dei miglioramenti.Per FreeBSD 4.X, ho completamente riscritto il sottosistema di swap.
Con questa riscrittura, le strutture di gestione dello swap vengono
allocate attraverso una tabella di hash invece che con un array lineare
fornendo una dimensione di allocazione fissata e una granularità
molto maggiore.
Invece di usare una lista lineare collegata per tenere traccia delle
riserve di spazio di swap, essa usa una mappa di bit di blocchi di swap
organizzata in una struttura ad albero radicato con riferimenti allo
spazio libero nelle strutture nei nodi dell'albero. Ciò rende in
effetti l'operazione di allocazione e liberazione delle risorse
un'operazione O(1).
L'intera mappa di bit dell'albero radicato viene anche preallocata in modo
da evitare l'allocazione di memoria kernel durante le operazioni di swap
critiche nei momenti in cui la memoria disponibile è ridotta.
Dopo tutto, il sistema tende a fare uso dello swap quando ha poca memoria
quindi dovremmo evitare di allocare memoria per il kernel in quei momenti
per poter evitare potenziali deadlock. Infine, per ridurre la
frammentazione l'albero radicato è in grado di allocare grandi
spezzoni contigui in una volta, saltando i pezzetti frammentati.
Non ho ancora compiuto il passo finale di avere un puntatore di
supportoall'allocazione che scorra su una porzione di swap nel
momento in cui vengano effettuate delle allocazioni, in modo da garantire
ancor di più le allocazioni contigue o almeno una località
nel riferimento, ma ho assicurato che un'aggiunta simile possa essere
effettuata.Quando liberare una paginaPoiché il sistema della VM usa tutta la memoria disponibile
per il caching del disco, in genere ci sono pochissime pagine veramente
libere. Il sistema della VM dipende dalla possibilità di
scegliere in maniera appropriata le pagine che non sono in uso per
riusarle in nuove allocazioni. Selezionare le pagine ottimali da liberare
è forse la funzione singola più importante che possa essere
eseguita da una VM perché se si effettua una selezione non
accurata, il sistema della VM può essere forzato a recuperare
pagine dal disco in modo non necessari, degradando seriamente le
prestazioni del sistema.Quanto sovraccarico siamo disposti a sopportare nel percorso critico
per evitare di liberare la pagina sbagliata? Ogni scelta sbagliata che
facciamo ci costerà centinaia di migliaia di cicli di CPU ed uno
stallo percettibile nei processi coinvolti, dunque permettiamo un
sovraccarico significativo in modo da poter avere la certezza che la
pagina scelta sia quella giusta.
Questo è il motivo per cui FreeBSD tende ad avere prestazioni
migliori di altri sistemi quando le risorse di memoria vengono
stressate.L'algoritmo di determinazione della pagina da liberare
è costruito su una storia di uso delle pagine di memoria.
Per acquisire tale storia, il sistema si avvantaggia di una
caratteristica della maggior parte dell'hardware moderno, il bit che
indica l'attività di una pagina (page-used bit).In qualsiasi caso, il page-used bit viene azzerato e in un momento
seguente il sistema della VM passa di nuovo sulla pagina e vede che il
page-used bit è stato di nuovo attivato. Questo indica che la
pagina viene ancora usata attivamente.
Il bit ancora disattivato è un indice che quella pagina non viene
usata attivamente.
Controllando questo bit periodicamente, viene sviluppata una storia
d'uso (in forma di contatore) per la pagina fisica. Quando il sistema
della VM avrà bisogno di liberare delle pagine, controllare questa
storia diventa la pietra angolare nella determinazione del candidato
migliore come pagina da riutilizzare.E se l'hardware non ha un page-used bit?Per quelle piattaforme che non hanno questa caratteristica, il
sistema in effetti emula un page-used bit. Esso elimina la mappatura di
una pagina, o la protegge, forzando un page fault se c'è un
accesso successivo alla pagina.
Quando avviene il page fault, il sistema segnala semplicemente
la pagina come usata e la sprotegge in maniera che possa essere usata.
Mentre prendere tale page fault solo per determinare se una pagina
è in uso può apparire una scelta costosa, in realtà
essa lo è molto meno che riusare la pagina per altri scopi, per
dover poi scoprire che un processo ne aveva ancora bisogno e dovere
andare a cercarla di nuovo su disco.FreeBSD fa uso di parecchie code per le pagine per raffinare
ulteriormente la selezione delle pagine da riutilizzare, come anche per
determinare quando le pagine sporche devono essere spostate dalla memoria
e immagazzinate da qualche parte. Poiché le tabelle delle pagine
sono entità dinamiche in FreeBSD, non costa praticamente nulla
eliminare la mappatura di una pagina dallo spazio di indirizzamento di un
qualsiasi processo che la stia usando. Quando una pagina candidata
è stata scelta sulla base del contatore d'uso, questo è
esattamente quello che viene fatto.
Il sistema deve effettuare una distinzione tra pagine pulite che
possono essere teoricamente liberate in qualsiasi momento, e pagine
sporche che devono prima essere scritte (salvate) per poter essere
riutilizzabili.
Quando una pagina candidata viene trovata viene spostata nella coda
delle pagine inattive, se è una pagina sporca, o nella coda di
cache se è pulita.
Un algoritmo separato basato su un rapporto sporche/pulite
determina quando le pagine sporche nella coda inattiva devono essere
scritte su disco. Una volta che è stato fatto questo, le pagine
ormai salvate vengono spostate dalla coda delle inattive alla coda di
cache. A questo punto, le pagine nella coda di cache possono ancora
essere riattivate da un VM fault ad un costo relativamente basso.
Ad ogni modo, le pagine nella coda di cache vengono considerate
immediatamente liberabili e verranno riutilizzate con un
metodo LRU (least-recently used Usate meno recentemente. Le pagine che non vengono usate da molto
tempo probabilmente non saranno necessarie a breve, e possono essere
liberate.) quando il sistema avrà bisogno di allocare nuova
memoria.È importante notare che il sistema della VM di FreeBSD tenta
di separare pagine pulite e sporche per l'espressa ragione di evitare
scritture non necessarie di pagine sporche (che divorano banda di I/O), e
non sposta le pagine tra le varie code gratuitamente quando il
sottosistema non viene stressato. Questo è il motivo per cui
dando un systat -vm vedrai sistemi con contatori della
coda di cache bassi e contatori della coda delle pagine attive molto alti.
Quando il sistema della VM diviene maggiormente stressato, esso fa un
grande sforzo per mantenere le varie code delle pagine ai livelli
determinati come più efficenti.
Per anni è circolata la leggenda urbana che Linux facesse un lavoro
migliore di FreeBSD nell'evitare gli swapout, ma in pratica questo non
è vero. Quello che stava effettivamente accadendo era che FreeBSD
stava salvando le pagine inutilizzate proattivamente per fare spazio
mentre Linux stava mantendendo le pagine inutilizzate lasciando meno
memoria disponibile per la cache e le pagine dei processi.
Non so se questo sia vero ancora oggi.Pre-Faulting e Ottimizzazioni di AzzeramentoSubire un VM fault non è costoso se la pagina sottostante
è già nella memoria fisica e deve solo essere mappata di
nuovo nel processo, ma può divenire costoso nel caso se ne
subiscano un bel po' su base regolare. Un buon esempio di ciò si
ha eseguendo un programma come &man.ls.1; o &man.ps.1; ripetutamente.
Se il binario del programma è mappato in memoria ma non nella
tabella delle pagine, allora tutte le pagine che verranno accedute dal
programmma dovranno generare un page fault ogni volta che il programma
viene eseguito.
Ciò non è necessario quando le pagine in questione sono
già nella cache della VM, quindi FreeBSD tenterà di
pre-popolare le tabelle delle pagine di un processo con quelle pagine che
sono già nella VM Cache. Una cosa che FreeBSD non fa ancora
è effettuare il pre-copy-on-write di alcune pagine nel caso di una
chiamata a exec.
Ad esempio, se esegui il programma &man.ls.1; mentre stai eseguendo
vmstat 1 noterai che subisce sempre un certo numero
di page fault, anche eseguendolo ancora e ancora. Questi sono
zero-fill fault, legati alla necessità di azzerare memoria,
non program code fault, legati alla copia dell'eseguibile in memoria
(che erano già stati gestiti come pre-fault).
Pre-copiare le pagine all'exec o alla fork è un'area che potrebbe
essere soggetta a maggior studio.Una larga percentuale dei page fault che accadono è composta di
zero-fill fault. In genere è possibile notare questo fatto
osservando l'output di vmstat -s.
Questi accadono quando un processo accede a pagine nell'area del BSS.
Ci si aspetta che l'area del BSS sia composta inizialmente da zeri
ma il sistema della VM non si preoccupa di allocare nessuna memoria
finché il processo non ne ha effettivamente bisogno.
Quindi nel momento in cui accade un fault il sistema della VM non
deve solo allocare una nuova pagina, ma deve anche azzerarla.
Per ottimizzare l'operazione di azzeramento, il sistema della VM
ha la capacità di pre-azzerare le pagine e segnalarle come tali,
e di richiedere pagine pre-azzerate quando avvengono zero-fill fault.
Il pre-azzeramento avviene quando la CPU è inutilizzata ma il
numero di pagine che vengono pre-azzerate dal sistema è limitato
per evitare di spazzare via la cache della memoria. Questo è un
eccellente esempio di complessità aggiunta al sistema della VM per
ottimizare il percorso critico.Ottimizzazioni della Tabella delle Pagine Le ottimizzazioni alla tabella delle pagine costituiscono
La parte più controversa nel design della VM di FreeBSD ed ha
mostrato un po' di affanno con l'avvento di un uso pesante di
mmap().
Penso che questa sia una caratteristiche della maggior parte dei
BSD anche se non sono sicuro di quando è stata introdotta
la prima volta. Ci sono due ottimizzazioni maggiori. La prima è
che le tabelle della pagine hardware non contengono uno stato persistente
ma possono essere gettate via in qualsiasi momento con un sovraccarico di
gestione minimo.
La seconda è che ogni pagina attiva nel sistema ha una struttura di
controllo pv_entry che è integrata con la
struttura vm_page. FreeBSD può semplicemente
operare attraverso quelle mappature di cui è certa l'esistenza,
mentre Linux deve controllare tutte le tabelle delle pagine che
potrebbero contenere una mappatura specifica per
vedere se lo stanno effettivamente facendo, il che può portare ad
un sovraccarico computazionale O(n^2) in alcune situazioni.
È per questo che FreeBSD tende a fare scelte migliori su quale
pagina riutilizzare o mandare in swap quando la memoria è messa
sotto sforzo, fornendo una miglior performance sotto carico. Comunque,
FreeBSD richiede una messa a punto del kernel per accomodare situazioni
che richiedano grandi spazi di indirizzamento condivisi, come quelli che
possono essere necessari in un sistema di news perché potrebbe
esaurire il numero di struct pv_entry.Sia Linux che FreeBSD necessitano di lavoro in quest'area.
FreeBSD sta cercando di massimizzare il vantaggio di avere un modello di
mappatura attiva potenzialmente poco denso (non tutti i processi hanno
bisogno di mappare tutte le pagine di una libreria condivisa, ad esempio),
mentre linux sta cercando di semplificare i suoi algoritmi. FreeBSD
generalmente ha dei vantaggi prestazionali al costo di un piccolo spreco
di memoria in più, ma FreeBSD crolla nel caso in cui un grosso file
sia condiviso massivamente da centinaia di processi.
Linux, d'altro canto, crolla nel caso in cui molti processi mappino a
macchia di leopardo la stessa libreria condivisa e gira in maniera non
ottimale anche quando cerca di determinare se una pagina deve essere
riutilizzata o no.Colorazione delle PagineConcluderemo con le ottimizzazioni di colorazione delle pagine.
La colorazione delle pagine è un'ottimizzazione prestazionale
progettata per assicurare che gli accessi a pagine contigue nella memoria
virtuale facciano il miglior uso della cache del processore. Nei
tempi antichi (cioè più di 10 anni fa) le cache dei
processori tendevano a mapparela memoria virtuale invece della memoria
fisica. Questo conduceva ad un numero enorme di problemi inclusa la
necessità di ripulire la cache ad ogni cambio di contesto, in
alcuni casi, e problemi con l'aliasing dei dati nella cache.
Le cache dei processori moderni mappano la memoria fisica proprio per
risolvere questi problemi.
Questo significa che due pagine vicine nello spazio di indirizzamento
dei processi possono non corrispondere a due pagine vicine nella cache.
In effetti, se non si è attenti pagine affiancate nella memoria
virtuale possono finire con l'occupare la stessa pagina nella cache del
processore—portando all'eliminazione prematura di dati
immagazzinabili in cache e riducendo le prestazioni della cache.
Ciò è vero anche con cache set-associative set-associative sta per associative all'interno di un insieme, in
quanto c'è un insieme di blocchi della cache nei quale puo
essere mappato un elemento della memoria fisica. a molte vie (anche se l'effetto viene in qualche maniera
mitigato).Il codice di allocazione della memoria di FreeBSD implementa
le ottimizizzazioni di colorazione delle pagine, ciò significa che
il codice di allocazione della memoria cercherà di trovare delle
pagine libere che siano vicine dal punto di vista della cache.
Ad esempio, se la pagina 16 della memoria fisica è assegnata
alla pagina 0 della memoria virtuale di un processo e la cache può
contenere 4 pagine, il codice di colorazione delle pagine non
assegnerà la pagina 20 di memoria fisica alla pagina 1 di
quella virtuale.
Invece, gli assegnerà la pagina 21 della memoria fisica.
Il codice di colorazione delle pagine cerca di evitare l'assegnazione
della pagina 20 perché questa verrebbe mappata sopra lo stesso
blocco di memoria cache della pagina 16 e ciò causerrebbe un uso
non ottimale della cache.
Questo codice aggiunge una complessità significativa
al sottosistema di allocazione memoria della VM, come si può ben
immaginare, ma il gioco vale ben più della candela. La colorazione
delle pagine rende la memoria virtuale deterministica quanto la memoria
fisica per quel che riguarda le prestazioni della cache.ConclusioneLa memoria virtuale nei sistemi operativi moderni deve affrontare
molti problemi differenti efficientemente e per molti diversi tipi di uso.
L'approccio modulare ed algoritmico che BSD ha storicamente seguito ci
permette di studiare e comprendere l'implementazione attuale cosi come di
poter rimpiazzare in maniera relativamente pulita grosse sezioni di
codice. Ci sono stati un gran numero di miglioramenti al sistema della
VM di FreeBSD negli ultimi anni, ed il lavoro prosegue.Sessione Bonus di Domande e Risposte di Allen Briggs
briggs@ninthwonder.comCos'è l'algoritmo di interleaving a cui
fai riferimento nell'elenco delle debolezze della gestione dello
swap in FreeBSD 3.X ?FreeBSD usa un intervallo tra zone di swap fissato, con un
valore predefinito di 4. Questo significa che FreeBSD riserva
spazio per quattro aree di swap anche se ne hai una sola o due o
tre. Poiché lo swap è intervallato lo spazio di
indirizzamento lineare che rappresenta le quattro aree di
swap verrà frammentato se non si possiedono
veramente quattro aree di swap. Ad esempio, se hai due aree di
swap A e B la rappresentazione dello spazio di FreeBSD per
quell'area di swap verrà interrotta in blocchi di 16
pagine:A B C D A B C D A B C D A B C DFreeBSD 3.X usa una lista sequenziale delle
regioni libere per registrare le aree di swap libere.
L'idea è che grandi blocchi di spazio libero e lineare
possano essere rappresentati con un nodo singolo
(kern/subr_rlist.c).
Ma a causa della frammentazione la lista sequenziale risulta
assurdamente frammentata.
Nell'esempio precedente, uno spazio di swap completamente non
allocato farà si che A e B siano mostrati come
liberi e C e D come totalmente
allocati. Ogni sequenza A-B richiede un nodo per essere
registrato perché C e D sono buchi, dunquei nodi di lista non
possono essere combinati con la sequenza A-B seguente.Perché organizziamo lo spazio in intervalli invece di
appiccicare semplicemente le area di swap e facciamo qualcosa di
più carino? Perché è molto più semplice
allocare strisce lineari di uno spazio di indirizzamento ed ottenere
il risultato già ripartito tra dischi multipli piuttosto che
cercare di spostare questa complicazione altrove.La frammentazione causa altri problemi. Essendoci una lista
lineare nella serie 3.X, ed avendo una tale quantità di
frammentazione implicita, l'allocazione e la liberazione dello swap
finisce per essere un algoritmo O(N) invece di uno O(1).
Combinalo con altri fattori (attività di swap pesante)
e comincerai a trovarti con livelli di overhead come O(N^2) e
O(N^3), e ciò è male. Il sistema dela serie 3.X
può anche avere necessità di allocare KVM durante
un'operazione di swap per creare un nuovo nodo lista, il che
può portare ad un deadlock se il sistema sta cercando di
liberare pagine nella memoria fisica in un momento di
scarsità di memoria.Nella serie 4.X non usiamo una lista sequenziale. Invece usiamo
un albero radicato e mappe di bit di blocchi di swap piuttosto che
nodi lista.
Ci prendiamo il peso di preallocare tutte le mappe di bit richieste
per l'intera area di swap ma ciò finisce per consumare meno
memoria grazie all'uso di una mappa di bit (un bit per blocco)
invece di una lista collegata di nodi. L'uso di un albero radicato
invece di una lista sequenziale ci fornisce una performance quasi
O(1) qualunque sia il livello di frammentazione dell'albero.Non ho capito questo:
È importante notare che il sistema della VM di FreeBSD
tenta di separare pagine pulite e sporche per l'espressa ragione di
evitare scritture non necessarie di pagine sporche (che divorano
banda di I/O), e non sposta le pagine tra le varie code
gratuitamente se il sottosistema non viene stressato. Questo
è il motivo per cui dando un systat -vm
vedrai sistemi con contatori della coda di cache bassi e contatori
della coda delle pagine attive molto alti.
Come entra in relazione la separazione delle pagine pulite e
sporche (inattive) con la situazione nella quale vediamo contatori
bassi per la coda di cache e valori alti per la coda delle pagine
attive in systat -vm? I dati di systat derivano
da una fusione delle pagine attive e sporche per la coda delle
pagine attive?Si, questo può confondere. La relazione è
obiettivo contro realtà. Il
nostro obiettivo è separare le pagine ma la realtà
è che se non siamo in crisi di memoria, non abbiamo bisogno
di farlo.Questo significa che FreeBSD non cercherà troppo di
separare le pagine sporche (coda inattiva) da quelle pulite
(code della cache), ne cercherà di disattivare le pagine
(coda pagine attive -> coda pagine inattive) quando il sistema non
è sotto sforzo, anche se non vengono effettivamente
usate. Nell'esempio di &man.ls.1; / vmstat 1,
alcuni dei page fault non potrebbero essere data page faults
(COW da file eseguibili a pagine private)? Cioè, io mi
aspetterei che i page fault fossero degli zero-fill e dei dati di
programma. O si implica che FreeBSD effettui il pre-COW per i dati
di programma?Un fault COW può essere o legato a uno zero-fill o a dati
di programma.
Il meccanismo è lo stesso in entrambi i casi poiché
i dati di programma da copiare sono quasi certamente già
presenti nella cache. E infatti li tratto insieme. FreeBSD non
effettua preventivamentela copia dei dati di programma o lo
zero-fill, effettua la mappatura preventiva
delle pagine che sono presenti nella sua cache.Nella sezione sull'ottimizzazione della tabella delle pagine,
potresti fornire maggiori dettagli su pv_entry e
vm_page (forse vm_page dovrebbe essere
vm_pmap—come in 4.4, cf. pp. 180-181 di
McKusick, Bostic, Karel, Quarterman)? Specificamente, che tipo di
operazioni/reazioni richiederebbero la scansione delle
mappature?Come funziona Linux nel caso in cui FreeBSD fallisce
(la condivisione di un grosso file mappato tra molti
processi)?Una vm_page rappresenta una tupla
(oggetto,indice#).
Una pv_entry rappresenta una voce nella tabella
delle pagine hardware (pte). Se hai cinque processi che condividono
la stessa pagina fisica, e tre delle tabelle delle pagine di questi
processi mappano effettivamente la pagina, questa pagina
verrà rappresentata da una struttura
vm_page singola e da tre strutture
pv_entry.Le strutture pv_entry rappresentano solo
le pagine mappate dalla MMU (una pv_entry
rappresenta un pte). Ciò significa che è necessario
rimuovere tutti i riferimenti hardware a vm_page
(in modo da poter riutilizzare la pagina per qualcos'altro,
effettuare il page out, ripulirla, sporcarla, e così via)
possiamo semplicemente scansionare la lista collegata di
pv_entry associate con quella
vm_page per rimuovere o modificare i pte
dalla loro tabella delle pagine.Sotto Linux non c'è una lista collegata del genere. Per
poter rimuovere tutte le mappature della tabella delle pagine
hardware per una vm_page linux deve indicizzare
ogni oggetto VM che potrebbe aver mappato la
pagina. Ad esempio, se si hanno 50 processi che mappano la stessa
libreria condivisa e si vuole liberarsi della pagina X in quella
libreria, sarà necessario cercare nella tabella delle pagine
per ognuno dei 50 processi anche se solo 10 di essi ha
effettivamente mappato la pagina. Così Linux sta barattando
la semplicità del design con le prestazioni. Molti algoritmi
per la VM che sono O(1) o (piccolo N) in FreeBSD finiscono per
diventare O(N), O(N^2), o anche peggio in Linux.
Poiché i pte che rappresentano una particolare pagina in un
oggetto tendono ad essere allo stesso offset in tutte le tabelle
delle pagine nelle quali sono mappati, la riduzione del numero di
accessi alla tabela delle pagine allo stesso offset eviterà
che la la linea di cache L1 per quell'offset venga cancellata,
portando ad una performance migliore.FreeBSD ha aggiunto complessità (lo schema
pv_entry) in modo da incrementare le prestazioni
(per limitare gli accessi alla tabella delle pagine
solo a quelle pte che necessitino di essere
modificate).Ma FreeBSD ha un problema di scalabilità che linux non ha
nell'avere un numero limitato di strutture
pv_entry e questo provoca problemi quando si
hanno condivisioni massicce di dati. In questo caso c'è la
possibilità che finiscano le strutture
pv_entry anche se c'è ancora una grande
quantità di memoria disponibile.
Questo può essere risolto abbastanza facilmente
aumentando il numero di struttre pv_entry nella
configurazione del kernel, ma c'è veramente bisogno di
trovare un modo migliore di farlo.Riguardo il sovrapprezzo in memoria di una tabella delle pagine
rispetto allo schema delle pv_entry: Linux usa
tabelle delle pagine permanenti che non vengono
liberate, ma non necessita una pv_entry per ogni
pte potenzialmente mappato.
FreeBSD usa tabelle delle pagine throw away,
eliminabili, ma aggiunge una struttura pv_entry
per ogni pte effettivamente mappato. Credo che l'utilizzo della
memoria finisca per essere più o meno lo stesso, fornendo a
FreeBSD un vantaggio algoritmico con la capacità di
eliminare completamente le tabelle delle pagine con un
sovraccarico prestazionale minimo.Infine, nella sezione sulla colorazione delle pagine, potrebbe
esser d'aiuto avere qualche descrizione in più di quello che
intendi. Non sono riuscito a seguire molto bene.Sai come funziona una memoria cache hardware L1? Spiego:
Considera una macchina con 16MB di memoria principale ma solo 128K
di cache L1. In genere il modo in cui funziona la cache è
che ogni blocco da 128K di memoria principale usa gli
stessi 128K di cache.
Se si accede all'offset 0 della memoria principale e poi al 128K su
può finire per cancellarei dati che si erano messi nella
cache dall'offset 0!Ora, sto semplificando di molto. Ciò che ho appena
descritto è quella che viene detta memoria cache a
corrispondenza diretta, o direct mapped.
La maggior parte delle cache moderne sono quelle che
vengono dette set-associative a 2 o 4 vie.
L'associatività di questo tipo permette di accedere fino ad N
regioni di memoria differenti che si sovrappongano sulla stessa
cache senza distruggere i dati preventivamente immagazzinati.
Ma solo N.Dunque se ho una cache set associativa a 4 vie posso accedere
agli offset 0, 128K, 256K 384K ed essere ancora in grado di
accedere all'offset 0 ritrovandolo nella cache L1. Se poi accedessi
all'offset 512K, ad ogni modo, uno degli oggetti dato immagazzinati
precedentemente verrebbero cancellati dalla cache.È estremamente importante …
estremamente importante che la maggior parte
degli accessi del processore alla memoria vengano dalla cache L1,
poiché la cache L1 opera alla stessa frequenza del
processore. Nel momento in cui si ha un miss Un miss nella cache è equivalente a un page fault per
la memoria fisica, ed allo stesso modo implica un accesso a
dispositivi molto più lenti, da L1 a L2 come da RAM a
disco. nella cache L1 si deveandare a cercare nella cache L2 o
nella memoria principale, il processore andrà in stallo, e
potenzialmente potrà sedersi a girarsi i pollici per un tempo
equivalente a centinaia di istruzioni
attendendo che la lettura dalla memoria principale venga
completata. La memoria principale (la RAM che metti nel tuo
computer) è lenta, se comparata alla
velocità del nucleo di un moderno processore.Ok, ora parliamo della colorazione dele pagine:
tutte le moderne cache sono del tipo noto come cache
fisiche. Esse memorizzano indirizzi di memoria
fisica, non indirizzi di memoria virtual. Ciò permette alla
cache di rimanere anche nel momento in cui ci sia un cambio di
contesto tra processi, e ciò è molto
importante.Ma nel mondo &unix; devi lavorare con spazi di indirizzamento
virtuali, non con spazi di indirizzamento fisici. Ogni programma
che scrivi vedrà lo spazio di indirizzamento virtuale
assegnatogli. Le effettive pagine fisiche
nascoste sotto quello spazio di indirizzi virtuali
non saranno necessariamente contigue fisicamente! In effetti,
potresti avere due pagine affiancate nello spazio di
indirizzamento del processo cge finiscono per trovarsi agli
offset 0 e 128K nella memoria fisica.Un programma normalmente assume che due pagine
affiancate verranno poste in cache in maniera ottimale.
Cioè, che possa accedere agli oggetti dato in
entrambe le pagine senza che esse si cancellino a vicenda le
rispettiva informazioni in cache.
Ma ciò è vero solo se le pagine fisiche sottostanti lo
spazio di indirizzo virtuale sono contigue (per quel che riguarda
la cache).Questo è ciò che viene fatto dalla colorazione
delle pagine.
Invece di assegnare pagine fisiche casuali agli
indirizzi virtuali, che potrebbe causare prestazioni non ottimali
della cache, la colorazione dele pagine assegna pagine fisiche
ragionevolmente contigue.
Dunque i programmi possono essere scritti assumendo che
le caratteristiche per lo spazio di indirizzamento virtuale del
programma della cache hardware sottostante siano uguali a come
sarebbero state se avessero usato lo spazio di indirizzamento
fisico.Si note ho detto ragionevolmente contigue invece
che semplicemente contigue. Dal punto di vista di
una cache di 128K a corrispondenza diretta, l'indirizzo fisico 0
è lo stesso che l'indirizzo fisico 128K.
Dunque due agine affiancate nello spzio di indirizzamento virtuale
potrebbero finire per essere all'offset 128K e al 132K nella memoria
fisica, ma potrebbero trovarsi tranquillamente anche agli offset
128K e 4K della memoria fisica e mantenera comunque le stesse
caratteristiche prestazionali nei riguardi della cache. Dunque la
colorazione delle pagine non deveassegnare
pagine di memoria fisica veramente contigue a pagine di memoria
virtuale contigue, deve solo assicurarsi che siano assegnate pagine
contigue dal punto di vista delle prestazioni/operazioni della
cache.
diff --git a/it_IT.ISO8859-15/books/handbook/Makefile b/it_IT.ISO8859-15/books/handbook/Makefile
index 7585682149..bca164e183 100644
--- a/it_IT.ISO8859-15/books/handbook/Makefile
+++ b/it_IT.ISO8859-15/books/handbook/Makefile
@@ -1,244 +1,244 @@
#
# $FreeBSD$
#
# Crea il Manuale di FreeBSD.
#
# ------------------------------------------------------------------------
#
# Variabili specifiche del Manuale
#
# WITH_PGPKEYS La versione stampata del manuale riporta solo i
# fingerprints PGP di base. Se vuoi visualizzare
# le chiavi intere, allora setta questa variabile.
# Questa opzione non ha effetto sui formati HTML.
#
# Targets specifici del Manuale
#
# pgpkeyring Questo target leggerà il contenuto del file
# pgpkeys/chapter.sgml ad estrarrà tutte le chiavi
# pgp sullo standard output. Questo output può
# quindi essere rediretto su un file e distribuito
# come un keyring pubblico degli sviluppatori di
# FreeBSD che può essere facilmente importato in
# PGP/GPG.
#
# ------------------------------------------------------------------------
-MAINTAINER= sysadmin@alexdupre.com
+MAINTAINER= ale@FreeBSD.org
DOC?= book
FORMATS?= html-split
HAS_INDEX= true
WITH_GLOSSARY?=
INSTALL_COMPRESSED?= gz
INSTALL_ONLY_COMPRESSED?=
IMAGES_EN = advanced-networking/isdn-bus.eps
IMAGES_EN+= advanced-networking/isdn-twisted-pair.eps
IMAGES_EN+= advanced-networking/natd.eps
IMAGES_EN+= advanced-networking/net-routing.pic
IMAGES_EN+= install/adduser1.scr
IMAGES_EN+= install/adduser2.scr
IMAGES_EN+= install/adduser3.scr
IMAGES_EN+= install/boot-mgr.scr
IMAGES_EN+= install/console-saver1.scr
IMAGES_EN+= install/console-saver2.scr
IMAGES_EN+= install/console-saver3.scr
IMAGES_EN+= install/console-saver4.scr
IMAGES_EN+= install/desktop.scr
IMAGES_EN+= install/disklabel-auto.scr
IMAGES_EN+= install/disklabel-ed1.scr
IMAGES_EN+= install/disklabel-ed2.scr
IMAGES_EN+= install/disklabel-fs.scr
IMAGES_EN+= install/disklabel-root1.scr
IMAGES_EN+= install/disklabel-root2.scr
IMAGES_EN+= install/disklabel-root3.scr
IMAGES_EN+= install/disk-layout.eps
IMAGES_EN+= install/dist-set.scr
IMAGES_EN+= install/dist-set2.scr
IMAGES_EN+= install/docmenu1.scr
IMAGES_EN+= install/ed0-conf.scr
IMAGES_EN+= install/ed0-conf2.scr
IMAGES_EN+= install/edit-inetd-conf.scr
IMAGES_EN+= install/example-dir1.eps
IMAGES_EN+= install/example-dir2.eps
IMAGES_EN+= install/example-dir3.eps
IMAGES_EN+= install/example-dir4.eps
IMAGES_EN+= install/example-dir5.eps
IMAGES_EN+= install/fdisk-drive1.scr
IMAGES_EN+= install/fdisk-drive2.scr
IMAGES_EN+= install/fdisk-edit1.scr
IMAGES_EN+= install/fdisk-edit2.scr
IMAGES_EN+= install/ftp-anon1.scr
IMAGES_EN+= install/ftp-anon2.scr
IMAGES_EN+= install/hdwrconf.scr
IMAGES_EN+= install/keymap.scr
IMAGES_EN+= install/main1.scr
IMAGES_EN+= install/mainexit.scr
IMAGES_EN+= install/main-std.scr
IMAGES_EN+= install/main-options.scr
IMAGES_EN+= install/main-doc.scr
IMAGES_EN+= install/main-keymap.scr
IMAGES_EN+= install/media.scr
IMAGES_EN+= install/mouse1.scr
IMAGES_EN+= install/mouse2.scr
IMAGES_EN+= install/mouse3.scr
IMAGES_EN+= install/mouse4.scr
IMAGES_EN+= install/mouse5.scr
IMAGES_EN+= install/mouse6.scr
IMAGES_EN+= install/mta-main.scr
IMAGES_EN+= install/net-config-menu1.scr
IMAGES_EN+= install/net-config-menu2.scr
IMAGES_EN+= install/nfs-server-edit.scr
IMAGES_EN+= install/ntp-config.scr
IMAGES_EN+= install/options.scr
IMAGES_EN+= install/pkg-cat.scr
IMAGES_EN+= install/pkg-confirm.scr
IMAGES_EN+= install/pkg-install.scr
IMAGES_EN+= install/pkg-sel.scr
IMAGES_EN+= install/probstart.scr
IMAGES_EN+= install/routed.scr
IMAGES_EN+= install/security.scr
IMAGES_EN+= install/sysinstall-exit.scr
IMAGES_EN+= install/timezone1.scr
IMAGES_EN+= install/timezone2.scr
IMAGES_EN+= install/timezone3.scr
IMAGES_EN+= install/userconfig.scr
IMAGES_EN+= install/userconfig2.scr
IMAGES_EN+= install/xf86setup.scr
IMAGES_EN+= security/ipsec-crypt-pkt.pic
IMAGES_EN+= security/ipsec-encap-pkt.pic
IMAGES_EN+= security/ipsec-network.pic
IMAGES_EN+= security/ipsec-out-pkt.pic
IMAGES_EN+= vinum/vinum-concat.pic
IMAGES_EN+= vinum/vinum-mirrored-vol.pic
IMAGES_EN+= vinum/vinum-raid10-vol.pic
IMAGES_EN+= vinum/vinum-raid5-org.pic
IMAGES_EN+= vinum/vinum-simple-vol.pic
IMAGES_EN+= vinum/vinum-striped-vol.pic
IMAGES_EN+= vinum/vinum-striped.pic
# Immagini dalla libreria per tutti i documenti
IMAGES_LIB = callouts/1.png
IMAGES_LIB+= callouts/2.png
IMAGES_LIB+= callouts/3.png
IMAGES_LIB+= callouts/4.png
IMAGES_LIB+= callouts/5.png
IMAGES_LIB+= callouts/6.png
IMAGES_LIB+= callouts/7.png
IMAGES_LIB+= callouts/8.png
IMAGES_LIB+= callouts/9.png
IMAGES_LIB+= callouts/10.png
#
# SRCS lista i singoli files SGML che compongono il documento. Modifiche
# a qualunque di questi files obbligano la ricreazione
#
# Contenuto SGML
SRCS = book.sgml
SRCS+= advanced-networking/chapter.sgml
SRCS+= basics/chapter.sgml
SRCS+= bibliography/chapter.sgml
SRCS+= config/chapter.sgml
SRCS+= boot/chapter.sgml
SRCS+= cutting-edge/chapter.sgml
SRCS+= desktop/chapter.sgml
SRCS+= disks/chapter.sgml
SRCS+= eresources/chapter.sgml
SRCS+= install/chapter.sgml
SRCS+= introduction/chapter.sgml
SRCS+= kernelconfig/chapter.sgml
SRCS+= l10n/chapter.sgml
SRCS+= linuxemu/chapter.sgml
SRCS+= mail/chapter.sgml
SRCS+= mirrors/chapter.sgml
SRCS+= multimedia/chapter.sgml
SRCS+= pgpkeys/chapter.sgml
SRCS+= ppp-and-slip/chapter.sgml
SRCS+= printing/chapter.sgml
SRCS+= security/chapter.sgml
SRCS+= serialcomms/chapter.sgml
SRCS+= users/chapter.sgml
SRCS+= vinum/chapter.sgml
SRCS+= x11/chapter.sgml
SRCS+= ports/chapter.sgml
SRCS+= preface/preface.sgml
SRCS+= colophon.sgml
# Entities
SRCS+= chapters.ent
SYMLINKS= ${DESTDIR} index.html handbook.html
# Attiva tutti i capitoli.
CHAPTERS?= ${SRCS:M*chapter.sgml}
SGMLFLAGS+= ${CHAPTERS:S/\/chapter.sgml//:S/^/-i chap./}
.if defined(WITH_GLOSSARY) && !empty(WITH_GLOSSARY)
SGMLFLAGS+= -i chap.freebsd-glossary
.endif
# XXX La creazione del Manuale attualmente sfora dei limiti interni,
# codificati in pdftex. Finché non dividiamo il Manuale, crea la versione
# PDF usando ps2pdf invece di pdftex.
PS2PDF?= ${PREFIX}/bin/ps2pdf
book.tex-pdf:
${TOUCH} book.tex-pdf
book.pdf: book.ps
${PS2PDF} book.ps book.pdf
pgpkeyring: pgpkeys/chapter.sgml
@${JADE} -V nochunks ${JADEOPTS} -d ${DSLPGP} -t sgml ${MASTERDOC}
#
# Variabili specifiche del Manuale
#
.if defined(WITH_PGPKEYS)
JADEFLAGS+= -V withpgpkeys
.endif
DOC_PREFIX?= ${.CURDIR}/../../..
.for p in ftp cvsup
SRCS+= mirrors.sgml.${p}.inc
CLEANFILES+= mirrors.sgml.${p}.inc
CLEANFILES+= mirrors.sgml.${p}.inc.tmp
.endfor
SRCS+= eresources.sgml.www.inc
CLEANFILES+= eresources.sgml.www.inc
CLEANFILES+= eresources.sgml.www.inc.tmp
.include "${DOC_PREFIX}/share/mk/doc.project.mk"
.for p in ftp cvsup
mirrors.sgml.${p}.inc: ${XML_MIRRORS} ${XSL_MIRRORS}
${XSLTPROC} ${XSLTPROCOPTS} \
-o $@.tmp \
--param 'type' "'$p'" \
--param 'proto' "'$p'" \
--param 'target' "'handbook/mirrors/chapter.sgml'" \
${XSL_MIRRORS} ${XML_MIRRORS}
${SED} -e 's,<\([^ >]*\)\([^>]*\)/>,<\1\2>\1>,;s,,,' \
< $@.tmp > $@ || (${RM} -f $@ && false)
${RM} -f $@.tmp
.endfor
eresources.sgml.www.inc: ${XML_MIRRORS} ${XSL_MIRRORS}
${XSLTPROC} ${XSLTPROCOPTS} \
-o $@.tmp \
--param 'type' "'www'" \
--param 'proto' "'http'" \
--param 'target' "'handbook/eresources/chapter.sgml'" \
${XSL_MIRRORS} ${XML_MIRRORS}
${SED} -e 's,<\([^ >]*\)\([^>]*\)/>,<\1\2>\1>,;s,,,' \
< $@.tmp > $@ || (${RM} -f $@ && false)
${RM} -f $@.tmp
diff --git a/it_IT.ISO8859-15/books/handbook/basics/chapter.sgml b/it_IT.ISO8859-15/books/handbook/basics/chapter.sgml
index 2ca360fbd9..1cd600d48b 100644
--- a/it_IT.ISO8859-15/books/handbook/basics/chapter.sgml
+++ b/it_IT.ISO8859-15/books/handbook/basics/chapter.sgml
@@ -1,2731 +1,2731 @@
ChrisShumwayRiscritto da Basi di UnixSinossibasiIl seguente capitolo tratta i comandi e le funzionalità di
base del sistema operativo FreeBSD. Molto di questo materiale è
valido anche per altri sistemi operativi &unix;-like. Sentiti libero di
leggere velocemente questo capitolo se hai familiarità con questo
materiale. Se sei un utente alle prime armi di FreeBSD, allora dovrai di
sicuro leggere questo capitolo attentamente.Dopo aver letto questo capitolo, saprai:Come usare le console virtuali di FreeBSD.Come funzionano i permessi dei file &unix;.La struttura di default del file system di &os;.L'organizzazione del disco di &os;.Come montare e smontare i file system.Cosa sono i processi, i demoni e i segnali.Cos'è una shell, e come cambiare il proprio ambiente di
login di default.I principi di base sull'uso degli editor testuali.Cosa sono i dispositivi e i nodi dei dispositivi.Quali formati dei binari sono usati in &os;.Come leggere le pagine man per ottenere maggiori
informazioni.Console Virtuali e Terminaliconsole virtualiterminaliFreeBSD può essere usato in vari modi. Uno di questi è
quello di digitare i comandi tramite un terminale testuale. Quando si
utilizza FreeBSD in questo modo si ha velocemente nelle proprie mani molta
della flessibilità e della potenza di un sistema operativo &unix;.
Questa sezione descrive cosa sono i terminali e le
console, e come si possono utilizzare in FreeBSD.La consoleconsoleSe non hai configurato FreeBSD in modo tale da avviare in modo
automatico l'ambiente grafico durante l'avvio, il sistema ti
fornirà un prompt di login dopo la fase di avvio, esattamente
dopo che gli script di avvio sono stati eseguiti. Dovresti vedere
qualcosa simile a questo:Additional ABI support:.
Local package initialization:.
Additional TCP options:.
Fri Sep 20 13:01:06 EEST 2002
FreeBSD/i386 (pc3.example.org) (ttyv0)
login:I messaggi potrebbero essere leggermente diversi sul tuo sistema,
tuttavia dovresti vedere qualcosa di analogo. In questo momento ci
interessano le ultime due righe. Analizziamo la penultima riga:FreeBSD/i386 (pc3.example.org) (ttyv0)Questa riga contiene alcune informazioni sul sistema che hai appena
avviato. Sei di fronte a una console FreeBSD, che sta
girando su un processore Intel o su un processore compatibile con
l'architettura x86Questo è il significato di i386.
Nota che anche se non stai eseguendo FreeBSD su una CPU della serie
386 di Intel, questo messaggio resta i386. Non
si riferisce al tipo del tuo processore, ma bensì
all'architettura del processore..
Il nome di questa macchina (tutte le macchine &unix; hanno un nome)
è pc3.example.org, e in questo momento sei di
fronte alla sua console di sistema—il terminale
ttyv0.Infine, l'ultima riga è sempre:login:Qui devi digitare il tuo username per loggarti in
FreeBSD. La prossima sezione descrive come fare ad effettuare il login
su FreeBSD.Loggarsi in FreeBSDFreeBSD è un sistema multi-utente e multi-processo. Questa
è la descrizione formale che viene usualmente attribuita a un
sistema che può essere usato da diverse persone, le quali
eseguono contemporaneamente molti programmi su una singola
macchina.Ogni sistema multi-utente necessita di qualche metodo che distingua
un utente in modo univoco. In FreeBSD (e in tutti i
sistemi operativi &unix;-like), questo viene realizzato richiedendo che
ogni utente debba loggarsi nel sistema prima che possa
eseguire qualche programma. Ogni utente ha un nome univoco (lo
username), uno personale e una chiave segreta (la
password). FreeBSD richiede entrambe queste due cose
prima di dare la possibilità ad un utente di eseguire qualche
programma.script di avvioGiusto dopo la fase di avvio di FreeBSD e quando gli script di avvio
sono stati eseguitiGli script di avvio sono programmi che vengono eseguiti in modo
automatico durante la fase di avvio di FreeBSD. Il loro compito
principale è quello di settare delle cose che potranno essere
utilizzate da qualsiasi altra cosa venga eseguita, ed avviare i
servizi che potresti avere configurato in modo tale da essere
eseguiti in background per realizzare cose utili., ti viene presentato un prompt dove inserire un valido
username:login:Giusto per questo esempio, assumiamo che il tuo username sia
john. Al prompt digita john e
premi Invio. Ti verrà presentato un prompt
dove inserire la password:login: john
Password:Digita la password di john, e premi
Invio. La password non viene
visualizzata! Non ti devi preoccupare di questo per ora.
È sufficiente sapere che è una questione di
sicurezza.Se hai digitato la tua password in modo corretto, dovresti essere
loggato in FreeBSD e sei quindi pronto per provare tutti i comandi
disponibili.Dovresti inoltre vedere il messaggio del giorno
(MOTD) seguito da un prompt dei comandi (un
carattere #, $, o
%). Ciò
indica che sei a tutti gli effetti loggato in FreeBSD.Console MultipleEseguire comandi &unix; in una sola console va bene, tuttavia
FreeBSD può eseguire più programmi alla volta. Avere una
sola console dove poter digitare i comandi può essere un
pò uno spreco quando un sistema operativo come FreeBSD è
in grado di eseguire dozzine di programmi contemporaneamente. È
in questo caso che le console virtuali possono essere
molto utili.FreeBSD può essere configurato in modo tale da poter
utilizzare differenti console virtuali. Puoi passare da una console
virtuale ad un'altra digitando un paio di tasti sulla tastiera. Ogni
console ha il proprio canale di output indipendente, e FreeBSD si
occupa di redirigere correttamente l'input della tastiera e l'output del
monitor quando passi da una console virtuale in un'altra.In FreeBSD alcune combinazioni speciali di tasti sono state
riservate per il passaggio tra le consoleUna descrizione abbastanza tecnica ed accurata di tutti i
dettagli della console di FreeBSD e dei driver della tastiera
può essere trovata nelle pagine man di &man.syscons.4;,
&man.atkbd.4;, &man.vidcontrol.1; e &man.kbdcontrol.1;. Qui non
approfondiremo i dettagli, ma il lettore interessato può
sempre consultare le pagine man per una spiegazione dettagliata
e completa su come funzionano queste cose.. Puoi usare
AltF1,
AltF2, fino a
AltF8 per
cambiare console su FreeBSD.Quando passi da una console ad un'altra, FreeBSD si preoccupa di
salvare e ripristinare l'output a video. Il risultato è
l'illusione di avere più schermi e più
tastiere virtuali che puoi utilizzare per dare in pasto a
FreeBSD dei comandi. I programmi che lanci su una console virtuale
rimarranno in esecuzione anche quando la console non è visibile.
L'esecuzione di questi programmi continua quando passi in un'altra
console virtuale.Il File /etc/ttysLa configurazione di default di FreeBSD prevede l'avvio del sistema
con otto console virtuali. Comunque questo non è un settaggio
obbligatorio, e puoi facilmente personalizzare la tua installazione in
modo tale da avviare il sistema con qualche console virtuale in
più. Il numero e i settaggi delle console virtuali sono
configurati nel file /etc/ttys.Puoi usare il file /etc/ttys per configurare
le console virtuali di FreeBSD. In questo file ogni riga non commentata
(le righe che non iniziano con il carattere #)
contiene i settaggi di un singolo terminale o di una singola console
virtuale. La versione di default di questo file contenuta in FreeBSD
configura nove console virtuale, e ne abilita otto di queste. Si tratta
delle righe che iniziano con ttyv:# name getty type status comments
#
ttyv0 "/usr/libexec/getty Pc" cons25 on secure
# Terminali virtuali
ttyv1 "/usr/libexec/getty Pc" cons25 on secure
ttyv2 "/usr/libexec/getty Pc" cons25 on secure
ttyv3 "/usr/libexec/getty Pc" cons25 on secure
ttyv4 "/usr/libexec/getty Pc" cons25 on secure
ttyv5 "/usr/libexec/getty Pc" cons25 on secure
ttyv6 "/usr/libexec/getty Pc" cons25 on secure
ttyv7 "/usr/libexec/getty Pc" cons25 on secure
ttyv8 "/usr/X11R6/bin/xdm -nodaemon" xterm off securePer una descrizione più dettagliata su ogni colonna di questo
file e per tutte le opzioni che puoi utilizzare per settare le console
virtuali, consulta la pagina man &man.ttys.5;.Console in Modalità Single UserUna descrizione dettagliata del significato della
modalità single user può essere trovata
nella . È bene notare che
c'è un'unica console quando avvii FreeBSD in modalità
single user. Le console virtuali non sono disponibili. Anche i
settaggi della console in modalità single user possono essere
trovati nel file /etc/ttys. Guarda la riga che
inizia con console:# name getty type status comments
#
# Se la console è definita "insecure", allora il processo init richiederà la password di root
# quando entrerai in modalità single-user.
console none unknown off secureCome riportato nel commento sopra la riga
console, puoi modificare questa riga cambiando
secure in insecure. Se lo fai,
quando FreeBSD viene avviato in modalità single user,
verrà chiesta la password di root.Pensaci comunque due volte a settare il parametro
insecure. Se non ricordi più
la password di root, riuscire ad avviare il
sistema in modalità single user sarà molto complesso.
È ancora possibile, ma potrebbe essere molto difficile per chi
non conosce molto bene il meccanismo di avvio di FreeBSD e i relativi
programmi.I PermessiUNIXFreeBSD, essendo un discendente diretto dello &unix; BSD, si basa su
molti concetti chiave di &unix;. Il primo e il più affermato
è che FreeBSD è un sistema operativo multi-utente.
Il sistema può gestire diversi utenti che lavorano
contemporaneamente su lavori indipendenti. Il sistema è
responsabile della gestione e della suddivisione appropiata delle
richieste di utilizzo dei dispositivi hardware, delle periferiche, della
memoria, e del tempo di CPU in modo equo per ogni utente.Poichè il sistema è in grado di supportare più
utenti, tutto ciò che il sistema gestisce possiede un'insieme di
permessi che determinano chi può leggere, scrivere, ed eseguire la
risorsa. Questi permessi sono memorizzati mediante tre ottetti
suddivisi in tre parti, una per il proprietario del file, una per il
gruppo al quale il file appartiene, e una per tutti gli altri. Questa
rappresentazione numerica funziona in questo modo:permessipermessi dei fileValorePermessiListato nella Directory0Lettura no, scrittura no, esecuzione no---1Lettura no, scrittura no, esecuzione--x2Lettura no, scrittura, esecuzione no-w-3Lettura no, scrittura, esecuzione-wx4Lettura, scrittura no, esecuzione nor--5Lettura, scrittura no, esecuzioner-x6Lettura, scrittura, esecuzione norw-7Lettura, scrittura, esecuzionerwxlsdirectoryPuoi usare l'opzione del comando &man.ls.1; per
visualizzare un lungo listato della directory che include una colonna
contenente le informazioni sui permessi del file per il proprietario, per
il gruppo, e per gli altri. Per esempio, digitando ls
-l in una arbitraria directory:&prompt.user; ls -l
total 530
-rw-r--r-- 1 root wheel 512 Sep 5 12:31 myfile
-rw-r--r-- 1 root wheel 512 Sep 5 12:31 otherfile
-rw-r--r-- 1 root wheel 7680 Sep 5 12:31 email.txt
...Ecco come è suddivisa la prima colonna dell'output del comando
ls -l:-rw-r--r--Il primo carattere (partendo da sinistra) indica se il file in
questione è un file regolare, una directory, un file speciale per
dispositivi a caratteri, una socket, o un file speciale per altri
dispositivi. Nel nostro caso, il - indica un
file regolare. I tre caratteri successivi, che in questo esempio sono
rw-, indicano i permessi per il proprietario del file.
Seguono altri tre caratteri, r--, che indicano i
permessi del gruppo al quale il file appartiene. Gli ultimi tre
caratteri, r--, indicano i permessi per il resto del
mondo. Un trattino significa che il permesso non viene concesso.
Nel caso di questo file, i permessi sono settati affinchè il
proprietario possa leggere e scrivere il file, il gruppo possa leggere
il file, e il resto del mondo possa solamente leggere il file. In accordo
con la precedente tabella, i permessi per questo file sono
644, dove ogni cifra rappresenta una delle tre parti
che costituiscono i permessi del file.D'accordo, ma il sistema come controlla i permessi sui dispositivi?
FreeBSD tratta molti dispositivi hardware esattamente come un file che i
programmi possono aprire, leggere, e scrivere dei dati proprio come
avviene con gli altri file. Questi file speciali per i dispositivi sono
memorizzati nella directory /dev.Anche le directory sono trattate come file. Queste hanno permessi di
lettura, scrittura e di esecuzione. Il bit riferito al permesso di
esecuzione per una directory ha un significato leggermente differente
rispetto a quello dei file. Quando una directory ha il permesso di
esecuzione abilitato, significa che si ha accesso alla directory, ossia
è possibile eseguire il comando cd (cambio di
directory) per entrarci. Inoltre questo significa che all'interno della
directory è possibile accedere ai file dei quali si conosce il nome
(naturalmente a condizione dei permessi degli stessi file).In particolare, per visualizzare il contenuto di una directory, deve
essere abilitato il permesso di lettura sulla stessa, mentre per
eliminare un file di cui si conosce il nome, è necessario che la
directory contenente il file abbia i permessi di scrittura
e di esecuzione abilitati.Ci sono altri bit per permessi particolari, ma sono in genere usati
in circostanze speciali come il permesso di setuid per i binari e
quello di sticky per le directory. Se vuoi avere più informazioni
sui permessi dei file e su come settarli, guarda la pagina man di
&man.chmod.1;.TomRhodesContributo di Permessi SimboliciPermessisimboliciI permessi simbolici, qualche volta chiamati espressioni simboliche,
usano caratteri al posto dei numeri ottali per assegnare i permessi a
file o directory. Le espressioni simboliche usano la sintassi (chi)
(azione) (permessi), con i seguenti valori:OpzioneLetteraCosa rappresenta/Cosa fa(chi)uUtente(chi)gGruppo di appartenenza(chi)oAltri(chi)aTutti (tutto il mondo)(azione)+Aggiunge i permessi(azione)-Rimuove i permessi(azione)=Setta esplicitamente i permessi(permessi)rLettura(permessi)wScrittura(permessi)xEsecuzione(permessi)tBit sticky(permessi)sSetta UID o GIDQuesti valori sono usati con il comando &man.chmod.1;
in modo simile a prima, ma con le lettere. Per esempio, puoi usare il
seguente comando per impedire agli altri utenti l'accesso a
FILE:&prompt.user; chmod go= FILESe si ha la necessità di realizzare più di una
modifica ai settaggi di un file si può usare una lista di
settaggi separati da virgola. Per esempio il seguente comando
rimuoverà il permesso di scrittura su
FILE al gruppo di appartenenza del file e al
resto del mondo, e inoltre aggiungerà
il permesso di esecuzione per tutti:&prompt.user; chmod go-w,a+x FILEStruttura delle Directorygerarchia delle directoryLa gerarchia delle directory di FreeBSD è fondamentale per
ottenere una comprensione globale del sistema. Il concetto più
importante da cogliere al volo è quello relativo alla directory
root, /. Questa directory è la prima ad essere
montata all'avvio e contiene gli elementi fondamentali del sistema
necessari per predisporre il sistema operativo al funzionamento
multi-utente. Inoltre la directory root contiene i punti di mount per
gli altri file system che potresti voler montare.Un punto di mount è una directory dove dei file system
aggiuntivi possono essere innestati sul file system root. Alcuni punti di
mount standard sono /usr, /var,
/mnt, e /cdrom. Queste
directory compaiono in genere negli elementi del file
/etc/fstab. Il file /etc/fstab
è una tabella di file system e punti di mount che viene consultata
dal sistema. Molti dei file system riferiti nel file
/etc/fstab sono montati in modo automatico all'avvio
tramite lo script &man.rc.8; a meno che essi sia stati dichiarati con
l'opzione . Consulta la pagina man di
&man.fstab.5; per maggiori informazioni sul formato del file
/etc/fstab e per le opzioni che può
contenere.Una descrizione completa della gerarchia del file system è
disponibile nella pagina man &man.hier.7;. Per ora, è
sufficiente una breve panoramica generale delle directory più
comuni.DirectoryDescrizione/Directory root del file system./bin/Utilità fondamentali per l'utente sia in ambiente
mono-utente sia in ambiente multi-utente./boot/Programmi e file di configurazione utilizzati durante la
fase di avvio del sistema operativo./boot/defaults/File di configurazione di avvio di default; consultare
&man.loader.conf.5;./dev/Nodi di dispositivo; consultare &man.intro.4;./etc/Script e file di configurazione del sistema./etc/defaults/File di configurazione di default del sistema; consultare
&man.rc.8;./etc/mail/File di configurazione per gli MTA (Mail Transfer Agent,
agente di trasferimento della posta elettronica) come
&man.sendmail.8;./etc/namedb/File di configurazione di named;
consultare &man.named.8;./etc/periodic/Script che sono eseguiti giornalmente, settimanalmente, e
mensilmente tramite &man.cron.8;; consultare
&man.periodic.8;./etc/ppp/File di configurazione di ppp;
consultare &man.ppp.8;./mnt/Directory vuota usata comunemente dagli amministratori di
sistema come punto di mount temporaneo./proc/File system dedicato ai processi; consultare
&man.procfs.5;, &man.mount.procfs.8;./root/Directory home per l'account
root./sbin/Programmi di sistema e utilità di amministrazione
fondamentali sia in ambiente mono-utente sia in ambiente
multi-utente./stand/Programmi usati in un ambiente standalone./tmp/File temporanei, di solito un file system basato sulla
memoria come &man.mfs.8; (generalmente il contenuto di /tmp non viene preservato dopo
un reboot del sistema)./usr/La maggior parte delle applicazioni e delle utilità
dell'utente./usr/bin/Utilità, strumenti di programmazione, e
applicazioni comuni./usr/include/File include standard del C./usr/lib/Archivio di librerie./usr/libdata/Archivio di dati per utilità varie./usr/libexec/Demoni & utilità di sistema (eseguiti da altri
programmi)./usr/local/Eseguibili locali, librerie locali, ecc. Usata anche
come destinazione di default per la struttura dei port di
FreeBSD. All'interno di /usr/local, viene
usato lo stesso schema generale descritto in &man.hier.7; per la
directory /usr. Le eccezioni sono la
directory man, che è posta direttamente sotto
/usr/local piuttosto che sotto
/usr/local/share, e la documentazione dei
port che è in
share/doc/port.
/usr/obj/Albero degli elementi dipendenti dal tipo di architettura
dell'elaboratore prodotto dalla costruzione dell'albero
/usr/src./usr/portsCollezione dei port di FreeBSD (opzionale)./usr/sbin/Demoni & utilità di sistema (eseguiti dagli
utenti)./usr/share/File indipendenti dal tipo di architettura
dell'elaboratore./usr/src/File sorgenti di BSD e/o sorgenti proprietari./usr/X11R6/Eseguibili, librerie, ecc. riguardanti la distribuzione
X11R6 (opzionale)./var/File log di vario genere, file temporanei, file transitori,
e file di spool./var/log/File di log del sistema di vario genere./var/mail/File delle caselle di posta degli utenti./var/spool/Directory di spool per stampanti e per la posta elettronica
del sistema./var/tmp/File temporanei che sono mantenuti tra i reboot del
sistema./var/ypMappe NIS.Organizzazione del DiscoLa più piccola unità di organizzazione che FreeBSD usa
per ricercare file è il nome del file. I nomi dei file sono
case-sensitive, ciò significa che readme.txt
e README.TXT sono due file distinti. FreeBSD non usa
l'estensione (es. .txt) di un file per determinare
se il file è un programma, un documento, o qualche altra forma di
dati.I file sono memorizzati in directory. Una directory può
contenere centinaia di file o non contenerne affatto. Inoltre una
directory può contenere altre directory, consentendo di costruire
una gerarchia di directory all'interno di un'altra. Tutto questo rende
più facile l'organizzazione dei tuoi dati.File e directory sono riferiti attraverso il nome del file o della
directory, seguito da uno slash in avanti, /,
a sua volta seguito da altri nomi di directory che sono necessari. Se
hai una directory di nome foo, la quale contiene la
directory bar, che a sua volta contiene il file
readme.txt, allora il nome completo, chiamato anche
il path del file è
foo/bar/readme.txt.Le directory e i file sono memorizzati in un filesystem. Ogni
filesystem contiene esattamente una directory al livello più alto,
chiamata la directory root di quel filesystem.
Questa directory root può contenere altre directory.Fin qui è probabilmente tutto simile ad altri sistemi
operativi che hai usato. Tuttavia ci sono alcune differenze; per
esempio, il &ms-dos; usa il carattere \ per separare i
nomi di file e directory, mentre &macos; usa :.FreeBSD non usa lettere di dispositivi, o altri nomi di dispositivi
nel path. In FreeBSD non dovrai mai scrivere
c:/foo/bar/readme.txt.Piuttosto, un filesystem è designato come il
filesystem root. La directory root del
filesystem root è riferita con /. Ogni altro
filesystem è montato sotto il filesystem
root. Non importa quanti dischi hai sul tuo sistema FreeBSD, ogni
directory è come se fosse parte dello stesso disco.Supponiamo che tu abbia tre filesystem, chiamati
A, B, e C.
Ogni filesystem ha una directory root, la quale contiene altre due
directory, chiamate A1, A2 (e
nello stesso modo B1, B2 e
C1, C2).Sia A il filesystem root. Se usi il comando
ls per visualizzare il contenuto di questa directory
dovresti vedere due sottodirectory, A1 e
A2. L'albero delle directory assomiglia a
questo: /
|
+--- A1
|
`--- A2Un filesystem deve essere montato su una directory di un altro
filesystem. Supponiamo ora che tu monti il filesystem
B sulla directory A1. La directory
root di B rimpiazza A1, e di
conseguenza appariranno le directory di B: /
|
+--- A1
| |
| +--- B1
| |
| `--- B2
|
`--- A2I file contenuti nelle directory B1 o
B2 possono essere raggiunti con il path
/A1/B1 o /A1/B2. I file che
erano in /A1 sono stati temporaneamente nascosti.
Questi riappariranno quando B sarà
smontato da A.Se B è stato montato su
A2 allora il diagramma assomiglierà a
questo: /
|
+--- A1
|
`--- A2
|
+--- B1
|
`--- B2e i path saranno rispettivamente /A2/B1 e
/A2/B2.I filesystem possono essere montati in cima ad altri filesystem.
Continuando con l'ultimo esempio, il filesystem C
può essere montato in cima alla directory B1
nel filesystem B, arrivando a questa
sistemazione: /
|
+--- A1
|
`--- A2
|
+--- B1
| |
| +--- C1
| |
| `--- C2
|
`--- B2Oppure C potrebbe essere montato direttamente sul
filesystem A, sotto la directory
A1: /
|
+--- A1
| |
| +--- C1
| |
| `--- C2
|
`--- A2
|
+--- B1
|
`--- B2Se hai familiarità con &ms-dos;, questo è simile, man
non identico, al comando join.Di solito non ti devi occupare direttamente di questi aspetti.
Tipicamente quando installi FreeBSD crei i filesystem e decidi dove
montarli, e da quel momento non avrai più la necessità di
modificarli a meno che installi un nuovo disco.È possibile avere un unico filesystem root, senza avere la
necessità di crearne altri. Esistono alcuni svantaggi
utilizzando questo approccio, e un solo vantaggio.Benefici con Filesystem MultipliFilesystem diversi possono avere opzioni di
mount diverse. Per esempio, in una attenta progettazione,
il filesystem root potrebbe essere montato in modalità di sola
lettura, rendendo impossibile la cancellazione accidentale o la modifica
di un file critico. Inoltre, separando i filesystem scrivibili
dall'utente, come /home, da altri filesystem
permette di montare i primi con l'opzione nosuid;
questa opzione non permette il settaggio dei bit
suid/guid sui file
eseguibili memorizzati sul filesystem che ha tale opzione di mount
attivata, migliorando l'aspetto sicurezza.FreeBSD ottimizza in modo automatico la disposizione dei file sul
filesystem, a seconda di come è usato il filesystem. Quindi
un filesystem che contiene molti file piccoli che sono scritti di
frequente avrà un'ottimizzazione diversa rispetto ad un altro
filesystem che contiene pochi file di grandi dimensioni. Utilizzando
un solo grande filesystem questa ottimizzazione viene a
mancare.I filesystem di FreeBSD reagiscono bene ad una violenta perdita di
energia elettrica. Tuttavia, una perdita di energia in un punto
critico potrebbe sempre danneggiare la struttura del filesystem.
Splittando i tuoi dati su filesystem multipli sarà più
probabile che il sistema riparta, dandoti la possibilità di
ripristinare un precedente backup se necessario.Benefici di un Filesystem SingoloI filesystem sono a dimensione fissa. Se crei un solo filesystem
quando installi FreeBSD e gli assegni una data dimensione, in futuro
potresti scoprire che necessiti di creare una partizione più
grande. Questo non è facilmente realizzabile se non
effettuando un backup dei dati, ricreando il filesystem con la nuova
dimensione, e quindi ripristinando il backup di dati.FreeBSD 4.4 e successivi hanno il comando &man.growfs.8;,
con il quale è possibile incrementare la dimensione del
filesystem al volo, rimuovendo questa limitazione.I filesystem sono contenuti all'interno di partizioni. Qui il
significato del termine partizione si discosta dall'uso comune di questo
termine (partizioni &ms-dos;, per esempio), a causa dell'eredità
&unix; di &os;. Ogni partizione è identificata da una lettera
partendo dalla a fino alla h. Ogni
partizione può contenere solo un filesystem, il che significa che i
filesystem sono spesso identificati sia dal loro punto di mount nella
gerarchia del filesystem, sia dalla lettera della partizione nella quale
sono contenuti.Inoltre FreeBSD usa parte del disco per lo spazio di
swap. Lo spazio di swap fornisce a FreeBSD la
funzionalità di memoria virtuale. Questo
permette al tuo computer di comportarsi come se avesse più memoria
di quella che ha realmente. Quando FreeBSD esaurisce la memoria muove
alcuni dati presenti in memoria che non sono utilizzati in quel momento
nello spazio di swap, e li riporta in memoria (spostando nello spazio di
swap qualche altro dato) non appena necessari.Alcune partizioni hanno certe convenzioni a loro associate.PartizioneConvenzioneaIn genere contiene il filesystem rootbIn genere contiene lo spazio di swapcDi solito rappresenta l'intera dimensione della slice.
Questo permette a utility che necessitano di lavorare sull'intera
slice (per esempio, uno scanner di blocchi difettosi) di lavorare
sulla partizione c. Di norma non dovresti
creare un filesystem su questa partizione.dLa partizione d era utilizzata in passato
con un significato speciale, sebbene ora non sia più
utilizzata. Ai giorni d'oggi, alcuni strumenti operano in modo
starno se gli si dice di lavorare sulla partizione
d, e per questo motivo
sysinstall di norma non la
crea.Ogni partizione-che-contiene-un-filesystem è memorizzata in
ciò che FreeBSD chiama slice. Slice
è un termine di FreeBSD per identificare ciò che comunemente
viene chiamato partizione, e di nuovo, questo è dovuto dal
background &unix; di FreeBSD. Le slices sono numerate, partendo da 1 e
arrivando fino a 4.slicepartizionipericolosamente dedicateI numeri di slice seguono il nome del dispositivo, preceduti da una
s, e partendo da 1. Quindi
da0s1 è la prima slice sul
primo disco SCSI. Ci possono essere solo quattro slice fisiche su un
disco, ma puoi avere slice logiche all'interno di slice fisiche di un
appropriato tipo. Queste slice estese sono numerate a partire da 5,
quindi ad0s5 è la prima
slice estesa sul primo disco IDE. Questi stratagemmi sono usati per i
filesystem che si aspettano di occupare una slice.Le slice, i dispositivi fisici pericolosamente
dedicati, e altri dispositivi contengono
partizioni, le quali sono rappresentate tramite
lettere dalla a fino alla h. Queste
lettere seguono il nome del dispositivo, quindi
da0a è la partizione a
sul primo dispositivo da, il quale è pericolosamente
dedicato. ad1s3e è
la quinta partizione nel terza slice del secondo disco IDE.In fine, ogni disco sul sistema è identificato. Un nome di un
disco incomincia con un codice che indica il tipo di disco, seguito da un
numero, che indica quale disco esso sia. A differenza delle slice,
i numeri riferiti al disco incominciano da 0. Puoi vedere dei codici
generici in .Quando fai riferimento a una partizione di FreeBSD devi specificare
anche il nome della slice e del disco che contengono la partizione, e
quando fai riferimento a una slice dovresti specificare anche il nome del
disco. Specifica quindi il nome del disco, il carattere
s, il numero di slice, e infine la lettera della
partizione. Alcuni esempi sono mostrati nell'.L' mostra un modello
concettuale di struttura di un disco che dovrebbe aiutare a chiare le
cose.Per installare FreeBSD devi prima configurare le slice del disco,
creare le partizioni all'interno della slice che vuoi usare per FreeBSD,
e quindi creare un filesystem (o spazio di swap) in ogni partizione, e
decidere dove il filesystem deve essere montato.
Codici dei Dispositivi DiscoCodiceSignificatoaddisco ATAPI (IDE)dadisco ad accesso diretto SCSIacdCDROM ATAPI (IDE)cdCDROM SCSIfdDisco floppy