<!doctype linuxdoc system>


<ARTICLE opts="italian">


<TITLE>From Power Up To Bash Prompt
<AUTHOR>Greg O'Keefe, <tt>gcokeefe@postoffice.utas.edu.au</tt>
<DATE>v0.9, novembre 2000

<ABSTRACT>
Questa è una breve descrizione di quello che succede in un sistema 
Linux, dal momento in cui accendete il computer, a quello in cui 
vi accreditate sul sistema e vi viene presentato il prompt della shell 
bash. Capirlo vi sarà di grande aiuto quando dovrete risolvere dei 
problemi, o configurare il vostro sistema.
Traduzione di Luca Ferraro (<tt>lferraro@NOSPAM.caspur.it</tt>, 
Dicembre 2004).
Revisione di Antonio "bombadur" Bracaglia 
(<tt>bombadur@slacky.it</tt>, Febbraio 2005).
</ABSTRACT>


<TOC>



<SECT>Introduzione
<P>
Trovo frustrante che all'interno della mia macchina Linux avvengano
delle cose che non comprendo.
Se, come me, volete veramente conoscere il vostro sistema invece di
saperlo solamente usare, questo documento dovrebbe essere un buon punto 
di partenza.
Questo tipo di conoscenze di basso livello è necessario se volete 
diventare dei veri esperti nel risolvere i problemi di Linux.

<P>
Darò per scontato che abbiate un sistema Linux funzionante e una
conoscenza basilare di Unix e dell'hardware di un PC. Se così non fosse, 
un documento eccellente per iniziare ad imparare è quello di Eric S. 
Raymond, 
<URL
URL="http://www.linuxdoc.org/HOWTO/Unix-and-Internet-Fundamentals-HOWTO.html"
NAME ="The Unix and Internet Fundamentals HOWTO" > 
È breve, facilmente comprensibile, e copre tutte le basi.

<P>
L'argomento principale di questo documento è come fa Linux ad avviarsi.
Ma cerca anche di essere una risorsa più generale di apprendimento. 
Per ciascuna sezione ho inserito degli esercizi. Se ne farete qualcuno, 
imparerete molto più di quanto fareste solamente leggendo.

<P>
Spero che alcuni lettori si cimenteranno nell'esercizio migliore che io 
conosca per Linux, ossia quello di costruirsi un sistema a partire 
dal codice sorgente. Giambattista Vico, filosofo italiano (1668 - 1744), 
disse "verum ipsum factum", che significa "la comprensione viene 
attraverso le azioni". 
Ringrazio Alex (vedi <REF ID="acknowledge" NAME="Acknowledgements">) per 
questa citazione.

<P>
Se volete farvelo da soli (NdT: l'espressione originale inglese era 
``roll your own'', come le sigarette arrotolate a mano), dovreste 
leggervi l'HOWTO di Gerard Beekmans, 
<URL URL="http://www.linuxfromscratch.org" NAME="Linux From Scratch HOWTO"> 
(LFS). LFS contiene istruzioni dettagliate sulla cotruzione di un 
sistema operativo Linux usabile e completo a partire dal codice sorgente. 
Sul sito di LFS troverete anche una mailing list per le persone che
stanno creando il proprio sistema operativo in questo modo.
Le istruzioni a riguardo che facevano parte di questo documento si 
trovano ora in un documento separato "Building a Minimal Linux System 
from Source Code", che potete trovare su 
<URL URL="http://www.netspace.net.au/~gok/power2bash/" 
	NAME="From PowerUp to Bash Prompt home page">.
Spiegano come ``giocare'' con il sistema, puramente a scopo educativo.

<P>
I pacchetti vengono presentati nell'ordine in cui compaiono durante il 
processo di avvio del sistema. Questo significa che se installate i 
pacchetti in questo ordine, potrete riavviare dopo ciascuna 
installazione, e vedere come ogni volta il sistema si avvicina sempre 
più al prompt finale della shell. Trovo un rassicurante senso di
avanzamento in questo.

<P>
Vi consiglio di leggere prima il testo principale di ogni sezione, 
saltando la parte degli esercizi e dei riferimenti. Successivamente 
scegliete a quale profondità di comprensione volete arrivare, e quanti 
sforzi siete disposti a fare. Quindi ricominciate a leggere dall'inizio, 
eseguendo gli esercizi e leggendo i documenti aggiuntivi man mano che
procedete. 



<SECT>L'Hardware

<P>
Quando accendete il computer, questo esegue una sorta di auto-verifica 
per controllare che tutto funzioni correttamente. Questa fase viene 
chiamata "auto-verifica di accensione" (dall'inglese "Power on self 
test"). A questo punto, un programma chiamato "bootstrap loader", che 
risiede nella memoria ROM del BIOS, cerca un settore di avvio (boot 
sector). Il settore di avvio è il primo settore di un disco, che 
contiene un piccolo programma capace di avviare un sistema operativo. 
I settori di avvio vengono marcati con il numero magico 0xAA55 = 43603 
al byte 0x1FE = 510. Questo corrisponde agli ultimi due byte del 
settore. È in questo modo che l'hardware è in grado di riconoscere se
un settore è di avvio oppure no.

<P>
Il bootstrap loader ha una lista di luoghi in cui cercare i possibili 
settori di avvio. Il mio vecchio computer cerca nel primo floppy drive e
quindi nell'hard disk primario. I computer più moderni possono cercare
un settore di avvio anche sul CD-ROM (NdT: recentemente anche tramite
rete o dispositivi esterni come memory card o penne USB). Se trova un 
settore di avvio, lo carica in memoria e passa il controllo al programma 
in esso contenuto, che a sua volta carica il sistema operativo. 
In un tipico sistema Linux, questo programma corrisponde probabilmente 
alla prima parte del boot loader LILO (NdT: o di GRUB). Esistono diversi 
modi di configurare l'avvio del vostro sistema. Date uno sguardo al 
documento <EM>LILO User's Guide</EM> per maggiori dettagli, e alla 
sezione <REF ID="lilo-links" NAME="LILO"> per dei rimandi sull'argomento.

<P>
Ovviamente ci sarebbe molto altro da dire su quello che fa l'hardware di 
un PC. Ma questo non è il posto adatto per dirlo. Leggetevi magari uno 
dei numerosi libri sull'hardware dei PC.

<SECT1>Configurazione
<P>
Il computer immagazzina alcune informazioni su se stesso nella sua CMOS. 
Queste informazioni comprendono ad esempio il tipo di hard disk e di RAM 
presenti nel sistema. Il BIOS del computer contiene un programma che 
permette di modificare queste impostazioni. Per capire come accedervi, 
controllate i messaggi che compaiono sullo schermo quando accendete il 
computer. Sul mio computer, bisogna premere il tasto Canc prima che 
inizi ad avviarsi il sistema operativo.

<SECT1>Esercizi
<LABEL ID="hardware-ex">
<P>
Un ottimo modo per imparare a conoscere l'hardware di un PC è quello di 
costruirsi una macchina da soli con dei pezzi di seconda mano. 
Procuratevi un processore, almeno un 386, così da poter poi eseguire un 
sistema Linux agevolmente. Non vi costerà molto. 
Chiedete in giro, qualcuno potrebbe darvi alcuni dei pezzi di cui avrete 
bisogno.

<P>
Scaricate e compilate il programma  
<URL URL="http://www.netspace.net.au/~gok/resources" NAME=Unios>
(avevano una homepage su <URL URL="http://www.unios.org">, ma è 
scomparsa) e fatevi con questo un dischetto di avvio. Si tratta
semplicemente del programma tipo "Ciao mondo!" avviabile, che consiste
soltanto di un centinaio di righe di codice assembly. Sarebbe bene 
vederle convertite in un formato comprensibile dal compilatore assembler 
GNU.

<P>
Aprite l'immagine del dischetto di avvio di unios con un editor 
esadecimale. Questa immagine è grande 512 byte, ossia esattamente un 
settore. Individuate il numero magico 0xAA55. Fate lo stesso con il 
settore di boot di un dischetto avviabile del vostro computer. 
Potete utilizzare il comando <TT>dd </TT> per copiarlo su un file:
<TT>dd if=/dev/fd0 of=myboot.sector</TT>.
Fate <EM>molta</EM> attenzione a come usate <TT>if</TT> (file di input) 
e <TT>of</TT> (file di output).
<P>
Date uno sguardo al codice sorgente del boot loader LILO.

<SECT1>Maggiori Informazioni
<P>
<ITEMIZE>
<ITEM>
<URL URL="http://www.linuxdoc.org/HOWTO/Unix-and-Internet-Fundamentals-HOWTO.html" 
	NAME="The Unix and Internet Fundamentals HOWTO">
di Eric S. Raymond, in particolare la sezione numero 3, 
<EM>What happens when you switch on a computer?</EM>

<ITEM>Il primo capitolo della guida  <EM>The LILO User's Guide</EM> 
fornisce un'eccellente spiegazione sulle partizioni dei dischi e sul 
processo di avvio di un PC. Vedete la sezione 
<REF ID="lilo-links" NAME="LILO"> per un link.

<ITEM><EM>The NEW Peter Norton Programmer's Guide to the IBM PC & PS/2</EM>, 
di Peter Norton e Richard Wilton, Microsoft Press 1988 
Esiste un libro di Norton più recente, che sembra buono, ma non posso 
permettermelo al momento!

<ITEM> Uno dei molti libri disponibili sull'aggiornamento di un PC.
</ITEMIZE>



<SECT>Lilo
<P>
Quando il computer carica il settore di boot su un normale sistema 
operativo Linux, quello che carica effettivamente è una parte di LILO, 
detta la "prima parte del boot loader" (NdT: "first stage boot loader"). 
Questo è un piccolo programma il cui unico scopo nella vita è quello di 
caricare ed avviare la "seconda parte del boot loader" (NdT: "second
stage boot loader").

<P>
La seconda parte del boot loader vi fornisce un prompt (se installato in
modo tale da farlo) e carica il sistema operativo che avrete scelto.

<P>
Quando il vostro sistema è attivo e in uso, se eseguite il comando 
<TT>lilo</TT>, quello che di fatto mandate in esecuzione è 
l'installatore di mappa (NdT: map installer). Questo legge il file di 
configurazione <TT>/etc/lilo.conf</TT> e scrive sull'hard disk il boot 
loader e le informazioni sui sistemi operativi che possono venire
avviati. 

<P>
Esistono molti modi diversi di configurare l'avvio del vostro sistema. 
Quello che vi ho appena illustrato è il più ovvio e "normale", se non 
altro per un computer il cui sistema operativo principale è Linux. La 
Guida Utente di LILO (NdT: LILO Users' Guide) tratta vari esempi di 
avvio. Sarebbe bene leggerli e provarne alcuni.

<SECT1>Configurazione
<P>
Il file di configurazione di lilo è <TT>/etc/lilo.conf</TT>. C'è una 
pagina di manuale per questo file: digitate <TT>man lilo.conf</TT> in 
una shell per leggerlo. La parte principale del file <TT>lilo.conf</TT> 
consiste in una voce per ogni sistema che lilo deve avviare. Una voce 
per Linux deve includere la posizione del kernel, e quale partizione del 
disco deve essere montata come filesystem radice. Per gli altri sistemi 
operativi, l'informazione principale è la partizione da cui eseguire 
l'avvio.

<SECT1>Esercizi
<P>
<EM>ATTENZIONE:</EM> fate molta attenzione con questi esercizi. È
piuttosto facile che qualcosa vada storto e che venga compromesso il
vostro master boot record, rendendo il vostro sistema inutilizzabile.
Assicuratevi di avere un disco di recupero funzionante, e di sapere come 
utilizzarlo per rimettere le cose a posto.  
Vedete sotto per un link a tomsrtbt, il disco di recupero che uso e vi 
raccomando. La migliore precauzione è quella di utilizzare una macchina 
di cui non vi importa molto. 

<P>
Installate lilo su un dischetto. Non importa se nel floppy ci sarà solo 
il kernel - incorrerete in un ``kernel panic'' quando il kernel tenterà 
di avviare init, ma almeno saprete che lilo sta funzionando.

<P>
Se vi piace, potete provare ad andare avanti a stiparvi del materiale, e 
vedere quanto del sistema operativo riuscite a mettere sul floppy. 
Questa è sicuramente la seconda miglior maniera per imparare qualcosa su 
Linux. Vedete il Bootdisk HOWTO (l'url è riportata più sotto), e tomsrtbt 
(url più sotto) per alcuni suggerimenti utili.

<P>
Provate a configurare lilo per avviare unios (vedete la sezione 
<REF ID="hardware-ex" NAME="hardware exercises">). Come ulteriore 
esercizio, provate a farlo da un dischetto.

<P>
Create un ciclo di boot (NdT: boot-loop): configurate lilo nel master 
boot record in modo tale che avvii lilo da uno dei settori di boot delle 
partizioni primarie, e configurate quest'ultimo in modo tale da avviare 
quello nel master boot record... Oppure usate il master boot record e 
tutte e quattro le partizioni primarie per creare un ciclo a cinque 
punti. Divertente!

<SECT1>Maggiori Informazioni
<P>
<LABEL ID="lilo-links">
<ITEMIZE>
<ITEM>La pagina man di lilo.
<ITEM>Il pacchetto LILO
	(<URL URL="ftp://lrcftp.epfl.ch/pub/linux/local/lilo/" NAME="lilo">),
	contiene la ``LILO User's Guide'' 
	<TT>lilo-u-21.ps.gz</TT> (o superiore).
	Potreste già avere questo documento installato.
	Controllate in <TT>/usr/doc/lilo</TT>, o comunque in quella zona 
        del filesystem.	La versione postscript è migliore di quella in 
        testo semplice, perché contiene diagrammi e tabelle.
<ITEM><URL URL="http://www.toms.net/rb" NAME="tomsrtbt"> il miglior 
	floppy Linux esistente. Un potente strumento di recupero.
<ITEM><URL URL="http://www.linuxdoc.org/HOWTO/Bootdisk-HOWTO/"
	 NAME="The Bootdisk HOWTO"> 
</ITEMIZE>



<SECT>Il Kernel Linux 
<P>
Il kernel assume molti compiti. Credo che un modo semplice per 
riassumerli sia quello di dire che esso fa in modo che l'hardware 
soddisfi tutte le richieste dei programmi, in modo semplice ed 
efficiente.

<P>
Il processore può eseguire solo un'istruzione alla volta, ma i sistemi 
Linux sembrano far girare molte cose contemporaneamente. Il kernel 
riesce a fare questo passando molto velocemente da un task ad un altro. 
Riesce a fare il miglior uso del processore, tenendo traccia dei
processi che sono pronti per essere eseguiti, e di quelli invece che 
sono in attesa di qualcosa, come un record da un file sull'hard disk o 
di un input dalla tastiera. Questa attività del kernel è chiamata 
scheduling.

<P>
Se un programma non sta facendo nulla, allora non è necessario che 
risieda nella RAM. Anche se un programma sta facendo qualcosa, potrebbe 
avere delle parti che non stanno facendo nulla. Lo spazio degli 
indirizzi di memoria di ciascun processo viene diviso in pagine. Il 
kernel tiene traccia delle pagine di cui i processi stanno facendo
maggiore uso. Le pagine che non vengono utilizzate con frequenza possono 
venire spostate nella partizione di swap. Quando saranno nuovamente 
necessarie, un'altra pagina non utilizzata potrà essere spostata per
fare lo spazio. Questa è la gestione della memoria virtuale.

<P>
Se avete compilato qualche volta il vostro kernel, avrete notato che 
esistono moltissime opzioni per specifici dispositivi. Il kernel 
contiene una grande quantità di codice specifico per comunicare con 
diverse tipologie di hardware, e presentarle ai programmi applicativi 
in modo semplice e uniforme.

<P>
Il kernel inoltre gestisce il filesystem, le comunicazioni tra i 
processi e diverso materiale riguardante il il networking.

<P>
Una volta che il kernel è stato caricato, la prima cosa che fa è quella
di cercare un programma <TT>init</TT> da eseguire.

<SECT1>Configurazione

<P>
La maggior parte della configurazione del kernel viene fatta durante la
sua compilazione, utilizzando il comando <TT>make menuconfig</TT>, o 
<TT>make xconfig</TT> da dentro la directory <TT>/usr/src/linux/</TT> 
(o comunque dalla directory contenente i sorgenti del kernel Linux).
Potete riconfigurare i valori della modalità video predefinita, il 
filesystem radice, il dispositivo di swap, e la dimensione del disco 
RAM, tramite il comando <TT>rdev</TT>. (NdT: dalla versione 0.95 del
kernel Linux il comando<TT>rdev -s</TT> per l'indicazione delle
partizioni di swap non è più valido, in quanto l'attivazione dello swap 
viene effettuato tramite la chiamata di sistema <TT>swapon()</TT>). 
Questi parametri e altri ancora possono essere passati al kernel 
attraverso lilo. Potete fornire a lilo i parametri da passare al kernel 
o dal file di configurazione lilo.conf, o direttamente dal prompt di 
lilo. Per esempio, se voleste utilizzare hda3 come filesystem radice al 
posto di hda2, potreste digitare il comando

<VERB>
	LILO: linux root=/dev/hda3
</VERB>

<P>
Se state costruendo un sistema dai sorgenti, potete rendervi la vita 
molto più semplice se create un kernel ``monolitico''. Ossia senza 
moduli. A questo punto non avrete bisogno di copiare i moduli del kernel 
sul sistema per cui è stato compilato.

<P>
NOTA: il file <TT>System.map</TT> viene utilizzato dal logger del 
kernel per determinare i nomi dei moduli che generano messaggi. Anche il 
programma <TT>top</TT> utilizza queste informazioni. Quando copiate il 
kernel sul nuovo sistema, copiate anche il file <TT>System.map</TT>.

<SECT1>Esercizi
<P>Riflettete su questo: <TT>/dev/hda3</TT> è un file speciale che 
descrive una partizione dell'hard disk. Ma risiede su un filesystem, 
proprio come tutti gli altri file. Il kernel vuole sapere quale 
partizione deve montare come filesystem radice - ma questa non ha ancora
un filesystem. Allora, come può leggere <TT>/dev/hda3</TT> per sapere
quale partizione montare?

<P>
Se non lo avete ancora fatto: compilatevi un kernel. Leggete tutta la 
documentazione di aiuto per ciascuna opzione.

<P>
Vedete quanto piccolo riuscite a compilare un kernel che ancora
funzioni. Potrete imparare molto se lascerete fuori le cose sbagliate!

<P>
Leggete ``The Linux Kernel'' (vedi l'indirizzo URL più sotto) e, 
mentre lo leggete, individuate le parti di codice sorgente a cui fa 
riferimento. Il libro (come ho detto) si riferisce alla versione 2.0.33 
del kernel, che è piuttosto vecchia. Potrebbe essere più semplice da 
seguire se scaricaste questa vecchia versione del kernel ed esaminaste 
quel codice sorgente. Trovo sia entusiasmante trovare pezzi di codice C 
chiamati ``processo'' e ``pagina''.

<P>
Hack! Vedete se riuscite a farvi sputare fuori qualche messaggio extra 
o cose simili.


<SECT1>Maggiori Informazioni
<LABEL ID="Kernel">
<P>
<ITEMIZE>
<ITEM><TT>/usr/src/linux/README</TT> ed i contenuti di
	<TT>/usr/src/linux/Documentation/</TT> 
	(Questi potrebbero trovarsi da qualche altra parte sul vostro 
        sistema).
<ITEM> <URL URL="http://mirror.aarnet.edu.au/linux/LDP/HOWTO/Kernel-HOWTO.html"
	 NAME="The Kernel HOWTO"> 
<ITEM> Le spiegazioni di aiuto disponibili quando configurate il kernel 
       tramite <TT>make menuconfig</TT> o <TT>make xconfig</TT> 
<ITEM> <URL URL="http://mirror.aarnet.edu.au/linux/LDP/LDP/" 
	NAME="The Linux Kernel (and other LDP Guides)">
<ITEM>  il codice sorgente, vedete
	<URL URL="http://www.netspace.net.au/~gok/power2bash" 
	NAME="Building a Minimal Linux System from Source Code"> 
	per i link.
</ITEMIZE>


<SECT>La libreria GNU C
<P>
Il passo successivo all'accensione del computer consiste nel caricamento
e nella esecuzione di init. Comunque, init, come la maggior parte dei 
programmi, utilizza delle funzioni di libreria. 

<P>
Potreste aver già visto un esempio di programma C come questo:

<P>
<VERB>
	main() {
        	printf("Hello World!\n");
	}
</VERB>

Il programma non contiene nessuna definizione della funzione 
<TT>printf</TT>, e quindi da dove salta fuori? Questa proviene dalle
librerie standard C che, su un sistema GNU/Linux, si chiamano glibc. Se 
compilate il programma sotto Visual C++, allora quella funzione viene da
una implementazione Microsoft delle stesse funzioni standard. Esistono 
milioni di queste funzioni standard, per matematica, stringhe, 
allocazione di memoria per data e ora, e così via. Qualsiasi cosa in 
Unix (incluso Linux) è stata scritta scritta in C, perciò ogni 
applicazione utilizza queste funzioni.

<P>	
Se guardate nella directory <TT>/lib</TT> del vostro sistema Linux 
troverete molti file chiamati <TT>libqualcosa.so</TT> o 
<TT>libqualcosa.a</TT>, ecc. Sono le librerie di queste funzioni. Glibc 
è esattamente l'implementazione GNU di queste funzioni.

<P>
Ci sono due modi in cui i programmi possono utilizzare queste le
funzioni di libreria. Se linkate il programma in modo <EM>statico</EM>, 
queste funzioni di libreria verranno copiate dentro l'eseguibile che 
viene creato. Le librerie <TT>libqualcosa.a</TT> servono a questo. Se 
invece linkate il programma in modo <EM>dinamico</EM> (e questa è la 
modalità predefinita), quando il programma sarà in esecuzione e avrà 
bisogno del codice della libreria, questo verrà chiamato dal file 
<TT>libqualcosa.so</TT>.


<P>
Il comando <TT>ldd</TT> farà al caso vostro quando vorrete sapere quali 
librerie sono necessarie ad un particolare programma. Per esempio, ecco 
le librerie utilizzate da <TT>bash</TT>:

<P>
<VERB>
	[greg@Curry power2bash]$ ldd /bin/bash
        	libtermcap.so.2 => /lib/libtermcap.so.2 (0x40019000)
        	libc.so.6 => /lib/libc.so.6 (0x4001d000)
        	/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
</VERB>

<SECT1>Configurazione
<P>
Alcune funzioni delle librerie dipendono dal posto in cui vivete. Per 
esempio, in Australia scriviamo le date nel formato dd/mm/yy 
(NdT: giorno/mese/anno, come in Italia), ma in America viene usato il 
formato mm/dd/yy. Esiste un programma che viene fornito con le 
<TT>glibc</TT>, chiamato <TT>localedef</TT>, che consente di configurare 
le localizzazioni.

<SECT1>Esercizi
<P>
Usate <TT>ldd</TT> per scoprire quali librerie utilizzano le vostre 
applicazioni preferite.

<P>
Usate <TT>ldd</TT> per scoprire quali librerie sono utilizzate da 
<TT>init</TT>.

<P>
Createvi una libreria giocattolo, con una o due funzioni. Per crearla
utilizzate il programma <TT>ar</TT>. La pagina di manuale di <TT>ar</TT> 
può essere un buon punto di inizio per capire come fare. Scrivete, 
compilate e linkate un programma che faccia uso di questa vostra 
libreria.



<SECT1>Maggiori Informazioni
<P>
<ITEMIZE>
<ITEM>  il codice sorgente, vedete
	<URL URL="http://www.netspace.net.au/~gok/power2bash" 
	NAME="Building a Minimal Linux System from Source Code"> 
	per ulteriori link
</ITEMIZE>



<SECT>Init
<P>
Parlerò solamente dello stile ``System V'' di init, utilizzato dalla
maggior parte dei sistemi Linux. Esistono anche altre alternative. 
Infatti, potete mettere qualsiasi programma vogliate in 
<TT>/sbin/init</TT>, e il kernel lo eseguirà non appena avrà terminato la 
sua fase di caricamento.

<P>
È compito di <TT>init</TT> mandare in esecuzione qualsiasi cosa nel
modo corretto. <TT>init</TT> verifica che i filesystem siano a posto e li 
monta. Avvia i "demoni" per registrare i messaggi di sistema, gestisce
le funzionalità di rete, rende disponibili le pagine web, gestisce il
vostro mouse, e così via. Avvia anche i processi getty che fanno 
comparire il prompt di login sui vostri terminali virtuali.

<P>
Dovrei anche parlare di una faccenda piuttosto complessa riguardo 
al passaggio tra i vari ``run-levels'', ma la salterò quasi del tutto e 
vi parlerò piuttosto di come si avvia il sistema.

<P>
Init legge il file <TT>/etc/inittab</TT> che gli dice cosa fare.
La prima cosa che di solito viene richiesta è quella di eseguire uno 
script di inizializzazione. Il programma che esegue (o interpreta) 
questo script è <TT>bash</TT>, lo stesso programma che vi fornisce un 
prompt dei comandi.
Nei sistemi Debian, lo script di inizializzazione è 
<TT>/etc/init.d/rcS</TT>, mentre in Red Hat, è 
<TT>/etc/rc.d/rc.sysinit</TT>. 
In questo script vengono verificati e montati i filesystem, viene 
impostato l'orologio di sistema, abilitato lo spazio di swap, il nome 
dell'host, ecc. 

<P>
Successivamente, viene chiamato un altro script che ci porta al 
run-level predefinito. Questo significa un gruppo di sottosistemi da
avviare. 
Esistono una serie di directory <TT>/etc/rc.d/rc0.d</TT>, 
<TT>/etc/rc.d/rc1.d</TT>, ..., <TT>/etc/rc.d/rc6.d</TT> in Red Hat, o
<TT>/etc/rc0.d</TT>, <TT>/etc/rc1.d</TT>, ..., <TT>/etc/rc6.d</TT> in 
Debian, che corrispondono ai vari run-level. Se stiamo entrando nel 
run-level 3 di un sistema Debian, allora lo script eseguirà tutti gli 
script presenti nella directory <TT>/etc/rc3.d</TT> i cui nomi inizino 
per `S' (S sta per start). Questi script in realtà sono soltanto dei 
link simbolici a degli script che si trovano in un'altra directory, 
generalmente chiamata <TT>init.d</TT>. 

<P>
Quindi, il nostro script di run-level è stato chiamato da <TT>init</TT> 
e ora sta cercando all'interno di una directory tutti gli script che 
cominciano per `S'. Potrebbe trovare <TT>S10syslog</TT> per primo. Il 
numero dice allo script di run-level in quale ordine questi devono 
venire eseguiti. Perciò in questo caso, dal momento che non ci sono 
altri script che cominciano per S00 ... S09, <TT>S10syslog</TT> viene 
eseguito per primo. Ma <TT>S10syslog</TT> è in realtà un link a 
<TT>/etc/init.d/syslog</TT>, uno script per avviare o fermare il logger 
di sistema. Dato che il link comincia per `S', lo script di run-level 
sa che dovrà eseguire lo script  <TT>syslog</TT> con il parametro 
``start''. Esistono anche i corrispettivi link che cominciano per `K' (K
sta per kill), che specificano quali servizi fermare e in quale ordine, 
quando viene lasciato un certo run-level.

<P>
Per scegliere quali sottosistemi (servizi) far partire in modo
predefinito, dovrete impostare questi collegamenti nella directory 
<TT>rcN.d</TT>, dove per N si intende il runlevel predefinito, 
configurato nel vostro <TT>inittab</TT>.

<P>
L'ultima cosa importante che fa init è far partire alcune sessioni del
programma <TT>getty</TT>. Questi sono di tipo ``respawned'', che 
significa che se si fermano, <TT>init</TT> li fa partire nuovamente. La 
maggior parte delle distribuzioni vengono configurate con sei terminali 
virtuali. Potreste volerne di meno per risparmiare memoria, o di più in 
modo da mandare in esecuzione più cose, e passare rapidamente da una 
all'altra a seconda delle vostre necessità.
Potreste anche voler eseguire <TT>getty</TT> per un terminale testuale o 
per un modem. In tal caso dovrete modificare il file <TT>inittab</TT>.


<SECT1>Configurazione
<P>
Il file <TT>/etc/inittab</TT> rappresenta il vertice della configurazione 
di init.

<P>
Le directory <TT>rcN.d</TT>, dove N = 0, 1, ..., 6 determinano quali 
sottosistemi vengono avviati.

<P>
Da qualche parte, in uno degli script richiamati da init, verrà dato il 
comando <TT>mount -a</TT>. Questo significa montare tutti i filesystem 
che si suppone debbano venire montati. Il file <TT>/etc/fstab</TT> 
definisce quali filesystem il sistema deve montare. Se volete modificare
quello che viene montato quando il il sistema viene avviato, questo è il 
file che dovrete editare. Esiste anche una pagina di manuale per 
<TT>fstab</TT>.

<SECT1>Esercizi
<P>
Individuate la directory <TT>rcN.d</TT> del run-level predefinito del
vostro sistema ed eseguite un <TT>ls -l</TT> per vedere a cosa puntano
link in essa presenti.

<P>
Cambiate il numero di sessioni getty che vengono eseguite sul vostro 
sistema.

<P>
Eliminate ogni servizio di cui non avete bisogno dal vostro run-level
predefinito.

<P>
Provate a verificare il numero minimo di servizi con cui riuscite a
partire.

<P>
Create un dischetto con lilo, un kernel e un programma "ciao mondo!" 
compilato staticamente, chiamato <TT>/sbin/init</TT> e osservate se si
avvia ed emette il messaggio di saluto.

<P>
Osservate attentamente l'avvio del vostro sistema, e prendete nota di 
tutto ciò che si sta verificando. Oppure stampate una porzione del file 
di log di sistema <TT>/var/log/messages</TT> dal momento dell'avvio. A 
questo punto, partendo da <TT>inittab</TT>, seguite tutti gli script e 
cercate di capire ogni parte del codice, e che cosa fa. Potete anche 
inserire dei messaggi extra, come ad esempio 

<VERB>
	echo "Ciao, io sono il file rc.sysinit"
</VERB>

Questo è un buon esercizio per imparare anche il linguaggio di scripting 
della shell Bash, visto che alcuni di questi script sono piuttosto 
complicati. Procuratevi una buona guida di Bash da tenere sottomano.

<SECT1>Maggiori Informazioni

<P>
<ITEMIZE>
<ITEM>Esistono le pagine di manuale per i file <TT>inittab</TT> e <TT>fstab</TT>. 
	Digitate ad esempio <TT>man inittab</TT> in una shell per vederlo.
<ITEM>The Linux System Administrators Guide contiene una buona 
    pagina <URL URL="http://mirror.aarnet.edu.au/linux/LDP/LDP/" 
	NAME="section"> su init.
<ITEM>  il codice sorgente, vedete
	<URL URL="http://www.netspace.net.au/~gok/power2bash" 
	NAME="Building a Minimal Linux System from Source Code"> 
        per ulteriori link
</ITEMIZE>
</P>

<SECT>Il Filesystem
<P>
In questa sezione, utilizzerò la parola ``filesystem'' in due differenti 
accezioni. Una riferendomi ai filesystem delle partizioni del disco o di 
altre periferiche, l'altra riferita al filesystem che vi viene
presentato da un sistema Linux in esecuzione. In Linux, infatti, voi 
``montate'' il filesystem di un disco all'interno del filesystem di 
sistema.

<P>
Nella sezione precedente ho detto che gli script di avvio verificano e
montano i filesystem. I comandi a cui vengono affidati questi compiti
sono rispettivamente <TT>fsck</TT> e <TT>mount</TT>.

<P>
L'hard disk può essere visto come un grande spazio su cui potete 
scrivere tanti 1 e 0. Un filesystem impone su di esso una struttura, e 
fa in modo che i file vengano visualizzati all'interno di directory 
dentro altre directory... Ogni file viene rappresentato da un inode, che 
definisce il file a cui fa riferimento, quando è stato creato e dove si 
trova il suo contenuto. Anche le directory vengono rappresentate dagli 
inode, ma questi dicono piuttosto dove trovare gli inode dei file in 
esse contenuti. Se il sistema vuole leggere il file 
<TT>/home/greg/bigboobs.jpeg</TT>, prima trova l'inode della directory 
radice <TT>/</TT> nel ``superblocco'', poi troverà l'inode per la 
directory <TT>home</TT> tra quelli contenuti in <TT>/</TT>, quindi 
l'inode per la directory <TT>greg</TT> tra quelli contenuti in 
<TT>/home</TT>, e infine l'inode per <TT>bigboobs.jpeg</TT>, che indica
quali blocchi del disco devono essere letti.


<P>
Se aggiungiamo dei dati alla fine di un file, potrebbe accadere che 
questi dati vengano scritti prima che l'inode sia aggiornato in modo da 
sapere che i nuovi blocchi appartengono al file, o viceversa. Se venisse
a mancare la corrente in questo momento, il filesystem risulterebbe
corrotto. Ed è proprio questo genere di cose che <TT>fsck</TT> tenta di 
verificare e riparare.

<P>
Il comando <TT>mount</TT> prende il filesystem di un dispositivo, e lo
innesta nella gerarchia che vedete quando usate il vostro sistema. 
Generalmente, il kernel monta la radice del proprio filesystem in 
modalità di sola lettura. Il comando <TT>mount</TT> viene utilizzato per 
rimontarlo in modalità di lettura e scrittura dopo che <TT>fsck</TT> 
abbia verificato che tutto sia in ordine.

<P>
Linux supporta anche altri tipi di filesystem: msdos, vfat, minix, e 
così via. Le caratteristiche di ogni filesystem vengono descritte in 
modo astratto attraverso il file system virtuale (VFS). Ma su questo
argomento non entrerò nei dettagli. Potete trovarne una trattazione su 
``The Linux Kernel'' (vedete la sessione 
<REF ID="Kernel" NAME="The Linux Kernel"> per la URL).

<P>
Un tipo di filesystem completamente differente viene montato su 
<TT>/proc</TT>. Questo contiene una rappresentazione di quello che 
accade nel kernel. Qui esiste una directory per ogni processo che si
trova in esecuzione sul sistema, con il numero del processo come nome
per la directory. Sono presenti anche dei file come <TT>interrupts</TT> 
o <TT>meminfo</TT>, che vi informano sul modo in cui viene utilizzato 
l'hardware. Potete imparare molto esplorando <TT>/proc</TT>.

<SECT1>Configurazione
<P>
Sono presenti dei parametri per il comando<TT>mke2fs</TT>, che crea un 
filesystem ext2. Questi controllano la dimensione dei blocchi, il numero 
di inode, e così via. Controllate la pagina di manuale di 
<TT>mke2fs</TT> per maggiori dettagli.

<P>
Ciò che viene montato, e dove, sul vostro filesystem, viene controllato 
dal file <TT>/etc/fstab</TT>. Anche per questo esiste una pagina di
manuale.

<SECT1>Esercizi
<P>
Create un piccolissimo filesystem, e guardatelo attraverso un editor 
esadecimale. Identificate gli inode, i superblocchi e i file in esso 
contenuti.

<P>
Sono sicuro che esistono degli strumenti che vi possano fornire una 
rappresentazione grafica del filesystem. Trovatene uno, provatelo e 
mandatemi una email con una bella recensione!

<P>
Leggete il codice del filesystem ext2 nel Kernel.

<SECT1>Maggiori Informazioni
<P>
<ITEMIZE>
<ITEM>Il capitolo 9 del libro LDP ``The Linux Kernel'' contiene una 
        eccellente descrizione dei filesystem. Potete trovarlo nel sito 
        australiano di LDP
	<URL URL="http://mirror.aarnet.edu.au/linux/LDP/LDP/" 
	NAME="mirror">
<ITEM>Il comando <TT>mount</TT> fa parte del pacchetto util-linux, di 
        cui trovate un link su 
	<URL URL="http://www.netspace.net.au/~gok/power2bash" 
	NAME="Building a Minimal Linux System from Source Code"> 
<ITEM>Le pagine man per <TT>mount</TT>, <TT>fstab</TT>, <TT>fsck</TT>, 
        <TT>mke2fs</TT> e <TT>proc</TT>
<ITEM>Il file <TT>Documentation/proc.txt</TT> nella directory dei 
        sorgenti del Kernel Linux illustra il filesystem <TT>/proc</TT>.
<ITEM>EXT2 File System Utilities
	<URL URL="http://web.mit.edu/tytso/www/linux/e2fsprogs.html"
	NAME="ext2fsprogs"> home page
	<URL URL="ftp://mirror.aarnet.edu.au/pub/linux/metalab/system/filesystems/ext2/"
	NAME="ext2fsprogs"> Mirror Australiano. Qui trovate anche un
        documento su Ext2fs, sebbene un po' datato, e non così leggibile 
        come il capitolo 9 di ``The Linux Kernel''.
<ITEM>  <LABEL ID="FHS">
	<URL URL="ftp://tsx-11.mit.edu/pub/linux/docs/linux-standards/fsstnd/" 
	NAME="Unix File System Standard"> 
	Un altro link <URL URL="http://www.pathname.com/fhs/" 
	NAME="link"> allo Unix File System Standard.
        Descrive cosa dovrebbe andare, e dove, in un filesystem Unix, e 
        perché. Contiene anche i requisiti minimi per i contenuti di 
	<TT>/bin</TT>, <TT>/sbin</TT> e così via. Questo è un buon 
        riferimento se il vostro obiettivo è quello di creare un sistema 
        minimo ma completo.
</ITEMIZE>



<SECT>I Demoni del Kernel
<P>
Se eseguite il comando<TT>ps aux</TT>, vedrete probabilmente qualcosa di
simile: 

<P>
<VERB>
USER       PID %CPU %MEM  SIZE   RSS TTY STAT START   TIME COMMAND
root         1  0.1  8.0  1284   536   ? S    07:37   0:04 init [2] 
root         2  0.0  0.0     0     0   ? SW   07:37   0:00 (kflushd)
root         3  0.0  0.0     0     0   ? SW   07:37   0:00 (kupdate)
root         4  0.0  0.0     0     0   ? SW   07:37   0:00 (kpiod)
root         5  0.0  0.0     0     0   ? SW   07:37   0:00 (kswapd)
root        52  0.0 10.7  1552   716   ? S    07:38   0:01 syslogd -m 0 
root        54  0.0  7.1  1276   480   ? S    07:38   0:00 klogd 
root        56  0.3 17.3  2232  1156   1 S    07:38   0:13 -bash 
root        57  0.0  7.1  1272   480   2 S    07:38   0:01 /sbin/agetty 38400 tt
root        64  0.1  7.2  1272   484  S1 S    08:16   0:01 /sbin/agetty -L ttyS1
root        70  0.0 10.6  1472   708   1 R   Sep 11   0:01 ps aux 
</VERB>

<P>
Questa è una lista dei processi in esecuzione sul sistema. Le 
informazioni provengono dal filesystem <TT>/proc</TT> che ho descritto 
nella sezione precedente.

Notate che <TT>init</TT> è il processo numero uno. I process 2, 3, 4 e 5 
sono kflushd, kupdate, kpiod e kswapd. C'è tuttavia qualcosa di strano: 
notate che in entrambe le colonne del Virtual Storage Size (SIZE) e del 
Real Storage Size (RSS), questi processi hanno valori nulli. Come può un 
processo non utilizzare memoria? 

<P>
Questi processi sono i demoni del kernel. La maggior parte dei kernel
non mostra affatto una lista dei processi attivi, e potete capire quanta 
memoria questi stanno utilizzando solamente sottraendo la memoria 
disponibile da quella totale del sistema. I demoni del kernel vengono 
avviati dopo init, e quindi prendono un numero di processo come fanno 
tutti gli altri processi. Ma il loro codice ed i loro dati risiedono 
nella parte di memoria riservata al kernel.

<P>
Intorno alle voci della colonna dei comandi ci sono le parentesi 
perché il filesystem <TT>/proc</TT> non contiene informazioni sulla 
linea di comando per questi processi.

<P>
Ma allora a cosa servono questi demoni del kernel?
Versioni precedenti di questo documento riportavano una richiesta di 
aiuto per questo paragrafo, dal momento che non sapevo molto sui demoni 
del kernel. La storia parziale che segue è stata realizzata combinando 
le diverse risposte a questa richiesta, per le quali sono veramente 
grato. Maggiori informazioni, riferimenti e correzioni sono benvenute!

<P>
L'input e l'output viene realizzato tramite i <em>buffer</em> in 
memoria. Questo consente di far eseguire le cose più velocemente. Quello 
che i programmi scrivono può essere tenuto in memoria, in un buffer, e
quindi scritto su blocchi di disco in modo molto più efficiente. I 
demoni <TT>kflushd</TT> e <TT>kupdate</TT> hanno questo compito: 
<TT>kupdate</TT> viene eseguito periodicamente (5 secondi?) per 
verificare se vi siano dei buffer utilizzati. Se ci sono, richiama 
<TT>kflushd</TT> per riversarli sul disco.

<P>
Spesso i processi non hanno nulla da fare, e spesso, quelli in 
esecuzione non hanno bisogno di tenere in memoria tutto il loro codice
ed i loro dati. Questo significa che possiamo fare un utilizzo migliore 
della memoria, spostando le porzioni inutilizzate dei programmi sulla(e)
partizione(i) di swap dell'hard disk.
Il trasferimento di questi dati da e verso la memoria a seconda della
necessità viene gestito di demoni <TT>kpiod</TT> e <TT>kswapd</TT>. Ogni 
secondo circa, <TT>kswapd</TT> si attiva e verifica lo stato della 
memoria e, se qualcosa che era stato portato sul disco diventa 
necessario alla memoria, o se non c'è memoria libera a sufficienza, 
viene attivato <TT>kpiod</TT>.

<P>
Sul vostro sistema potrebbe essere in esecuzione anche il demone 
<TT>kapmd</TT>, se avete configurato il kernel con la gestione
automatica dell'energia.

<P>
<SECT1>Configurazione
<P>
Il programma <TT>update</TT> vi consente di configurare <TT>kflushd</TT> 
e <TT>kswapd</TT>. Provate il comando <TT>update -h</TT> per avere 
maggiori informazioni.

<P>
Lo spazio di swap viene attivato da <TT>swapon</TT>, e disattivato da 
<TT>swapoff</TT>. Lo script di init (<TT>/etc/rc.sysinit</TT> oppure 
<TT>/etc/rc.d/rc.sysinit</TT>) generalmente fa una chiamata a 
<TT>swapon</TT> quando il sistema si avvia.
Mi è stato detto che <TT>swapoff</TT> è comodo per il risparmio
energetico sui portatili.

<SECT1>Esercizi
<P>
Eseguite un <TT>update -d</TT> (NdT: al momento della traduzione,
l'opzione <TT>-d</TT> non viene contemplata dal programma <TT>udate</TT>, 
e notate cosa viene blaterato nell'ultima riga riguardo al ``threshold 
for buffer fratricide'' (NdT: ``punto limite per un fratricidio tra 
buffer''). Ecco un argomento intrigante, provate ad investigare!

<P>
Entrate nella directory <TT>/proc/sys/vm</TT> e visualizzate con 
<TT>cat</TT> i file ivi contenuti. Vedete cosa riuscite a scoprire.

<SECT1>Maggiori Informazioni
<P>
Il documento ``The Linux Kernel'' su Linux Documentation Project (LDP)  
(vedete la sessione <REF ID="Kernel" NAME="The Linux Kernel"> per la 
URL) 

<P>
Il codice sorgente del kernel Linux, se siete abbastanza coraggiosi!
Il codice di <TT>kswapd</TT> è in <TT>linux/mm/vmscan.c</TT>, 
quello di <TT>kflushd</TT> e di <TT>kupdate</TT> sono in 
<TT>linux/fs/buffer.c</TT>.



<SECT>Il Logger di Sistema
<P>
Init avvia i demoni <TT>syslogd</TT> e <TT>klogd</TT>. Questi scrivono 
dei messaggi nei log. I messaggi del kernel vengono gestiti da 
<TT>klogd</TT>, mentre <TT>syslogd</TT> gestisce i messaggi di log degli 
altri processi. Il file di log principale è <TT>/var/log/messages</TT>. 
Questo è un buon posto in cui investigare se c'è qualcosa che non va nel 
vostro sistema. Spesso potreste trovarvi degli indizi importanti.


<SECT1>Configurazione
<P>
Il file <TT>/etc/syslog.conf</TT> istruisce il programma che gestisce i 
log sui messaggi da gestire, e dove riportarli. I messaggi vengono 
identificati tramite il servizio da cui provengono, e dal loro livello
di priorità. Questo file di configurazione consiste di una serie di
righe su cui viene indicato che i messaggi provenienti dal servizio x, 
con priorità y, devono venire inviati su z, dove z può essere un file,
una tty, una stampante, un host remoto o altro.

<P>
NOTA: il demone Syslog richiede che il file <TT>/etc/services</TT> sia 
presente sul sistema. Il file services assegna le porte. Non sono sicuro 
se syslog necessiti di una porta assegnata per poter gestire i log in  
remoto, o se la stessa gestione locale dei log venga fatta tramite una 
porta, o se utilizza <TT>/etc/services</TT> soltanto per convertire i 
nomi dei servizi che avete impostato in <TT>/etc/syslog.conf</TT> in 
numeri di porta.

<SECT1>Esercizi
<P>
Osservate i vostri log di sistema. Cercate un messaggio che non 
comprendete, e sforzatevi di capire cosa significhi.

<P>
Mandate tutti i vostri messaggi di log su una tty. (poi reimpostateli 
al modo predefinito)


<SECT1>Maggiori Informazioni
<P>Australian sysklogd <URL URL="http://mirror.aarnet.edu.au/pub/linux/metalab/system/daemons/"
	NAME="Mirror">



<SECT>Getty e Login
<P>
Getty è il programma che vi permette di autenticarvi attraverso un 
dispositivo seriale, come ad esempio un terminale fisico o virtuale,  
oppure tramite un modem. Getty visualizza il prompt di autenticazione.
Una volta inserito il vostro nome utente, getty lo passa a 
<TT>login</TT>, il quale vi chiederà una password, controllerà la sua 
validità, e vi fornirà una shell.


<P>
Esistono diverse versioni disponibili di getty. Alcune distribuzioni, 
compresa Red Hat, ne usano una molto piccola chiamata <TT>mingetty</TT>,  
che funziona solamente con i terminali virtuali.

<P>
Il programma <TT>login</TT> fa parte del pacchetto util-linux, che 
contiene a sua volta una versione di getty chiamata <TT>agetty</TT>, e 
che funziona molto bene. Questo pacchetto contiene anche 
<TT>mkswap</TT>, <TT>fdisk</TT>, <TT>passwd</TT>, <TT>kill</TT>, 
<TT>setterm</TT>, <TT>mount</TT>, <TT>swapon</TT>, <TT>rdev</TT>, 
<TT>renice</TT>, <TT>more</TT> e molti altri ancora.

<SECT1>Configurazione
<P>
Il messaggio che viene visualizzato sulla parte alta del vostro schermo 
assieme al prompt di login, proviene da <TT>/etc/issue</TT>. In genere
le istanze di Getty vengono avviate da <TT>/etc/inittab</TT>. Login
verifica i dati di un utente contenuti in <TT>/etc/passwd</TT>, o in 
<TT>/etc/shadow</TT> se usate lo shadow delle password.

<SECT1>Esercizi
<P>
Create un file <TT>/etc/passwd</TT> a mano. Potete anche impostare delle  
password vuote, e modificarle con il comando <TT>passwd</TT> una volta 
eseguito il login. Leggete la pagina di manuale corrispondente tramite 
il comando <TT>man 5 passwd</TT>, per avere il manuale del file 
piuttosto che quello del programma passwd.


<SECT>Bash
<P>
Se fornite a <TT>login</TT> una combinazione di username e password
valida, questo verificherà nel file <TT>/etc/passwd</TT> quale shell
deve mettervi a disposizione. Nella maggior parte dei casi per un 
sistema Linux, questa sarà la shell <TT>bash</TT>. Spetta a 
<TT>bash</TT> leggere ed interpretare i vostri comandi. Può essere vista 
contemporaneamente come un'interfaccia utente, e come un interprete di 
linguaggio di programmazione. 

<P>
Come interfaccia utente legge i vostri comandi e, se sono dei comandi 
``interni'' come <TT>cd</TT> li esegue essa stessa, altrimenti cerca ed 
esegue un programma se sono dei comandi ``esterni'', come <TT>cp</TT> o 
<TT>startx</TT>. Bash svolge anche altri compiti diversi, come il 
mantenimento dello storico dei comandi ed il completamento automatico 
dei nomi.

<P>
Abbiamo già visto <TT>bash</TT> in azione come interprete di linguaggio 
di programmazione. Gli script che vengono eseguiti da <TT>init</TT> per 
avviare il sistema solitamente sono degli script di shell, e vengono 
eseguiti da <TT>bash</TT>. Avere a disposizione un vero e proprio 
linguaggio di programmazione affianco ai programmi di utilità messi a 
disposizione dalla linea di comando, costituisce un potente strumento,
se sapete usarlo.
Ad esempio (permettetemi l'immodestia), l'altro giorno ho dovuto 
applicare una serie di patch ai file di una directory contenente del 
codice sorgente. Sono riuscito a farlo con questo semplice, singolo 
comando:

<VERB>
for f in /home/greg/sh-utils-1.16*.patch; do patch -p0 < $f; done;
</VERB>

<P>
Questo comando cerca nella mia directory personale tutti quei file i cui
nomi iniziano per <TT>sh-utils-1.16</TT> e finiscono per 
<TT>.patch</TT>. Quindi ne prende uno alla volta, lo imposta alla 
variabile <TT>f</TT>, ed esegue i comandi contenuti tra le istruzioni 
<TT>do</TT> e <TT>done</TT>. Nel mio caso c'erano 11 file di patch, ma 
avrebbero potuto facilmente essere anche 3000.

<SECT1>Configurazione
<P>
Il file <TT>/etc/profile</TT> controlla il comportamento globale di bash
sul sistema. Quello che scriverete su questo file avrà effetto per tutti 
gli utenti che utilizzeranno bash sul vostro sistema. Aggiungerà inoltre 
alcune directory alla variabile di ambiente <TT>PATH</TT>, imposterà 
la variabile <TT>MAIL</TT>, ecc.

<P>
Il comportamento predefinito della tastiera lascia spesso molto a 
desiderare. Attualmente è la libreria readline che lo gestisce. 
Readline è un pacchetto separato che gestisce la linea di comando,
fornendo lo storico dei comandi ed il completamento automatico dei nomi, 
così come alcune caratteristiche di editing avanzato da linea di 
comando. Viene compilata all'interno di bash. In modo predefinito, 
readline viene configurata attraverso il file <TT>.inputrc</TT>,
presente nella vostra directory home. La variabile bash INPUTRC può
venire utilizzata per modificare questa impostazione. Per esempio in Red 
Hat 6, <TT>INPUTRC</TT> viene impostata a <TT>/etc/inputrc</TT> in 
<TT>/etc/profile</TT>. Questo permette ai tasti backspace, delete, home 
e end, di funzionare adeguatamente per tutti gli utenti. 

<P>
Dopo che bash ha letto il file di configurazione globale di sistema, va 
a leggere il vostro file di configurazione personale. Ne verifica la
presenza nella vostra directory home attraverso i nomi di file
<TT>.bash_profile</TT>, <TT>.bash_login</TT> e <TT>.profile</TT>. Esegue 
il primo dei tre che individua. Se volete modificare il comportamento di 
bash solo per voi, senza cambiare il suo funzionamento per gli altri
utenti, fatelo in questi file. Ad esempio, molte applicazioni usano 
delle variabili di ambiente per impostare il proprio funzionamento. Io 
ho la variabile <TT>EDITOR</TT> impostata a <TT>vi</TT>, in modo da 
poter utilizzare vi all'interno di Midnight Commander (un eccellente 
file manager testuale), invece del suo editor predefinito. 


<SECT1>Esercizi
<P>
I principi base di bash sono facili da imparare. Ma non fermatevi lì: 
c'è ancora molto materiale per approfondire. Prendete l'abitudine di 
cercare metodi sempre migliori per svolgere determinati compiti.

<P>
Leggete gli script di shell, cercate di capire le cose che non vi sono
chiare.

<SECT1>Altre Informazioni
<P>
<ITEMIZE>
<ITEM>Esiste un ``Bash Reference Manual'', che comprende praticamente 
      tutto, ma di pesante lettura.
<ITEM>C'è un libro della O'Reilly su Bash, ma non sono sicuro che sia 
      buono.
<ITEM>Non conosco dei tutorial gratuti, buoni e aggiornati per bash. Se 
      li conoscete, per favore fatemelo sapere e segnalatemi per posta
      elettronica l'indirizzo URL su cui reperirli. 
<ITEM>  il codice sorgente, vedete
	<URL URL="http://www.netspace.net.au/~gok/power2bash" 
	NAME="Building a Minimal Linux System from Source Code"> 
</ITEMIZE>


<SECT>Comandi
<P>
Gran parte del lavoro che svolgete in bash viene eseguito attraverso dei 
comandi come <TT>cp</TT>. La maggior parte di questi comandi sono dei 
piccoli programmi, sebbene alcuni, come <TT>cd</TT>, siano contenuti 
all'interno della shell. 

<P>
I comandi vengono distribuiti sotto forma di pacchetti, la maggior parte
dei quali dalla Free Software Foundation (o GNU). Piuttosto che 
mettermi ad elencare qui i pacchetti, vi rimando direttamente a
<URL URL="http://www.linuxfromscratch.org" NAME="Linux From Scratch HOWTO">. 
Contiene una lista completa ed aggiornata dei pacchetti che vengono
installati in un sistema Linux, insieme alle istruzioni su come 
compilarli.


<SECT>Conclusioni
<P>
Una delle cose migliori di Linux, secondo la mia modesta opinione, è che 
potete entrarci dentro e capire davvero come funzioni l'intero sistema. 
Spero che apprezziate questo come l'ho apprezzato io. E spero che questa 
piccola guida vi sia stata di aiuto.

<SECT>Amministrativa
<SECT1>Copyright
<P>
This document is copyright (c) 1999, 2000 Greg O'Keefe. You are welcome
to use, copy, distribute or modify it, without charge, under the terms 
of the <URL URL="http://www.gnu.org/copyleft/gpl.html" 
	NAME="GNU General Public Licence">.
Please acknowledge me if you use all or part of this in another 
document.

<SECT1>Homepage
<P>
Potete trovare la versione aggiornata di questo documento su 
<URL URL="http://www.netspace.net.au/~gok/power2bash" 
	NAME="From Powerup To Bash Prompt"> 
insieme al suo complementare ``Building a Minimal Linux System from 
Source Code''.

<P>
Esiste una traduzione in Francese su
<URL URL="http://www.freenix.fr/unix/linux/HOWTO/From-PowerUp-To-Bash-Prompt-HOWTO.html"
	NAME="From Powerup To Bash Prompt"> grazie a Dominique van den 
        Broeck.
La versione giapponese arriverà presto, se non si trova già su 
<URL URL="http://www.linux.or.jp/JF" NAME="Japanese Documentation and FAQ Project">.
	


	
<SECT1>Segnalazioni
<P>
Mi piacerebbe ricevere i vostri commenti, critiche o suggerimenti per 
migliorare questo documento. Per favore scrivetemi all'indirizzo
<URL URL="mailto:gcokeefe@postoffice.utas.edu.au" NAME="Greg O'Keefe">


<SECT1>Ringraziamenti
<LABEL ID="acknowledge">
<P>
I nomi dei prodotti sono marchi registrati dei rispettivi proprietari, 
e sono perciò da considerarsi come noti.

<P>
Ci sono alcune persone che vorrei ringraziare per avermi aiutato a 
realizzare questa guida.

<P>
<DESCRIP>
	
<TAG>Michael Emery</TAG>
Per avermi ricordato di Unios.
<TAG>Tim Little</TAG>
Per alcuni buoni suggerimenti su <TT>/etc/passwd</TT>
<TAG>sPaKr su #linux di efnet</TAG>
Che mi ha fatto notare come syslogd necessiti di <TT>/etc/services</TT>, 
e che mi ha fatto conoscere l'espressione ``rolling your own'' in
riferimento alla costruzione di un sistema a partire dal codice 
sorgente.
<TAG>Alex Aitkin</TAG>
Per avermi fatto conoscere Vico e il suo ``verum ipsum factum'' 
(la comprensione viene attraverso le azioni).
<TAG>Dennis Scott</TAG>
Per aver corretto la mia aritmetica esadecimale.
<TAG>jdd</TAG>
Per avermi segnalato alcuni errori di battitura.
<TAG>David Leadbeater</TAG>
Per aver contribuito a chiarire alcuni dubbi sui demoni del kernel.
<TAG>Dominique van den Broeck </TAG>
Per aver tradotto questo documento in Francese.
<TAG>Matthieu Peeters </TAG>
Per alcune preziose informazioni sui demoni del kernel.
<TAG>John Fremlin</TAG>
Per alcune preziose informazioni sui demoni del kernel.
<TAG>Yuji Senda</TAG>
Per la traduzione in Giapponese del documento.
<TAG>Antonius de Rozari</TAG>
Per aver contribuito alla realizzazione di una 
versione assembler GNU di UNIOS
(vedete la sezione ``risorse'' nella mia home page)
</DESCRIP>

<SECT1>Storico delle modifiche

<SECT2>0.8 -> 0.9 (Novembre 2000)
<P>
<ITEMIZE>
<ITEM>Incorporate alcune informazioni da Matthieu Peeters e John Fremlin
      sui demoni del kernel e sul filesystem <TT>/proc</TT>.
</ITEMIZE>

<SECT2>0.7 -> 0.8 (Settembre 2000)
<P>
<ITEMIZE>
<ITEM> Rimosse le istruzioni su come costruire un sistema, e poste in un
       documento separato. Corretti alcuni link.
<ITEM> Modificata la homepage da <URL URL="http://learning.taslug.org.au/power2bash" 
	NAME="learning@TasLUG">
	a <URL URL="http://www.netspace.net.au/~gok/power2bash" 
	NAME="my own webspace">.
<ITEM> Completamente fallito il tentativo di inserire molto buon
       materiale, fornito dai contributi di svariate persone. Forse sarà
       per una prossima volta :(
</ITEMIZE>

<SECT2>0.6 -> 0.7
<P>
<ITEMIZE>
<ITEM>maggiore enfasi sulla parte teorica, minore sul metodo di
      costruzione di un sistema; le informazioni sulla costruzione
      riunite in una sezione separata, e riordinato il sistema
      compilato; indirizzati i lettori verso il documento di ``Linux 
      From Scratch'' di Gerard Beekmans per una compilazione più
      completa
<ITEM>aggiunte alcune divagazioni suggerite da David Leadbeater
<ITEM>corrette un paio di url, aggiunto il link al download di unios a 
      learning.taslug.org.au/resources
<ITEM>verificati e corretti i link
<ITEM>riscrittura generale, riordinamento
</ITEMIZE>

<SECT2>0.5 -> 0.6
<P>
<ITEMIZE>
<ITEM>aggiunto lo storico delle modifiche
<ITEM>aggiunte alcune voci alla lista "DA FARE"
</ITEMIZE>

<SECT1>DA FARE
<P>
<ITEMIZE>
<ITEM>spiegare i moduli del kernel, i comandi depmod, modprobe, insmod e
      simili (devo prima provarli!)
<ITEM>menzionare il filesystem /proc, possono venire proposti esercizi
      su di esso
<ITEM>convertire a docbook sgml
<ITEM>aggiungere altri esercizi, magari una intera sezione dedicata ad
     esercizi più complessi, come ad esempio la creazione di un
     filesystem minimale, un file alla volta, attraverso l'installazione
     di una distribuzione.
<ITEM>aggiungere miglioramenti al makefile di compilazione di bash.
</ITEMIZE>

</ARTICLE>
