LKN: Configurare e Compilare: differenze tra le versioni

Vai alla navigazione Vai alla ricerca

LKN: Configurare e Compilare (visualizza wikitesto)

Versione delle 18:13, 22 ago 2007

99 byte aggiunti ,  22 ago 2007
m
aggiunto link pdf originale
Nessun oggetto della modifica
m (aggiunto link pdf originale)
Riga 1: Riga 1:
== Introduzione ==
''Torna all'indice: [[Linux Kernel in a Nutshell]]''


Questo how-to spiegher� come installare i driver proprietari forniti da ATI per generare il modulo <tt>fglrx</tt> necessario al funzionamento del motore 3d delle schede grafiche.
__TOC__


Come � noto i driver ATI soffrono di una difficile installazione e configurazione. Sfortunatamente (o forse no) esistono molteplici configurazioni hardware che ostacolano l'installazione dei driver. Spesso, anche seguendo un guida perfetta, non si riesce ad attivare l'accelerazione 3D al primo colpo (molto raramente si hanno anche problemi di visualizzazione nel desktop). Solamente con i successivi tentativi (variando anche il metodo, o la guida) solitamente si raggiunge lo scopo prefisso. Il modesto consiglio � di non disperarsi, magari tirare cazzotti pesanti al case, ma provare finch� non si riesce.
Ora che avete scaricato i sorgenti della versione del kernel che avete scelto e che li avete installati in una cartella locale, è giunto il momento di compilare il codice. Il primo passo è di configurare il kernel con le opzioni appropriate; in seguito il kernel potrà essere compilato. Entrambe le operazioni sono portate a termine attraverso lo strumento standard ''make''.


== Software richiesto ==
== '''Creare una configurazione''' ==


Sebbene i pacchetti per la generazione del modulo <tt>fglrx</tt> siano disponibili nel repository di Debian, il consiglio � quello di utilizzare l'installer fornito da ATI in quanto pi� aggiornato.
La configurazione del kernel risiede in un file chiamato ''.config'' nella cartella principale dell'albero dei sorgenti del kernel. Se avete appena estratto il codice sorgente del kernel, non vi sarà alcun file ''.config'', quindi dovrà essere creato. Il file può essere creato da zero, creato partendo dalla "configurazione predefinita", preso da una versione funzionante del kernel, o preso da quello rilasciato da una distribuzione. Copriremo i primi due metodi adesso, gli ultimi due metodi nel [[LKN:_Personalizzare_un_Kernel|Capitolo 7]].
Oltre a questo, nel caso in cui si voglia compilare il modulo senza sfruttare l'installer, sar� necessario disporre dei sorgenti del kernel (o gli header), quindi del pacchetto linux-source e di tutti i pacchetti correlati a questo e necessari per la compilazione (<tt>build-essential</tt>).


{{ Warningbox | Prima di far partire l'installazione di nuovi driver:
==='''Configurare dall'inizio'''===
Il modo più spartano per configurare un kernel è usare il metodo ''make config'':
<pre>$ cd linux-2.6.17.10
  $ make config
make config
scripts/kconfig/conf arch/i386/Kconfig
*
* Linux Kernel Configuration
*
*
* Code maturity level option
*
Prompt for development and/or incomplete code/drivers (EXPERIMENTAL) [Y/n/?]
Y


* Salvate una copia di <tt>/etc/X11/xorg.conf</tt> , che in caso di problemi andra' sostituita a quella nuova (creata dal configurer).
*
* Verificate che non sia presente la cartella <tt>/usr/share/fglrx/</tt>. Se � presente, significa che sono installati dei vecchi driver fglrx. Per rimuoverli:
* General setup
<pre># cd /usr/share/fglrx/
*
# sh ./fglrx-uninstall.sh</pre>
Local version - append to kernel release (LOCALVERSION) []
e seguite le istruzioni.
Automatically append version information to the version string
* Fate un '''<tt>aptitude purge</tt>''' di vecchi pacchetti di vecchi driver, se sono installati. Per esempio (i nomi dei pacchetti potrebbero essere diversi):
(LOCALVERSION_AUTO) [Y/n/?] Y
<pre># aptitude purge fglrx-driver fglrx-kernel-src fglrx-control fglrx-kernel-2.6.17-2-686</pre>
...</pre>
}}
Il programma di configurazione del kernel procederà attraverso ogni opzione di configurazione e chiederà se la si vuole abilitare o meno. Tipicamente, le possibilità per ogni opzione sono presentate nella forma <tt>[Y/m/n/?]</tt>. La lettera maiuscola è la scelta predefinita, e può essere selezionata semplicemente premendo il tasto Invio. Le quattro scelte sono:
* <tt>Y</tt>  Compilare direttamente nel kernel.
* <tt>n</tt>   Lasciare completamente al di fuori del kernel.
* <tt>m</tt>   Compilare come modulo, da caricare se necessario.
* <tt>?</tt>   Stampa un breve messaggio descrittivo e ripropone il quesito.
Il kernel contiene quasi duemila opzioni di configurazioni differenti, quindi rispondere ad una domanda su ognuna di esse richiede un notevole dispendio di tempo. Fortunatamente, vi è un modo più facile di configurare un kernel: basare la configurazione su di un'altra precostituita.


== Metodologie di installazione ==
==='''Opzioni della configurazione predefinita'''===
Ogni versione del kernel ha una configurazione "predefinita". Questa configurazione è in parte basata sulle scelte che il responsabile di quella architettura crede siano le opzioni migliori da essere usate. In alcuni casi, è la configurazione usata dal responsabile stesso sulle proprie macchine. Questo è vero per l'architettura i386, dove la configurazione predefinita corrisponde strettamente a quella che Linus Torvalds usa per la sua macchina di sviluppo principale.


Per quanto riguarda l'intallazione di quelli nuovi, esistono essenzialmente <u>3 metodi alternativi</u>:
Per creare questa configurazione predefinita, eseguite:
# usare l'eseguibile Ati
<pre>$ cd linux-2.6.17.10
# creare i pacchetti ''.deb'' partendo dall'eseguibile Ati
$ make defconfig</pre>
# installare i driver dai repository
Un'enorme quantità di opzioni di configurazione scorrerà velocemente sullo schermo, e un file ''.config'' sarà creato e piazzato nella cartella del kernel. Il kernel è ora correttamente configurato, ma dovrebbe essere adattato alla vostra macchina per assicurarsi che funzioni correttamente.


=== Intallazione attraverso l'installer ATI ===
==='''Modificare la configurazione'''===
Ora che abbiamo un file di configurazione di base, dovrebbe essere modificato per supportare l'hardware presente nel vostro sistema. Per ulteriori dettagli su come individuare quali opzioni siano necessarie per ottenere ciò, potete leggere il [[LKN:_Personalizzare_un_Kernel|Capitolo 7]]. Qui mostreremo come selezionare le opzioni che potreste voler cambiare.


Da un terminale spostatevi nella cartella dove avete scaricato il file e date i permessi di esecuzione:
Ci sono tre differenti strumenti interattivi per la configurazione del kernel: uno basato su terminale chiamato ''menuconfig'', uno grafico basato sulle GTK+ chiamato ''gconfig'', e un altro grafico basato sulle QT chiamato ''xconfig''.
<pre>$ chmod +x ati-driver-installer-8.26.18-x86.run</pre> quindi, da root:
<pre># sh ./ati-driver-installer-8.26.18.x86.run</pre>
e seguite le istruzioni.
Poi, sempre con i permessi di root, aggiornate il file di configurazione <tt>xorg.conf</tt>:
<pre># cd /etc/X11/
# aticonfig --initial
# aticonfig --overlay-type=Xv</pre>
e se volete settare meglio la configurazione:
<pre># aticonfig</pre>
il quale ci dar� un lungo output con la descrizione di tutte le opzioni che possiamo usare con <tt>aticonfig</tt>.


A questo punto non ci resta che compilare il modulo del kernel fglrx. I metodi possono essere 2:
==='''Configurazione tramite terminale'''===
Il metodo chiamato '''menuconfig''' per configurare un kernel è un programma per terminale che dà modo di muoversi nella configurazione del kernel usando i tasti freccia della tastiera. Per avviare questa modalità di configurazione, digitate:
<pre>$ make menuconfig</pre>
Vi apparirà una schermata molto simile a quella di figura 4-1.


1) Usare module-assistant un pacchetto fornito per compilare moduli contenenti nel kernel-headers
[[Immagine:Menuconfig_1.png|center|500px|thumb|''Figura 4-1. Schermata iniziale di menuconfig'']]


2) Compilare a mano il modulo.
Le istruzioni per navigare attraverso il programma, e i significati dei diversi caratteri, sono mostrati in cima allo schermo. Il resto dello schermo contiene le diverse opzioni di configurazione.


Preferendo la seconda via perch� non richiede il pacchetto kernel-header e perch� applicabile a qualsiasi tipo di kernel sia quello distribuito dai debian repository che i kernel vanilla di www.kernel.org il metodo � il seguente:
La configurazione del kernel è divisa in sezioni. Ogni sezione contiene opzioni che corrispondo ad argomenti specifici. Al loro interno possono esserci sottosezioni per vari argomenti specifici. Per esempio tutti i driver per le periferiche possono essere trovati sotto l'opzione del menu principale <tt>Device Drivers ---></tt>.


Spostarci nella directory /lib/module/fglrx/build_mod da utenti root:
[[Immagine:Menuconfig_2.png|center|500px|thumb|''Figura 4-2. Selezione dell'opzione Device Drivers'']]


In questa directory adesso basta lanciare
Per aprire questo menu, premete la freccia in basso nove volte, finché la riga <tt>Device Drivers ---></tt> non è sottolineata, come mostrato in figura 4-2.


<pre>./make.sh</pre>
Premete poi il tasto Invio. Vi porterà nel sotto-menu <tt>Device Drivers</tt> e lo mostrerà come mostrato nella figura 4-3.


Accertarsi che tutto sia andato a buon fine con una scritta "done" e poi spostarci nella directory precedente a build_mod ovvero /lib/modules/fglrx
[[Immagine:Menuconfig_3.png|center|500px|thumb|''Figura 4-3. Sottomenu Device Drivers'']]
A questo punto lanciare il comando


<pre>./make_install.sh </pre>
Potete continuare a muovervi nella gerarchia dei menu allo stesso modo. Per visualizzare il sotto-menu <tt>Generic Driver Options</tt> premete Invio di nuovo, e vedrete se tre opzioni mostrate in figura 4-4.


Se tutto � andato a buon fine avete compilato il vostro bel modulo fglrx e per evitare di riavviare il sistema basta semplicemente entrare in linea di comando con CTRL + ALT + F1, effettuare il login come utente root e poi digitare
[[Immagine:Menuconfig_4.png|center|500px|thumb|''Figura 4-4. Sottomenu Generic Driver Options'']]


<pre> /etc/init.d/gdm o kdm stop </pre>
Le prime due opzioni hanno un simbolo <tt>[*]</tt> vicino a esse. Questo significa che quest'opzione è selezionata (perché il simbolo <tt>*</tt> sta al centro dei due caratteri <tt>[]</tt>), e che questa è un'opzione del tipo sì-o-no. La terza opzione ha un segno <tt>< ></tt>, che mostra che questa opzione può essere inserita nel kernel (<tt>Y</tt>), compilata come modulo (<tt>M</tt>), o esclusa del tutto (<tt>N</tt>).


montare il modulo fglrx con  
Se l'opzione è selezionata con <tt>Y</tt>, le parentesi ad angolo conterranno un <tt>*</tt>. Se è selezionata come modulo con una <tt>M</tt>, conterranno una lettera <tt>M</tt>. Se è disabilitata con <tt>N</tt>, mostreranno solo uno spazio bianco.


<pre> modprobe fglrx </pre>
Così, se desiderate cambiare queste tre opzioni per selezionare solo driver che non necessitano di firmware esterno in tempo di compilazione, disabilitate l'opzione per impedire che il firmware sia compilato, e compilate il caricatore del firmware in spazio utente come modulo, digitando <tt>Y</tt> per la prima opzione, <tt>N</tt> per la seconda e <tt>M</tt> per la terza, rendendo la schermata come quella in figura 4-5.


e riavviare il sistema
[[Immagine:Menuconfig_5.png|center|500px|thumb|''Figura 4-5. Sottomenu Generic Driver Options cambiato'']]


<pre> /etc/init.d/gdm o kdm restart </pre>
Quando avete completato le vostre modifiche in questa schermata, premete il tasto Esc o la freccia destra seguita dal tasto Invio per lasciare questo sottomenu. Tutte le opzioni del kernel possono essere esplorate in questa maniera.


Per controllare che la vostra accelerazione 3D funzioni basta digitare da shell come utente normale
Quando avete finito di fare tutte le modifiche che desideriate apportare alla configurazione del kernel, uscite dal programma premendo il tasto Esc quando siete nel menu principale.


<pre> fglrxinfo </pre>
[[Immagine:Menuconfig_6.png|center|500px|thumb|''Figura 4-6. Salvare le opzioni del kernel'']]
Nel mio caso l'output � il seguente:


<pre>display: :0.0  screen: 0
Vi sarà mostrata la schermata in figura 4-6, che vi chiede se desiderate salvare la vostra modificata configurazione.
OpenGL vendor string: ATI Technologies Inc.
OpenGL renderer string: ATI Radeon Xpress Series
OpenGL version string: 2.0.6473 (8.37.6)</pre>


<pre>glxinfo | grep rendering </pre>
Premete Invio per salvare la configurazione, o, se volete eliminare ogni modifica fatta, digitate la freccia destra per selezionare la voce <tt>< No ></tt> e premete Invio.


e aspettare che vi dia come output


<pre>direct rendering: Yes</pre>
==='''Metodi grafici di configurazione'''===
I metodi di configurazione del kernel ''gconfig'' e ''xconfig'' usano un programma grafico per permettervi di modificare la configurazione. I due metodi sono pressoché identici, l'unica differenza risiede nei diversi strumenti grafici attraverso i quali sono scritti. ''gconfig'' è scritto usando il toolkit GTK+ e ha uno schermo diviso in due regioni, come mostrato in figura 4-7.


N.B.: Se non avete glxinfo installare il pacchetto mesa-utils
[[Immagine:Gconfig_1.png|center|500px|thumb|''Figura 4-7. Schermata di make gconfig'']]


Questo metodo risulta pi� semplice ed efficace della pacchettizzazione. Se usate kernel vanilla la procedura � la medesima. Attenzione ad usare i kernel 2.6.20 poich� hanno un bug e quindi viene corretto da una patch al modulo fglrx.Tale patch � possibile trovarla in rete.
Il metodo ''xconfig'' è scritto usando il toolkit QT e ha uno schermo diviso in tre regioni, come in figura 4-8.


===Installazione manuale con generazione pacchetti specifici per Debian===
[[Immagine:Xconfig_1.png|center|500px|thumb|''Figura 4-8. Schermata di make xconfig'']]


Con i privilegi di root, rimuoviamo i vecchi pacchetti del modulo <tt>fglrx</tt>, se presenti:
Usate il mouse per navigare nei sottomenu e selezionare le opzioni. Per esempio, nella figura 4-8 potreste usarlo per selezionare il sottomenu <tt>Generic Driver Options</tt> del menu <tt>Device Drivers</tt>. Questo cambierà la schermata di ''xconfig'' e la farà diventare quella dell'immagine 4-9.  
<pre># rm /usr/src/fglrx-kernel*.deb</pre>
E' necessario installare i seguenti pacchetti:
<pre># apt-get install module-assistant build-essential fakeroot dh-make debconf libstdc++5 gcc-3.4-base</pre>
Spostiamoci nella cartella dove abbiamo scaricato l'eseguibile Ati e diamogli i permessi di esecuzione:
<pre>$ chmod +x ati-driver-installer-8.26.18-x86.run</pre>
Poi, per creare i 5 pacchetti .deb:
<pre>$ sh ./ati-driver-installer-8.26.18-x86.run --buildpkg Debian/[release]</pre>
Ad esempio:
<pre>$ sh ./ati-driver-installer-8.26.18-x86.run --buildpkg Debian/testing</pre>
Per installarli (installiamo solo quelli fondamentali):
<pre>$ su
Password:
# dpkg -i fglrx-driver_8.26.18-1_i386.deb
# dpkg -i fglrx-kernel-src_8.26.18-1_i386.deb
# dpkg -i fglrx-control_8.26.18-1_i386.deb</pre>


====Compilazione del modulo <tt>fglrx</tt>====
[[Immagine:Xconfig_2.png|center|500px|thumb|''Figura 4-9. Generic Driver Options in make xconfig'']]


Adesso va compilato il modulo <tt>fglrx</tt>, con <tt>module-assistant</tt> (m-a):
La corrispondente immagine di ''gconfig'' è in figura 4-10.
<pre># m-a prepare
# m-a update
# m-a build fglrx
# m-a install fglrx
# depmod -a</pre>
Quindi muoviamoci in <tt>/etc/X11/</tt>:
<pre># cd /etc/X11/</pre>
e aggiorniamo il file di configurazione di X:
<pre># aticonfig --initial
# aticonfig --overlay-type=Xv</pre>
Naturalmemte � possibile modificare <tt>etc/X11/xorg.conf</tt> anche a manina (per fare questo consultate...uhm, forse c'� qualche cosa in <tt>man xorg.conf</tt>) oppure consultando e usando <tt>aticonfig</tt>.


Riavviamo '''X'''.
[[Immagine:Gconfig_2.png|center|500px|thumb|''Figura 4-10. Generic Driver Options in make gconfig'']]


{{ Warningbox | Ad ogni aggiornamento del kernel bisogna ricompilare il modulo <tt>fglrx</tt>. }}
Modificare questo sottomenu per disabilitare la seconda opzione e rendere la terza opzione compilata come modulo genera le schermate apparire come nelle figure 4-11 e 4-12.


===Installazione dei driver dai repository===
[[Immagine:Xconfig_3.png|center|500px|thumb|''Figura 4-11. Generic Driver Options in make xconfig, modificato'']]
[[Immagine:gconfig_3.png|center|500px|thumb|''Figura 4-12. Generic Driver Options in make gconfig, modificato'']]


Innanzi tutto installiamo i pacchetti necessari:
Notate che nel metodo ''gconfig'' un riquadro con il segno di visto significa che l'opzione sarà compilata nel kernel, laddove una linea nel riquadro significa che l'opzione sarà compilata come modulo. Nel metodo ''xconfig'' un'opzione compilata come modulo sarà mostrata con un punto nel riquadro.
<pre># apt-get install fglrx-control fglrx-driver fglrx-driver-dev fglrx-kernel-src</pre>
Siccome il modulo di cui abbiamo bisogno (<tt>fglrx</tt>) � sotto forma di sorgenti (<tt>fglrx-kernel-src</tt>), lo compiliamo e lo installiamo utilizzando <tt>module-assistant</tt>, come descritto [[#Compilazione del modulo fglrx|qui]].


In teoria abbiamo finito, bisogna solamente configurare [[#Struttura del file xorg.conf|<tt>/etc/X11/xorg.conf</tt>]] e riavviare '''X'''.
Entrambi questi metodi vi chiedono di salvare la configurazione quando uscite dal programma, e offrono la possibilità di scrivere quella configurazione in un altro file. Potete così creare molteplici, distinte configurazioni.


'''Nota:''' Consultate anche il manuale di <tt>fglrx</tt> . ( <tt>man fglrx</tt> ).


== Struttura del file xorg.conf ==
=='''Compilazione del kernel'''==
Ora che avete creato la configurazione che intendete usare, dovete compilare il kernel. Questo è semplice come digitare un comando di un parola:
<pre>$ make
CHK include/linux/version.h
UPD include/linux/version.h
SYMLINK include/asm -> include/asm-i386
SPLIT include/linux/autoconf.h -> include/config/*
CC arch/i386/kernel/asm-offsets.s
GEN include/asm-i386/asm-offsets.h
CC scripts/mod/empty.o
HOSTCC scripts/mod/mk_elfconfig
MKELF scripts/mod/elfconfig.h
HOSTCC scripts/mod/file2alias.o
HOSTCC scripts/mod/modpost.o
HOSTCC scripts/mod/sumversion.o
HOSTLD scripts/mod/modpost.o
HOSTCC scripts/kallsyms
HOSTCC scripts/conmakehash
HOSTCC scripts/bin2c
CC init/main.o
CHK include/linux/compile.h
UPD include/linux/compile.h
CC init/version.o
CC init/do_mounts.o
...</pre>


Un esempio di <tt>/etc/X11/xorg.conf</tt>
Eseguire ''make'' fa sì che il sistema di compilazione del kernel usi il file di configurazione che avete selezionato per compilare un kernel e tutti i moduli necessari per supportare tale configurazione. Mentre il kernel è in compilazione, ''make'' mostra cosa sta correntemente succedendo ai singoli file, insieme a tutti gli avvertimenti ("warnings", N.d.T.) e gli errori di compilazioni.


<pre>
Se la compilazione del kernel termina senza errori, avete creato con successo l'immagine di un kernel. Comunque deve essere propriamente installata prima che proviate ad avviarla. Leggete il [[LKN:_Installare_ed_Avviare_con_un_Kernel|Capitolo 5]] per sapere come fare.


### /etc/X11/xorg.conf ###
È molto raro avere errori di compilazione quando state compilando una versione del kernel rilasciata. Se vi capita, riportateli agli sviluppatori del kernel Linux cosicché possano essere corretti.


Section "ServerLayout"
nota: Versioni del kernel più vecchie, precedenti al rilascio 2.6 richiedevano l'ulteriore passo ''make modules'' per compilare tutti i moduli necessari. Questo non è più necessario.
Identifier    "Default Layout"
Screen      0  "aticonfig-Screen[0]" 0 0
InputDevice    "Keyboard"
InputDevice    "Mouse"
InputDevice    "Touchpad"
EndSection


Section "Files"
=='''Opzioni di compilazione avanzate'''==
# path to defoma fonts
Il sistema di compilazione del kernel consente di fare molte altre cose, oltre a compilare l'intero kernel e i relativi moduli. Il Capitolo 10 contiene l'intero elenco delle opzioni che il sistema di compilazione fornisce. In questa sezione discuteremo alcune di queste opzioni avanzate. Per avere una descrizione completa di come usare altre opzioni avanzate, fate riferimento alla documentazione dentro il kernel stesso, che può essere trovata nella cartella ''Documentation/kbuild'' nei sorgenti.
FontPath    "/usr/share/fonts/X11/misc"
FontPath    "/usr/share/fonts/X11/100dpi/:unscaled"
FontPath    "/usr/share/fonts/X11/75dpi/:unscaled"
FontPath    "/usr/share/fonts/X11/Type1"
FontPath    "/usr/share/fonts/X11/100dpi"
FontPath    "/usr/share/fonts/X11/75dpi"
FontPath    "/var/lib/defoma/x-ttcidfont-conf.d/dirs/TrueType"
EndSection


Section "Module"
==='''Velocizzare la compilazione in macchine multiprocessore'''===
Load  "synaptics"
Il sistema di compilazione del kernel lavora molto bene come operazione che può essere divisa in pezzi più piccoli e assegnati a diversi processori. Facendo questo, potete usare la piena potenza di una macchina multiprocessore e ridurre considerevolmente il tempo di compilazione del kernel.
Load  "bitmap"
Load  "ddc"
Load  "dri"
Load  "extmod"
Load  "freetype"
Load  "glx"
Load  "int10"
Load  "type1"
Load  "vbe"
#      Load  "GLcore"
EndSection


Section "InputDevice"
Per compilare un kernel in modo parallelo, usate l'opzione ''-j'' del comando ''make''. È meglio dare un numero all'opzione ''-j'' che corrisponda al doppio del numero di processori nel sistema. Quindi, per macchine con due processori, usate:
Identifier  "Keyboard"
<pre>$ make -j4</pre>
Driver      "kbd"
e per macchine con quattro processori, usate:
Option     "CoreKeyboard"
<pre>$ make -j8</pre>
Option     "XkbRules" "xorg"
Se non passate un numero all'opzione ''-j'':
Option     "XkbModel" "pc105"
<pre>$ make -j</pre>
Option     "XkbLayout" "it"
il sistema di compilazione creerà un nuovo filo ("thread", N.d.T.) per ogni sottocartella nell'albero delle cartelle del kernel, che può facilmente rendere la vostra macchina non in grado di rispondere ai comandi, e impiegare molto più tempo per completare la compilazione. Per questo si raccomanda di passare sempre un valore numerico all'opzione ''-j''.
EndSection


Section "InputDevice"
==='''Compilare solo una parte del kernel'''===
Identifier  "Mouse"
Quando ci si dedica allo sviluppo del kernel, a volte si desidera compilare solo una specifica sottocartella, o un singolo file dell'intero albero del kernel. Il sistema di compilazione lo consente agevolmente. Per compilare selettivamente una sottocartella, specificatela nel comando di compilazione. Per esempio, per compilare i file nella cartella '''drivers/usb/serial''', inserite: <pre>$ make drivers/usb/serial</pre>
Driver      "mouse"
Usando questa sintassi, comunque, non si compilerà l'immagine finale del modulo in quella cartella. Per fare questo, potete usare l'opzione <tt>M=</tt>argomento:<pre>$ make M=drivers/usb/serial</pre>che compilerà tutti i file necessari in quella cartella e collegherà le immagini finali dei moduli.
Option     "CorePointer"
Option     "Device" "/dev/input/mice"
Option     "Protocol" "ExplorerPS/2"
Option     "Emulate3Buttons" "true"
EndSection


Section "InputDevice"
Quando si compila una singola cartella in uno dei modi mostrati, l'immagine finale del kernel non viene ricollegata. Comunque ogni cambiamento che era stato effettuato alle sottocartelle non influenzerà l'immagine finale del kernel, che probabilmente non è quello che desiderate. Eseguite alla fine un:<pre>$ make</pre> perché il sistema di compilazione controlli tutti i file oggetto cambiati e colleghi in modo proprio l'immagine finale del kernel.
Identifier  "Touchpad"
Driver      "synaptics"
Option     "Device" "/dev/psaux"
Option     "Protocol" "auto-dev"
Option     "LeftEdge" "1700"
Option     "RightEdge" "5300"
Option     "TopEdge" "1700"
Option     "BottomEdge" "4200"
Option     "FingerLow" "25"
Option     "FingerHigh" "30"
Option     "MaxTapTime" "180"
Option     "MaxTapMove" "220"
Option     "VertScrollDelta" "100"
Option     "MinSpeed" "0.10"
Option     "MaxSpeed" "0.30"
Option     "AccelFactor" "0.0150"
Option     "SHMConfig" "on"
        Option      "AlwaysCore" "true"
EndSection


Section "Monitor"
Per compilare un solo specifico file nell'albero del kernel, semplicemente passatelo come parametro a ''make''. Per esempio, se desiderate compilare il modulo ''drivers/usb/serial/visor.ko'', inserite:<pre>$ make drivers/usb/serial/visor.ko</pre>
Identifier  "aticonfig-Monitor[0]"
Il sistema di compilazione compilerà tutti i file necessari per il modulo visor.ko, e farà il collegamento finale per creare il modulo.
HorizSync    30.0 - 70.0
VertRefresh  50.0 - 100.0
Option     "VendorName" "ATI Proprietary Driver"
Option     "ModelName" "Generic Autodetecting Monitor"
Option     "DPMS" "true"
EndSection


Section "Monitor"
==='''Sorgente in un posto, destinazione in un altro'''===
Identifier  "aticonfig-Monitor[1]"
Alle volte è più semplice avere i sorgenti del kernel in un posto accessibile in sola lettura (come un CD-ROM, o in un sistema di controllo del codice sorgente), e collocare il risultato della compilazione altrove, così da non alterare l'albero originale del sorgente. Il sistema di compilazione lo realizza facilmente, richiedendo il solo argomento <tt>O=</tt> per specificare dove collocare l'output della compilazione. Per esempio se i sorgenti del kernel sono in un CD-ROM montato in ''/mnt/cdrom/'' e desiderate mettere i file compilati nella vostra cartella locale, inserite:<pre>$ cd /mnt/cdrom/linux-2.6.17.11
Option     "DPMS" "true"
$ make O=~/linux/linux-2.6.17.11</pre>
EndSection
Tutti i file compilati saranno creati nella cartella ''~/linux/linux-2.6.17.11''. Notate che questa opzione <tt>O=</tt> dovrebbe essere passata anche alle opzioni di configurazione della compilazione cosicché la configurazione sia correttamente collocata nella cartella di destinazione e non in quella contenente il codice sorgente.


Section "Device"
==='''Architetture differenti'''===
Identifier  "aticonfig-Device[0]"
Una caratteristica molto utile è la costruzione di un kernel in una compilazione incrociata, per permettere a una macchina più potente di compilare un kernel per una sistema integrato più piccolo, o anche solo per controllare una compilazione per un'architettura diversa per assicurare che a un cambiamento nel codice sorgente non danneggi qualcosa di inaspettato. Il sistema di compilazione del kernel consente di specificare un'architettura diversa da quella della macchina corrente con il parametro <tt>ARCH=</tt>argomento. Il sistema di compilazione consente, inoltre, di specificare il compilatore che si desidera usare con il parametro <tt>CC=</tt>argomento o uno strumento per concatenare ("toolchain", N.d.T.) la compilazione incrociata con <tt>CROSS_COMPILE</tt> argomento.
Driver      "fglrx"
Option     "VideoOverlay" "on"
Option     "OpenGLOverlay" "off"
Option     "DesktopSetup" "horizontal,reverse"
BusID      "PCI:1:0:0"
EndSection


Section "Screen"
Per esempio, per avere la configurazione predefinita dell'architettura x86_64, si può inserire:
Identifier "aticonfig-Screen[0]"
Device    "aticonfig-Device[0]"
Monitor    "aticonfig-Monitor[0]"
DefaultDepth    24
SubSection "Display"
Viewport  0 0
Depth    24
Modes    "1280x800" "1280x1024" "1024x768" "800x600" "640x480"
EndSubSection
EndSection


Section "DRI"
<pre>$ make ARCH=x86_64 defconfig</pre>
Mode        0666
EndSection


### End Of File ###
Per compilare l'intero kernel con uno strumento per concatenare la compilazione situato in ''/usr/local/bin'', si può inserire:
</pre>
<pre>$ make ARCH=arm CROSS_COMPILE=/usr/local/bin/arm-linux-</pre>


== Alcuni Test ==
È utile anche per i kernel non ottenuti con compilazione incrociata cambiare ciò che il sistema di costruzione del kernel usa per il compilatore. Esempi di questo sono l'utilizzo dei programmi ''distcc'' o ''ccache'', i quali riducono notevolmente il tempo di compilazione di un kernel. Per usare il programma ''ccache'' come parte del sistema di costruzione del kernel, digitate:


Per verificare se abbiamo installato tutto correttamente:
<pre>$ make CC="ccache gcc"</pre>
<pre>$ fglrxinfo</pre>
dovrebbe dare un output simile a questo:
<pre>display: :0.0  screen: 0
OpenGL vendor string: ATI Technologies Inc.
OpenGL renderer string: MOBILITY RADEON 9700 Generic
OpenGL version string: 2.0.5879 (8.26.18)</pre>
Se al posto di ATI compare Mesa, c'� qualcosa che non va. L'installazione non � andata a buon fine.


Per testare l'accelerazione:
Per usare contemporaneamente ''distcc'' e ''ccache'', inserite:
<pre>$ fgl_glxgears</pre>
Dovrebbe comparire un cubo rotante con sulle sei faccie degli ingranaggi rotanti e, sul terminale la conta dei frame:
<pre>Using GLX_SGIX_pbuffer
1610 frames in 5.0 seconds = 322.000 FPS
1640 frames in 5.0 seconds = 328.000 FPS
2093 frames in 5.0 seconds = 418.600 FPS</pre>
Se invece compaiono 4-5 righe di errori, c'� qualcosa che non va. L'installazione non � andata a buon fine. Ritenta, forse sarai pi� fortunat*.


Per testare l'accelerazione � possibile utilizzare anche i tools di Mesa:
<pre>$ make CC="ccache distcc"</pre>
<pre># apt-get install mesa-utils
$ glxgears -printfps</pre>
Appaiono tre ingranaggi rotanti e la conta dei fotogrammi:
<pre>14045 frames in 5.0 seconds = 2808.862 FPS
14115 frames in 5.0 seconds = 2822.858 FPS
14196 frames in 5.0 seconds = 2839.177 FPS</pre>


==File di log==
l file di log principale '''<tt>/var/log/Xorg.0.log</tt>''' e seguenti. Da spulciare, analizare, bruciare, supplicare. Insomma qui c' di tutto di pi. Ma a volte si pu anche non trovare nulla di anomalo e magari <tt>fgl_glxgears</tt> non funziona lo stesso. 8(
Se abbiamo installato i driver con l'installer Ati, esiste anche questo piccolo log:  <tt>/usr/share/fglrx/fglrx-install.log</tt>
== Tips and Tricks ==
* Una cosa importante, ma che resta comunque strana, scrivere, in <tt>/etc/X11/xorg.conf</tt>, i moduli <tt>dri</tt>, <tt>glx</tt> e <tt>GLcore</tt>, in questo ordine. Se ad esempio si mette <tt>GLcore</tt> per primo, l'accelerazione non andr e il log <tt>/var/log/Xorg.0.log</tt> riporter una serie di errori, tra cui warning sulla libreria <tt>/usr/lib/xorg/modules/extensions/libGLcore.so</tt> e  un errore verso la fine, tristemente incorniciato. Questo errore non so se sia circoscritto alla mia configurazione o se sia un cosa generale. L'unica cosa fare un po' di test.
* A volte si ottengono risultati migliori installando i driver con '''X non avviato'''.
* Se i driver sono molto recenti il modulo <tt>GLcore</tt> non bisognerebbe inserirlo in <tt>/etc/X11/xorg.conf</tt> : viene caricato automaticamente.
* Aggiornando le librerie Mesa (<tt>libgl1-mesa-dri</tt> oppure <tt>libgl1-mesa-glx</tt> ad esempio), ahim, pu capitare che l'accelerazione sparisca all'improvviso. L'unica cosa da fare probabilmente disinstallare i driver e installarli di nuovo.
* Per quanto riguarda le trasparenze di KDE, credo non siano supportate a livello hardware. Io non sono riuscito ad attivarle, infatti se aggiungo a <tt>/etc/X11/xorg.conf</tt> la sezione:
<pre>Section "Extensions"
Option "Composite" "Enable"
EndSection</pre>
l'accelerazione 3D non viene caricata.


----
This is an indipendent translation of the book [http://www.kroah.com/lkn/ Linux Kernel in a Nutshell] by [http://www.kroah.com/log/ Greg Kroah-Hartman]. This translation (like the original work) is available under the terms of [http://creativecommons.org/licenses/by-sa/2.5/ Creative Commons Attribution-ShareAlike 2.5].
----
----


Autore: [[User:rasca|rasca]] 09:04, 17 July 2006 (CEST)
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/ch04.pdf ''Capitolo originale'']
 
Ampliato da: [[Utente:Superflieriam|Superflieriam]]
 
Alcune correzioi da: [[Utente:ENtRoPiA|ENtRoPiA]] 11:31, 9 July 2007
 
[[Categoria:Hardware]]
[[Categoria:Desktop]]
[[Categoria:Kernel]]
[[Categoria:Kernel]]
TheNoise
1 760

contributi

Estratto da "https://guide.debianizzati.org/index.php/Speciale:DiffMobile/14918"

Menu di navigazione