path: root/it_IT.ISO8859-15/books/handbook/boot/chapter.sgml

<?xml version="1.0" encoding="ISO8859-15" standalone="no"?>
<!--
     The FreeBSD Italian Documentation Project

     $FreeBSD$
     Original revision: 1.65
-->

<chapter id="boot">
  <title>La Procedura di Avvio di FreeBSD</title>

  <sect1 id="boot-synopsis">
    <title>Sinossi</title>

    <indexterm><primary>avvio</primary></indexterm>
    <indexterm><primary>avviamento</primary></indexterm>

    <para>Il processo di accensione di un computer e caricamento del sistema
      operativo viene detto <quote>processo di avviamento</quote>, o
      semplicemente <quote>avvio</quote>.  La procedura di avvio di FreeBSD
      fornisce un alto grado di flessibilit&agrave; nel personalizzare quello
      che succede quando avvii il sistema, dandoti la possibilit&agrave; di
      scegliere tra diversi sistemi operativi installati sullo stesso computer,
      o anche tra diverse versioni dello stesso sistema operativo o tra diversi
      kernel installati.</para>

    <para>Questo capitolo fornisce i dettagli sulle opzioni di configurazione
      che puoi impostare per personalizzare il processo di avvio di FreeBSD.
      Ci&ograve; comprende tutto quello che avviene fino a quando il kernel
      viene lanciato, vengono controllate le periferiche, e viene avviato
      &man.init.8;.  Se non sei sicuro di sapere quando tutto questo accada, si
      tratta del momento in cui il colore del testo a video cambia da bianco
      brillante a grigio.</para>

    <para>Dopo aver letto questo capitolo, saprai:</para>

    <itemizedlist>
      <listitem>
        <para>Quali sono i componenti del sistema di avvio di FreeBSD, e come
          interagiscono.</para>
      </listitem>

      <listitem>
        <para>Le opzioni che puoi impostare per i componenti durante
          l'avviamento di FreeBSD per controllare il processo di avvio.</para>
      </listitem>

      <listitem>
        <para>Le basi dei &man.device.hints.5;.</para>
      </listitem>
    </itemizedlist>

    <note>
      <title>Solo per x86</title>

      <para>Questo capitolo descrive la procedura di avvio di FreeBSD su sistemi
        Intel x86.</para>
    </note>
  </sect1>

  <sect1 id="boot-introduction">
    <title>Il Problema dell'Avvio</title>

    <para>Accendere un computer e far partire il sistema operativo pone un
      dilemma interessante.  Per definizione, il computer non sa fare
      nulla finch&eacute; non viene avviato il sistema operativo.  Questo
      include anche l'esecuzione dei programmi dal disco.  Dunque se il computer
      non pu&ograve; eseguire un programma da disco senza il sistema operativo,
      ed i programmi del sistema operativo sono sul disco, come viene avviato il
      sistema operativo?</para>

    <para>Questo &egrave; un problema analogo a quello descritto nel
      libro <citetitle>Le Avventure del Barone di Munchausen</citetitle>.  Un
      personaggio era caduto in una botola, e ne era uscito tirandosi su da
      s&eacute; (in inglese <quote>bootstrap</quote>), riuscendo nell'intento
      solo con i propri sforzi.  Nei primi giorni dei calcolatori al meccanismo
      usato per caricare il sistema operativo fu applicato il termine
      <firstterm>bootstrap</firstterm>, ed in seguito venne abbreviato in
      <quote>booting</quote> (in italiano <quote>avvio</quote>).</para>

    <indexterm><primary>BIOS</primary></indexterm>
    <indexterm>
      <primary>Basic Input/Output System</primary>
      <see>BIOS</see>
    </indexterm>

    <para>Su sistemi con hardware x86 il BIOS (Basic Input/Output System)
      &egrave; il responsabile del caricamento del sistema operativo.  Per fare
      ci&ograve;, il BIOS cerca nel disco rigido il Master Boot Record (MBR),
      che deve essere in una specifica posizione sul disco.  Il BIOS ha
      abbastanza conoscenze per caricare ed eseguire l'MBR, ed assume che l'MBR
      possa portare avanti il resto dei compiti relativi al caricamento del
      sistema operativo, possibilmente con l'aiuto del BIOS.</para>

    <indexterm><primary>Master Boot Record (MBR)</primary></indexterm>
    <indexterm><primary>Boot Manager</primary></indexterm>
    <indexterm><primary>Boot Loader</primary></indexterm>

    <para>Il codice all'interno del MBR &egrave; di solito riferito come
      <emphasis>boot manager</emphasis>, specialmente quando interagisce
      con l'utente.  In questo caso la maggior parte del suo codice &egrave;
      nella prima <emphasis>traccia</emphasis> del disco o direttamente
      nel file system dell'OS.  (Il boot manager qualche volta viene chiamato
      anche <emphasis>boot loader</emphasis>, ma gli utenti di FreeBSD
      usano questo termine per una successiva fase di avvio.)  Boot
      manager popolari sono <application>boot0</application> (a.k.a.
      <application>Boot Easy</application>, il boot manager standard di &os;),
      <application>Grub</application>, <application>GAG</application>, e
      <application>LILO</application>.
      (Solo <application>boot0</application> &egrave; all'interno del
      MBR.)</para>

    <para>Se hai solo un sistema operativo installato sui tuoi dischi allora
      sar&agrave; sufficiente il MBR standard del PC.  Questo MBR cerca la prima
      slice avviabile (a.k.a. attiva) sul disco, e quindi esegue il codice
      in quella slice per caricare il resto del sistema operativo.  Il
      MBR installato da &man.fdisk.8;, di default, &egrave; come un MBR.
      &Egrave; basato su <filename>/boot/mbr</filename>.</para>

    <para>Se hai installato pi&ugrave; sistemi operativi sui tuoi dischi allora
      puoi installare un boot manager diverso, che mostra una lista dei diversi
      sistemi operativi, e ti permette di scegliere quale avviare.  Nella
      prossima sezione ne vengono presentati due.</para>

    <para>Il resto del sistema di avvio di FreeBSD &egrave; diviso in tre stadi.
      Il primo stadio viene eseguito dall'MBR, che sa solo il necessario per
      mettere il computer in un certo stato ed eseguire il secondo stadio.
      Quest'ultimo pu&ograve; fare poco di pi&ugrave;, prima di eseguire il
      terzo.  Il terzo stadio esaurisce il compito di caricare il sistema
      operativo.  Il lavoro &egrave; diviso in queste tre parti perch&eacute;
      gli standard dei PC pongono dei limiti alla dimensione dei programmi che
      possono essere eseguiti nei primi due stadi.  Concatenando i compiti
      si permette a FreeBSD di fornire un loader pi&ugrave; flessibile.</para>

    <indexterm><primary>kernel</primary></indexterm>
    <indexterm><primary><command>init</command></primary></indexterm>

    <para>A questo punto viene avviato il kernel ed esso comincia a verificare i
      dispositivi e ad inizializzarli.  Una volta che la procedura di avvio del
      kernel &egrave; finita, il kernel passa il controllo al processo utente
      &man.init.8;, che si assicura che i dischi siano in uno stato usabile.
      Poi &man.init.8; avvia la configurazione delle risorse a livello utente
      che monta i file system, imposta le schede di rete per comunicare via
      rete, ed in generale fa partire tutti i processi che generalmente sono in
      esecuzione su un sistema FreeBSD all'avvio.</para>
  </sect1>

  <sect1 id="boot-blocks">
    <title>Il Boot Manager e le Fasi di Boot</title>

    <indexterm><primary>Boot Manager</primary></indexterm>

    <sect2 id="boot-boot0">
      <title>Il Boot Manager</title>

      <indexterm><primary>Master Boot Record (MBR)</primary></indexterm>

      <para>Il codice nel MBR o nel boot manager &egrave; solitamente
        riferito alla <emphasis>fase zero</emphasis> del processo di boot.
        Questa sezione discute dei due boot manager menzionati in
        precedenza: <application>boot0</application> e
        <application>LILO</application>.</para>

      <formalpara>
        <title>Il Boot Manager <application>boot0</application>:</title>

        <para>Il MBR installato dall'installer di FreeBSD o da &man.boot0cfg.8;,
          di default, si basa su <filename>/boot/boot0</filename>.
          (Il programma <application>boot0</application> &egrave; molto
          semplice, poich&egrave; il programma nel <abbrev>MBR</abbrev>
          pu&ograve; essere al pi&ugrave; di 446 byte a causa della tabella
          della slice e dell'identificatore <literal>0x55AA</literal>
          alla fine del MBR.)
          Se hai installato <application>boot0</application> e hai pi&ugrave; di
          un sistema operativo sui tuoi dischi, allora vedrai
          una schermata simile alla seguente nella fase di avvio:</para>
      </formalpara>

      <example id="boot-boot0-example">
        <title>Screenshot di <filename>boot0</filename></title>

        <screen>F1 DOS
F2 FreeBSD
F3 Linux
F4 ??
F5 Drive 1

Default: F2</screen>
      </example>

      <para>Altri sistemi operativi, in particolare &windows;, sono noti
        per l'abitudine di sovrascrivere l'MBR esistente con il proprio.
        Se accade questo, o se vuoi rimpiazzare l'MBR pre-esistente con quello
        di FreeBSD puoi usare il seguente comando:</para>

      <screen>&prompt.root; <userinput>fdisk -B -b /boot/boot0 <replaceable>dispositivo</replaceable></userinput></screen>

      <para>dove <replaceable>dispositivo</replaceable> &egrave; il dispositivo
        dal quale vuoi avviare, come <devicename>ad0</devicename> per il primo
        disco IDE, <devicename>ad2</devicename> per il primo disco ide sul
        secondo canale, <devicename>da0</devicename> per il primo disco SCSI,
        e cos&igrave; via.  Se vuoi una configurazione ad hoc dell'MBR,
        usa &man.boot0cfg.8;.</para>

      <formalpara>
        <title>Il Boot Manager LILO:</title>

        <para>Per installare questo boot manager affinch&egrave; possa avviare
          anche FreeBSD, avvia Linux e aggiungi le seguenti cose nel
          tuo file di configurazione
          <filename>/etc/lilo.conf</filename>:</para>
      </formalpara>

      <programlisting>other=/dev/hdXY
table=/dev/hdX
loader=/boot/chain.b
label=FreeBSD</programlisting>

      <para>Specifica la partizione primaria di FreeBSD e il disco usando le
        direttive di Linux, rimpiazzando <replaceable>X</replaceable> con
        la lettera del dispositivo di Linux e <replaceable>Y</replaceable> con
        il numero della partizione primaria di Linux.  Se stai usando un
        dispositivo <acronym>SCSI</acronym>, devi modificare
        <replaceable>/dev/hd</replaceable> in qualcosa simile a
        <replaceable>/dev/sd</replaceable>.  La linea
        <option>loader=/boot/chain.b</option> pu&ograve; essere omessa
        se hai entrambi i sistemi operativi sullo stesso disco.  Esegui
        <command>/sbin/lilo&nbsp;-v</command> per apportare le modifiche al
        sistema; verificando il relativo messaggio a video.</para>
    </sect2>

    <sect2 id="boot-boot1">
      <title>Stadio Uno, <filename>/boot/boot1</filename>, e Stadio Due,
        <filename>/boot/boot2</filename></title>

      <para>Concettualmente il primo ed il secondo stadio sono parte dello
        stesso programma, sulla stessa area del disco.  Per limitazioni di
        spazio sono stati divisi in due, ma li installerai sempre
        insieme.  Sono copiati dal file
        <filename>/boot/boot</filename> dall'installer o da
        <application>bsdlabel</application> (vedi sotto).</para>

      <para>Questi sono posizionati fuori dai file system, nella prima
        traccia della slice di boot, a partire dal primo settore.
        Questo &egrave; il posto dove <link
          linkend="boot-boot0">boot0</link>, o qualsiasi altro boot manager,
        si aspetta di trovare un programma da avviare per continuare il
        processo di boot.  Il numero di settori usati &egrave; facilmente
        determinabile dalla dimensione di
        <filename>/boot/boot</filename>.</para>

      <para><filename>boot1</filename> &egrave; molto semplice, poich&eacute;
        pu&ograve; essere lungo solo 512 byte, e conosce solo lo stretto
        necessario del <firstterm>bsdlabel</firstterm> di FreeBSD, il quale
        memorizza le informazioni sulle slice, per trovare ed eseguire
        <filename>boot2</filename>.</para>

      <para><filename>boot2</filename> &egrave; leggermente pi&ugrave;
        sofisticato, e conosce il file system di FreeBSD abbastanza da potervi
        trovare dei file, e pu&ograve; fornire una semplice interfaccia per
        scegliere quale kernel o loader eseguire.</para>

      <para>Poich&eacute; il <link linkend="boot-loader">loader</link> &egrave;
        molto pi&ugrave; complesso, e fornisce una gradevole interfaccia di
        facile utilizzo alla configurazione di avvio, <filename>boot2</filename>
        in genere lo esegue, ma in precedenza era incaricato di lanciare il
        kernel direttamente.</para>

      <example id="boot-boot2-example">
        <title>Screenshot di <filename>boot2</filename></title>
        <screen>&gt;&gt; FreeBSD/i386 BOOT
Default: 0:ad(0,a)/boot/loader
boot:</screen>
      </example>

      <para>Se mai avrai bisogno di rimpiazzare il <filename>boot1</filename> ed
        il <filename>boot2</filename> installati, usa &man.bsdlabel.8;:</para>

      <screen>&prompt.root; <userinput>bsdlabel -B <replaceable>discoslice</replaceable></userinput></screen>

      <para>dove <replaceable>discoslice</replaceable> sono il disco e la slice
        dal quale vuoi effettuare l'avvio, come ad esempio
        <devicename>ad0s1</devicename> per la prima slice sul primo disco
        IDE.</para>

      <warning>
        <title>Modalit&agrave; Pericolosamente Dedicata</title>

        <para>Se nella sintassi del comando &man.bsdlabel.8; usi solo il
          nome del disco, come <devicename>ad0</devicename>, creerai un disco
          pericolosamente dedicato, senza slice.  Quasi sicuramente non &egrave;
          questo quello che vuoi fare, quindi controlla due volte il comando
          &man.bsdlabel.8; prima di premere <keycap>Invio</keycap>.</para>
      </warning>
    </sect2>

    <sect2 id="boot-loader">
      <title>Stadio Tre, <filename>/boot/loader</filename></title>

      <indexterm><primary>boot-loader</primary></indexterm>

      <para>Il loader &egrave; l'ultimo stadio della procedura di avvio divisa
        in tre, e si trova sul file system, generalmente come
        <filename>/boot/loader</filename>.</para>

      <para>Il loader deve essere inteso come un metodo user-friendly per la
        configurazione di avvio, tramite l'uso di un insieme di comandi
        integrati facili da usare, sostenuto da un potente interprete, con un
        insieme di comandi pi&ugrave; complessi.</para>

      <sect3 id="boot-loader-flow">
        <title>Sequenza di Operazioni del Loader</title>

        <para>Durante l'inizializzazione, il loader controller&agrave;
          la console e i dischi, e cercher&agrave; di capire da quale disco si
          stia avviando.  Imposter&agrave; le variabili di conseguenza, ed
          avvier&agrave; un interprete al quale potranno essere passati i
          comandi dell'utente in maniera interattiva o attraverso uno
          script.</para>

        <indexterm><primary>loader</primary></indexterm>
        <indexterm><primary>configurazione del loader</primary></indexterm>

        <para>Poi il loader legger&agrave; <filename>/boot/loader.rc</filename>,
          che di default legge i settaggi di
          <filename>/boot/defaults/loader.conf</filename> il quale imposta
          dei valori di default ragionevoli per le variabili e inoltre
          <filename>/boot/loader.rc</filename> legge
          <filename>/boot/loader.conf</filename> per i cambiamenti locali a
          quelle variabili.  In base a queste variabili
          <filename>loader.rc</filename> carica i moduli ed il kernel
          prescelti.</para>

        <para>Infine, di default, il loader attende per 10 secondi la pressione
          di un tasto, ed avvia il kernel se non viene interrotto.  Se invece
          viene interrotto, viene presentato all'utente un prompt in grado di
          comprendere un semplice insieme di comandi, dal quale l'utente
          pu&ograve; impostare precisamente le variabili, scaricare dalla
          memoria tutti i moduli, o caricarli, ed infine avviare o
          ri-avviare.</para>
      </sect3>

      <sect3 id="boot-loader-commands">
        <title>Comandi Integrati nel Loader</title>

        <para>Questi sono i comandi usati pi&ugrave; comunemente.  Per una
          discussione completa su tutti i comandi disponibili, guarda
          &man.loader.8;.</para>

        <variablelist>
          <varlistentry>
            <term>autoboot <replaceable>secondi</replaceable></term>

            <listitem>
              <para>Procede all'avvio del kernel se non viene interrotto
                nell'intervallo di tempo specificato, in secondi.  Mostra un
                conto alla rovescia, e l'intervallo predefinito &egrave; di
                10 secondi.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>boot
              <optional><replaceable>-opzioni</replaceable></optional>
              <optional><replaceable>nomekernel</replaceable></optional></term>

            <listitem>
              <para>Procede immediatamente all'avvio del kernel, con le opzioni
                date, se ce ne sono, e con il nome del kernel specificato, se
                fornito.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>boot-conf</term>

            <listitem>
              <para>Va avanti con la stessa configurazione automatica di moduli
                basati sulle variabili come accade al boot.  Questo ha senso
                solo se prima usi <command>unload</command>, e cambi delle
                variabili, in generale <envar>kernel</envar>.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>help
              <optional><replaceable>argomento</replaceable></optional></term>

            <listitem>
              <para>Mostra un messaggio d'aiuto letto da
                <filename>/boot/loader.help</filename>.  Se l'argomento dato
                &egrave; <literal>index</literal>, allora elenca tutti gli
                argomenti disponibili.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>include <replaceable>nomefile</replaceable> &hellip;</term>

            <listitem>
              <para>Processa il file specificato.  Il file viene letto, e
                interpretato riga per riga.  Un errore blocca il comando include
                immediatamente.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>load <optional><option>-t</option>
                <replaceable>tipo</replaceable></optional>
              <replaceable>nomefile</replaceable></term>

            <listitem>
              <para>Carica il kernel, il modulo del kernel, o il file
                del tipo specificato, con il nome specificato.  Ogni argomento
                dopo <replaceable>nomefile</replaceable> viene passato al
                file.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>ls <optional><option>-l</option></optional>
              <optional><replaceable>percorso</replaceable></optional></term>

            <listitem>
              <para>Mostra un elenco dei file nel percorso dato, o nella
                directory root, se non ne viene specificato uno.  Se &egrave;
                specificato <option>-l</option>, verranno mostrate anche le
                dimensioni dei file.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>lsdev <optional><option>-v</option></optional></term>

            <listitem>
              <para>Elenca tutti i dispositivi dai quali potrebbe essere
                possibile caricare moduli.  Se viene specificata l'opzione
                <option>-v</option>, verranno stampati dettagli maggiori.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>lsmod <optional><option>-v</option></optional></term>

            <listitem>
              <para>Mostra i moduli caricati.  Se viene specificato
                <option>-v</option>, verranno stampati dettagli maggiori.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>more <replaceable>nomefile</replaceable></term>

            <listitem>
              <para>Mostra i file specificati, con una pausa ad ogni
                pagina visualizzata.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>reboot</term>

            <listitem>
              <para>Riavvia immediatamente il sistema.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>set <replaceable>variabile</replaceable></term>
            <term>set
              <replaceable>variabile</replaceable>=<replaceable>valore</replaceable></term>

            <listitem>
              <para>Imposta le variabili di ambiente del loader.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>unload</term>

            <listitem>
              <para>Rimuove tutti i moduli caricati.</para>
            </listitem>
          </varlistentry>
        </variablelist>
      </sect3>

      <sect3 id="boot-loader-examples">
        <title>Esempi sul Loader</title>

        <para>Qui ci sono alcuni esempi pratici sull'uso del loader:</para>

        <itemizedlist>
          <indexterm>
            <primary>modalit&agrave; singolo utente</primary>
          </indexterm>

          <listitem>
            <para>Per avviare semplicemente il vostro kernel abituale,
            ma in modalit&agrave; singolo utente:</para>

            <screen><userinput>boot -s</userinput></screen>
          </listitem>

          <listitem>
            <para>Per scaricare dalla memoria i moduli e il kernel usuali,
              e poi caricare solo il vecchio (o un altro) kernel:</para>

            <indexterm>
              <primary><filename>kernel.old</filename></primary>
            </indexterm>

            <screen><userinput>unload</userinput>
<userinput>load <replaceable>kernel.old</replaceable></userinput></screen>

            <para>Puoi usare <filename>kernel.GENERIC</filename> per riferirti
              al kernel generico che viene fornito nel disco d'installazione, o
              <filename>kernel.old</filename> per riferirti al kernel installato
              precedentemente (quando hai aggiornato o configurato il kernel, ad
              esempio).</para>

            <note>
              <para>Usa il comando seguente  per caricare i tuoi soliti moduli
                con un altro kernel:</para>

              <screen><userinput>unload</userinput>
<userinput>set kernel="<replaceable>kernel.old</replaceable>"</userinput>
<userinput>boot-conf</userinput></screen></note>
          </listitem>

          <listitem>
            <para>Per caricare uno script di configurazione del kernel
              (uno script automatizzato che faccia le cose che faresti tu
              normalmente configurando il kernel all'avvio):</para>

            <screen><userinput>load -t userconfig_script <replaceable>/boot/kernel.conf</replaceable></userinput></screen>
          </listitem>
        </itemizedlist>
      </sect3>
    </sect2>
  </sect1>

  <sect1 id="boot-kernel">
    <title>Interazione con il Kernel Durante l'Avvio</title>

    <indexterm>
      <primary>kernel</primary>
      <secondary>interazione all'avvio</secondary>
    </indexterm>

    <para>Una volta che il kernel &egrave; stato caricato dal <link
        linkend="boot-loader">loader</link> (come di consueto) o da <link
        linkend="boot-boot1">boot2</link> (scavalcando il loader), esso
      esamina i suoi flag di avvio, se ce ne sono, e aggiusta il suo
      comportamento come necessario.</para>

    <sect2 id="boot-kernel-bootflags">
      <title>I Flag di Avvio del Kernel</title>

      <indexterm>
        <primary>kernel</primary>
        <secondary>flag di boot</secondary>
      </indexterm>

      <para>Qui ci sono alcuni dei pi&ugrave; comuni flag di avvio:</para>

      <variablelist id="boot-kernel-bootflags-list">
        <varlistentry>
          <term><option>-a</option></term>

          <listitem>
            <para>durante l'inizializzazione del kernel, chiede il dispositivo
              da montare come file system di root.</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><option>-C</option></term>

          <listitem>
            <para>avvia da CDROM.</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><option>-c</option></term>

          <listitem>
            <para>esegue UserConfig, il programma di configurazione del kernel
              all'avvio</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><option>-s</option></term>

          <listitem>
            <para>avvia in modalit&agrave; singolo utente</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><option>-v</option></term>

          <listitem>
            <para>aumenta la verbosit&agrave; durante l'avvio del kernel</para>
          </listitem>
        </varlistentry>
      </variablelist>

      <note>
        <para>Ci sono altri flag di avvio, leggi &man.boot.8; per maggiori
          informazioni su di essi.</para></note>
    </sect2>
  </sect1>

  <sect1 id="device-hints">
    <sect1info>
      <authorgroup>
        <author>
          <firstname>Tom</firstname>

          <surname>Rhodes</surname>

          <contrib>Contributo di </contrib>
        </author>
      </authorgroup>
    </sect1info>

    <title>Device Hints</title>

    <indexterm><primary>device.hints</primary></indexterm>

    <note>
      <para>Questa &egrave; una caratteristica di FreeBSD&nbsp;5.0 e successive
        che non esiste nelle versioni precedenti.</para>
    </note>

    <para>Durante l'avvio iniziale del sistema, il boot &man.loader.8;
      legger&agrave; il file &man.device.hints.5;.  Questo file contiene
      informazioni di avvio per il kernel dette variabili, e talvolta indicate
      come <quote>device hints</quote>, suggerimenti per i dispositivi.
      Questi <quote>device hints</quote> vengono usati dai driver per la
      configurazione delle varie periferiche.</para>

    <para>I device hints possono essere specificati anche nel prompt del terzo
      stadio <link linkend="boot-loader">del boot loader</link>.
      Le variabili possono essere aggiunte usando il comando
      <command>set</command>, rimosse con <command>unset</command>, e
      visualizzate con <command>show</command>.  Inoltre, in questo modo,
      le variabili impostate nel file <filename>/boot/device.hints</filename>
      possono essere scavalcate.  I device hint inseriti in questo modo non sono
      permanenti e verranno dimenticati al riavvio seguente.</para>

    <para>Una volta che il sistema &egrave; stato avviato, pu&ograve; essere
      usato il comando &man.kenv.1; per mostrare tutte le variabili.</para>

    <para>La sintassi per il file <filename>/boot/device.hints</filename>
      &egrave; una variabile per riga, usando il solito cancelletto
      <quote>#</quote> per indicare i commenti.  Le linee sono costruite come
      segue:</para>

    <screen><userinput>hint.driver.unit.keyword="<replaceable>valore</replaceable>"</userinput></screen>

    <para>La sintassi nel terzo stadio del boot loader &egrave;:</para>

    <screen><userinput>set hint.driver.unit.keyword=<replaceable>valore</replaceable></userinput></screen>

    <para><literal>driver</literal> &egrave; il nome del driver per il
      dispositivo, <literal>unit</literal> &egrave; il numero di unit&agrave;
      per quel driver, e <literal>keyword</literal> &egrave; la parola chiave
      per quell'hint.  La parola chiave pu&ograve; essere:</para>

    <itemizedlist>
      <listitem>
        <para><literal>at</literal>: specifica il bus sul quale &egrave;
          collegato il dispositivo.</para>
      </listitem>

      <listitem>
        <para><literal>port</literal>: specifica l'indirizzo iniziale di
          <acronym>I/O</acronym> che deve essere usato.</para>
      </listitem>

      <listitem>
        <para><literal>irq</literal>: specifica il numero di interrupt request
          che deve essere usato.</para>
      </listitem>

      <listitem>
        <para><literal>drq</literal>: specifica il numero del canale DMA.</para>
      </listitem>

      <listitem>
        <para><literal>maddr</literal>: specifica l'indirizzo di memoria fisico
          occupato dal dispositivo.</para>
      </listitem>

      <listitem>
        <para><literal>flags</literal>: imposta vari bit di flag per il
          dispositivo.</para>
      </listitem>

      <listitem>
        <para><literal>disabled</literal>: se impostato a <quote>1</quote> il
          dispositivo &egrave; disabilitato.</para>
      </listitem>
    </itemizedlist>

    <para>I driver possono accettare (o richiedere) pi&ugrave; hints di quelli
      elencati qui, si raccomanda quindi di verificare la loro pagina di
      manuale.  Per maggiori informazioni, consulta le pagine man
      &man.device.hints.5;, &man.kenv.1;, &man.loader.conf.5;, e
      &man.loader.8;.</para>
  </sect1>

  <sect1 id="boot-init">
    <title>Init: Inizializzazione del Controllo dei Processi</title>

    <indexterm><primary><command>init</command></primary></indexterm>

    <para>Una volta che il kernel ha finito di avviarsi, trasferisce il
      controllo al processo utente <command>init</command>, che si trova in
      <filename>/sbin/init</filename>, o al programma specificato
      nella variabile <envar>init_path</envar> nel
      <command>loader</command>.</para>

    <sect2 id="boot-autoreboot">
      <title>Sequenza di Riavvio Automatica</title>

      <para>La sequenza di riavvio automatica assicura che i file system
        disponibili sul sistema siano consistenti.  Se qualcuno non lo &egrave;,
        e &man.fsck.8; non pu&ograve; risolvere le inconsistenze, &man.init.8;
        abbandona il sistema in <link linkend="boot-singleuser">modalit&agrave;
          singolo utente</link> per permettere all'amministratore di sistema di
        occuparsi dei problemi direttamente.</para>
    </sect2>

    <sect2 id="boot-singleuser">
      <title>Modalit&agrave; Singolo Utente</title>

      <indexterm><primary>modalit&agrave; singolo utente</primary></indexterm>
      <indexterm><primary>console</primary></indexterm>

      <para>Questa modalit&agrave; pu&ograve; essere raggiunta attraverso la
        <link linkend="boot-autoreboot">sequenza di riavvio automatica</link>,
        o tramite l'avvio da parte dell'utente con l'opzione
        <option>-s</option> o impostando la variabile <envar>boot_single</envar>
        nel <command>loader</command>.</para>

      <para>Si pu&ograve; arrivare ad essa anche richiamando &man.shutdown.8;
        senza l'opzione per il riavvio (<option>-r</option>) o per l'arresto
        (<option>-h</option>), dalla <link
          linkend="boot-multiuser">modalit&agrave; multi utente</link>.</para>

      <para>Se la <literal>console</literal> del sistema &egrave; settata come
        <literal>insecure</literal> in <filename>/etc/ttys</filename>,
        allora il sistema richiede la password di <username>root</username>
        prima di entrare in modalit&agrave; singolo utente.</para>

      <example id="boot-insecure-console">
        <title>Una Console Insicura in <filename>/etc/ttys</filename></title>

        <programlisting># name  getty                           type    status          comments
#
# Se la console &egrave; settata come  "insecure", allora init chieder&agrave;
# la password di root per andare in modalit&agrave; singolo utente .
console none                            unknown off insecure</programlisting>
      </example>

      <note>
        <para>Avere una console <literal>insecure</literal> significa
          ritenere insicura la sicurezza fisica della console, ed assicurarsi
          che solo chi conosce la password di <username>root</username> possa
          usare la modalit&agrave; singolo utente, non significa voler eseguire
          la console in maniera insicura.  Dunque, se vuoi avere sicurezza,
          scegli <literal>insecure</literal>, non
          <literal>secure</literal>.</para>
      </note>
    </sect2>

    <sect2 id="boot-multiuser">
      <title>Modalit&agrave; Multi Utente</title>

      <indexterm><primary>modalit&agrave; multi utente</primary></indexterm>

      <para>Se &man.init.8; ritiene che i tuoi file system siano in ordine,
        o quando l'utente ha terminato il lavoro in <link
          linkend="boot-singleuser">modalit&agrave; singolo utente</link>, il
        sistema entra in modalit&agrave; multi utente, nella quale inizia la
        configurazione delle risorse del sistema.</para>

      <sect3 id="boot-rc">
        <title>Configurazione delle Risorse (rc)</title>

        <indexterm><primary>file rc</primary></indexterm>

        <para>Il sistema di configurazione delle risorse legge i valori
          predefiniti della configurazione da
          <filename>/etc/defaults/rc.conf</filename>, e
          i dettagli specifici del sistema da
          <filename>/etc/rc.conf</filename>, e poi procede al montaggio dei
          file system del sistema elencati in
          <filename>/etc/fstab</filename>, avvia i servizi di rete,
          avvia vari demoni di sistema, ed infine esegue gli script di avvio dei
          pacchetti installati localmente.</para>

        <para>La pagina man di &man.rc.8; &egrave; un buon riferimento per la
          configurazione delle risorse del sistema, poich&eacute; esamina gli
          script stessi.</para>
      </sect3>
    </sect2>
  </sect1>

  <sect1 id="boot-shutdown">
    <title>Sequenza di Spegnimento</title>

    <indexterm><primary><command>spegnimento</command></primary></indexterm>

    <para>Al momento di uno spegnimento controllato, tramite &man.shutdown.8;,
      &man.init.8; cercher&agrave; di eseguire lo script
      <filename>/etc/rc.shutdown</filename>, e poi proceder&agrave; ad inviare
      a tutti i processi il segnale <literal>TERM</literal>, e successivamente
      il segnale <literal>KILL</literal> a quelli che non sono terminati in
      tempo.</para>

    <para>Per spegnere una macchina FreeBSD su architetture e sistemi
      che supportano la gestione dell'energia, usa semplicemente il comando
      <command>shutdown -p now</command> per disattivare immediatamente
      l'alimentazione.  Per riavviare semplicemente un sistema FreeBSD, usa solo
      <command>shutdown -r now</command>.  Avrai bisogno di essere
      <username>root</username> o un membro del gruppo
      <groupname>operator</groupname> per eseguire &man.shutdown.8;.
      Possono essere usati anche i comandi &man.halt.8; e &man.reboot.8;,
      fai riferimento alle loro pagine di man ed a quella di &man.shutdown.8;
      per maggiori informazioni.</para>

    <note>
      <para>La gestione dell'energia richiede il supporto &man.acpi.4; nel
        kernel o caricato come modulo.</para>
    </note>
  </sect1>
</chapter>