https://guide.debianizzati.org/api.php?action=feedcontributions&user=TheNoise&feedformat=atomGuide@Debianizzati.Org - Contributi dell'utente [it]2024-03-28T12:23:07ZContributi dell'utenteMediaWiki 1.39.5https://guide.debianizzati.org/index.php?title=Old:Debian_su_HP_Compaq_nx6325&diff=14980Old:Debian su HP Compaq nx63252007-10-27T14:50:40Z<p>TheNoise: inserita categoria</p>
<hr />
<div>Questa guida rappresenta la mia configurazione di Debian su un portatile HP Compaq nx6325. Suggerimenti e miglioramenti sono bene accetti. L'ultima modifica risale al 24 ottobre 2007.<br />
<br />
== Guide HP ==<br />
<br />
Il sito HP mette a disposizione [http://h20000.www2.hp.com/bizsupport/TechSupport/DocumentIndex.jsp?contentType=SupportManual&lang=en&cc=us&docIndexId=179111&taskId=135&prodTypeId=321957&prodSeriesId=1849082 numerose guide], basate però su Windows, riguardanti questo portatile.<br />
<br />
== Hardware ==<br />
<br />
Esistono diverse versioni dell'HP Compaq nx6325. Una [http://h18000.www1.hp.com/products/quickspecs/12447_div/12447_div.HTML lista completa dei componenti] è offerta dal sito HP. A meno che il processore non sia un Sempron, si tratta di un processore a 64bit. Per fortuna Debian offre senza battere ciglio una versione amd64.<br />
<br />
Nel mio caso i principali componenti sono:<br />
<br />
* Processori: AMD Turion 64 X2 Dual-Core Mobile Processor TL-60 (2.0-GHz, 2 x 512-KB L2 cache)<br />
* Memoria RAM: 1024 MB (slot 1); dato che uno slot 2 è disponibile, ho aggiunto altri 1024 MB di RAM<br />
* Scheda Video: ATI Radeon Xpress 200M (alias 1150), 128 MB di memoria<br />
* Scheda Audio: ATI Technologies Inc SB450 HDA Audio<br />
* Scheda Ethernet: Broadcom NetXtreme BCM 5788 Gigabit Ethernet<br />
* Scheda Wireless: Broadcom BCM 4310 802.11 a/b/g (BCM 4310 è ciò che lspci mostra; il sito HP dice che si tratta di una BCM 4311).<br />
<br />
Il laptop è dotato di un lettore di schede di memoria 7-in-1 e di un lettore per impronta digitale.<br />
<br />
=== Hardware testato e funzionante ===<br />
<br />
* Scheda video ATI Radeon Xpress 200M: funziona con i driver ati (xserver-xorg-video-ati), ma per l'accelerazione 3D bisogna usare i [[Installazione_driver_proprietari_Ati|driver proprietari ATI]].<br />
* Scheda audio ATI Technologies Inc SB450 HDA Audio: funziona con il driver snd_hda_intel.<br />
* Touchpad Synaptics: da configurare in xorg.conf come in [[Synaptics_touchpad|questa guida]].<br />
* Wireless Broadcom BCM4310: funziona decentemente con il driver bcm43xx; viene riportato che su ubuntu ([http://www.ludreb.plus.com/ubuntuguide.html#6] e [http://vale.homelinux.net/wordpress/?p=106]) funziona meglio l'[[ndisWrapper]].<br />
* Pulsanti multimediali: configurati con xbindkeys.<br />
<br />
=== Hardware non testato ===<br />
<br />
* Sensore per impronta digitale AuthenTec AES 2501: secondo [http://www.thinkwiki.org/wiki/How_to_enable_the_fingerprint_reader questa guida] funziona.<br />
* Lettore di card 7-in-1: su [http://gentoo-wiki.com/HARDWARE_Gentoo_on_HP_Compaq_nx6325#Onboard_cardreader Gentoo] funziona.<br />
* Modem interno<br />
* FireWire<br />
* BlueTooth<br />
<br />
=== lspci ===<br />
<br />
Host bridge: ATI Technologies Inc RS480 Host Bridge (rev 10)<br />
PCI bridge: ATI Technologies Inc RS480 PCI Bridge<br />
PCI bridge: ATI Technologies Inc RS480 PCI Bridge<br />
PCI bridge: ATI Technologies Inc Unknown device 5a37<br />
PCI bridge: ATI Technologies Inc RS480 PCI Bridge<br />
IDE interface: ATI Technologies Inc ATI 4379 Serial ATA Controller (rev 80)<br />
USB Controller: ATI Technologies Inc IXP SB400 USB Host Controller (rev 80)<br />
USB Controller: ATI Technologies Inc IXP SB400 USB Host Controller (rev 80)<br />
USB Controller: ATI Technologies Inc IXP SB400 USB2 Host Controller (rev 80)<br />
SMBus: ATI Technologies Inc IXP SB400 SMBus Controller (rev 81)<br />
IDE interface: ATI Technologies Inc Standard Dual Channel PCI IDE Controller ATI (rev 80)<br />
Audio device: ATI Technologies Inc SB450 HDA Audio (rev 01)<br />
ISA bridge: ATI Technologies Inc IXP SB400 PCI-ISA Bridge (rev 80)<br />
PCI bridge: ATI Technologies Inc IXP SB400 PCI-PCI Bridge (rev 80)<br />
Host bridge: Advanced Micro Devices [AMD] K8 [Athlon64/Opteron] HyperTransport Technology Configuration<br />
Host bridge: Advanced Micro Devices [AMD] K8 [Athlon64/Opteron] Address Map<br />
Host bridge: Advanced Micro Devices [AMD] K8 [Athlon64/Opteron] DRAM Controller<br />
Host bridge: Advanced Micro Devices [AMD] K8 [Athlon64/Opteron] Miscellaneous Control<br />
VGA compatible controller: ATI Technologies Inc RS482 [Radeon Xpress 200M]<br />
Ethernet controller: Broadcom Corporation NetXtreme BCM5788 Gigabit Ethernet (rev 03)<br />
CardBus bridge: Texas Instruments PCIxx12 Cardbus Controller<br />
FireWire (IEEE 1394): Texas Instruments PCIxx12 OHCI Compliant IEEE 1394 Host Controller<br />
Mass storage controller: Texas Instruments 5-in-1 Multimedia Card Reader (SD/MMC/MS/MS PRO/xD)<br />
Generic system peripheral [0805]: Texas Instruments PCIxx12 SDA Standard Compliant SD Host Controller<br />
Network controller: Broadcom Corporation BCM4310 UART (rev 01)<br />
<br />
== Kernel ==<br />
<br />
Il mio kernel è un 2.6.22.9 customizzato.<br />
<br />
=== Kernel 2.6.22 ===<br />
<br />
Opzioni rilevanti sono le seguenti:<br />
* Processore<br />
<pre>Processor Family ---><br />
<*> AMD-Opteron/Athlon64<br />
[*] Symmetric multi-processing support<br />
[*] SMT (Hyperthreading) scheduler support<br />
[*] Multi-core scheduler support</pre><br />
* Scheda wireless, se volete usare il driver broadcom compreso nel kernel:<br />
<pre>Network device support ---><br />
Wireless LAN ---><br />
[*] Broadcom BCM43xx wireless support</pre><br />
<br />
=== ACPI ===<br />
<br />
Il supporto basta abilitarlo nel kernel; personalmente i moduli AC Adapter, Battery, Button, Video, Fan, Processor, Thermal Zone. Con un kernel come 2.6.22 non ho avuto problemi.<br />
<br />
== Configurazioni ==<br />
<br />
=== xorg.conf, ATI e accelerazione 3D ===<br />
<br />
Per avere l'accelerazione 3D bisogna usare i [[Installazione_driver_proprietari_Ati|driver ATI]]. Il più recente è alla versione 8.40.4 per linux a 64-bit. Per l'installazione del driver consiglio quella manuale con la creazione dei pacchetti.<br />
<br />
Una volta installato il driver xorg.conf dovrebbe avere sezioni come queste:<br />
Section "Module"<br />
Load "i2c"<br />
Load "bitmap"<br />
Load "ddc"<br />
Load "dri"<br />
Load "extmod"<br />
Load "freetype"<br />
Load "glx"<br />
Load "int10"<br />
Load "vbe"<br />
Load "GLcore"<br />
EndSection<br />
...<br />
Section "Device"<br />
Identifier "Ati Device"<br />
Driver "fglrx"<br />
Option "VideoOverlay" "on"<br />
Option "OpenGLOverlay" "off"<br />
BusID "PCI:1:5:0"<br />
EndSection<br />
...<br />
Section "DRI"<br />
Mode 0666<br />
EndSection<br />
<br />
Section "Extensions"<br />
Option "Composite" "Disable"<br />
EndSection<br />
<br />
Per il touchpad Synaptics:<br />
Section "InputDevice"<br />
Identifier "Synaptics Touchpad"<br />
Driver "synaptics"<br />
Option "SendCoreEvents" "true"<br />
Option "Device" "/dev/psaux"<br />
Option "Protocol" "auto-dev"<br />
Option "HorizScrollDelta" "0"<br />
EndSection<br />
<br />
=== Audio e ALSA ===<br />
<br />
L'audio non dà problemi. La configurazione segue la norma<br />
# apt-get install alsa-base alsa-utils<br />
# alsaconf<br />
<br />
=== Boot e APIC ===<br />
<br />
Mi capita che APIC riempia i log con errori sulle due CPU:<br />
APIC error on CPU0: 40(40)<br />
APIC error on CPU1: 40(40)<br />
APIC error on CPU0: 40(40)<br />
APIC error on CPU1: 40(40)<br />
...<br />
<br />
Se nelle opzioni di boot viene aggiunto '''-noapic -nolapic''' succede che viene rilevato un solo processore. Per ora mi tengo gli errori sulle CPU!<br />
<br />
=== Wireless ===<br />
<br />
La scheda wireless funziona abbastanza bene con il driver bcm43xx compreso nel kernel (>= 2.6.21). Mi succede che non riceva sempre offerte dhcp quando tento di connettermi e mi è stato consigliato l'ndiswrapper.<br />
<br />
=== xbindkeys per l'audio === <br />
<br />
La configurazione di xbindkeys per i tre pulsanti audio in alto a destra è come segue.<br />
Il file di configurazione è ~/.xbindkeysrc.<br />
<pre># Volume up<br />
"amixer set Master 4+"<br />
m:0x0 + c:176<br />
<br />
# Volume down<br />
"amixer set Master 4-"<br />
m:0x0 + c:174<br />
<br />
# Mute<br />
"muter"<br />
m:0x0 + c:160</pre><br />
<br />
Il programma 'muter' è un piccolo script shell che mi sono scritto:<br />
<pre><br />
#!/bin/sh<br />
#<br />
# amix muter for HP Compaq nx6325<br />
# Francesco Marass - 2007 May 22<br />
# fmarass@uvic.ca<br />
#<br />
STATE=`amixer get Master | grep "Front Left" | grep "\[on\]"`<br />
if [ -z "$STATE" ]; then<br />
amixer -q set Master unmute<br />
else<br />
amixer -q set Master mute<br />
fi<br />
exit 0;<br />
</pre><br />
<br />
== Ringraziamenti ==<br />
<br />
Nello scrivere la prima versione di questa guida ho fatto riferimento alle pagine:<br />
*[[Debian_on_a_HP_Compaq_NX6110|Debian su HP Compaq nx6110]],<br />
*[http://gentoo-wiki.com/HARDWARE_Gentoo_on_HP_Compaq_nx6325 Gentoo su HP Compaq nx6325].<br />
<br />
== Links utili ==<br />
<br />
* [http://h18000.www1.hp.com/products/quickspecs/12447_div/12447_div.HTML HP - Specifiche del portatile]<br />
* [http://h20000.www2.hp.com/bizsupport/TechSupport/DocumentIndex.jsp?contentType=SupportManual&lang=en&cc=us&docIndexId=179111&taskId=135&prodTypeId=321957&prodSeriesId=1849082 HP - Manuali]<br />
* [http://h20000.www2.hp.com/bizsupport/TechSupport/SoftwareIndex.jsp?lang=en&cc=us&prodNameId=3315736&prodTypeId=0&prodSeriesId=1849082&swLang=8&taskId=135&swEnvOID=181 HP - Drivers Download]<br />
* [http://www.puchalla-online.de/nx6325.html Puchalla Online - Debian su HP Compaq nx6325]<br />
<br />
----<br />
Autore: [[Utente:Francys|Francys]] | 23 ottobre 2007<br />
<br />
[[Categoria:Laptop]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Attivare_le_quote_su_un_filesystem&diff=14935Attivare le quote su un filesystem2007-08-22T19:02:52Z<p>TheNoise: aggiunte categorie</p>
<hr />
<div>In questo articolo vedremo come attivare il supporto per le quote.<br />
Nell'esempio supporrò che /home sia montato su /dev/hda5.<br />
<br />
== Introduzione ==<br />
'''A cosa servono le quote?''' Servono a limitare lo spazio di disco che gli utenti possono utilizzare.<br />
Nel caso di sistemi con più utenti, il loro utilizzo è utile perché permette di impedire che pochi utenti occupino tutto lo spazio disponibile, a discapito degli altri.<br />
Le quote possono servire per impostare la dimensione massima che un utente può utilizzare, e per impostare il numero massimo di file (inodes) che può salvare. Questo perché anche i file vuoti occupano spazio su disco.<br />
<br />
== Requisiti ==<br />
Per prima cosa occorre che il kernel abbia il supporto per le quote. I kernel precompilati hanno tale supporto.<br />
Se invece state usando un kernel compilato da voi, assicuratevi di aver incluso il supporto alle quote.<br />
<br />
<br />
== Modificare /etc/fstab ==<br />
Per prima cosa dobbiamo abilitare le quote sul filesystem che ci interessa (solitamente si attivano sulla partizione che contiene le cartelle home).<br />
<br />
/dev/hda5 /home ext3 defaults,usrquota,grpquota 0 2<br />
<br />
'''usrquota''' attiva le quote per gli utenti e '''grpquota''' le attiva per i gruppi.<br />
<br />
Per rendere attive la nuova configurazione, dobbiamo smontare e rimontare il filesystem.<br />
umount /home<br />
mount /home<br />
<br />
Non sarà possibile smontare il filesystem se ci sono file aperti che si trovano in quel filesystem.<br />
<br />
<br />
== Attivare le quote ==<br />
<br />
<br />
== Impostare le quote per un utente ==<br />
Per impostare la quota di un utente, bisogna dare il comando (username va sostituito con il nome dell'utente):<br />
edquota username<br />
<br />
Si aprirà il vostro editor predefinito, che mostrerà una schermata simile a questa:<br />
Disk quotas for user user (uid 1000):<br />
Filesystem blocks soft hard inodes soft hard<br />
/dev/hda5 1848 49600 50000 244 0 0<br />
<br />
La prima cifra indica i blocchi attualmente in uso da parte dell'utente.<br />
La seconda indica il limite soft espresso in blocchi; e la terza il limite hard, sempre espresso in blocchi.<br />
<br />
La quarta cifra indica il numero di inodes utilizzati dall'utente, e le successive due sono i limiti soft e hard sugli inode.<br />
Le modifiche effettuate vengono controllate quando si chiude l'editor. In caso abbiate commesso qualche errore vi verrà segnalato.<br />
<br />
<br />
== Impostare le quote per tutti gli utenti ==<br />
Dopo aver impostato la quota di un utente, se volessimo usare le stesse impostazioni per altri utenti, sarebbe sufficiente scrivere:<br />
<br />
edquota -p user gianni<br />
<br />
Tale comando copierà le impostazioni sulla quota di user e le utilizzerà anche per l'utente gianni.<br />
<br />
<br />
[[Categoria: Sistema]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Old:UMTS/GPRS:_Internet_col_cellulare&diff=14934Old:UMTS/GPRS: Internet col cellulare2007-08-22T19:01:09Z<p>TheNoise: aggiunte categorie</p>
<hr />
<div>==Prefazione==<br />
<br />
Questa è una guida introduttiva all'uso del cellulare come modem bluetooth.<br />
<br />
Tale guida è utilizzabile anche per altri sistemi operativi (oltre Debian) dotati di kernel Linux.<br />
<br />
I file che per essere editati necessitino dei privilegi di root, possono essere aperti (conoscendo la password) con il seguente comando:<br />
<br />
<pre>su -c "gedit nome_del_file_da_editare"</pre> su GNOME, e<br />
<pre>su -c "kwrite nome_del_file_da_editare"</pre> su KDE.<br />
<br />
<br />
In alternativa al comando su, è possibile usare sudo (appositamente configurato).<br />
<br />
==Software necessario==<br />
<br />
Per l'utilizzo di un dispositivo bluetooth è necessario installare "The official Linux Bluetooth protocol stack", cioè BlueZ.<br />
Successivamente bisognerebbe abilitare, anche, il supporto al Point-to-Point Protocol, più genericamente conosciuto come PPP, nel kernel. Ma di solito lo è già di default.<br />
<br />
===Sorgenti===<br />
:I sorgenti sono scaricabili come tarball sul sito http://www.bluez.org/download.html.<br />
===Pacchetti===<br />
:I pacchetti delle blueZ dovrebbero essere contenuti nei cd/dvd della distribuzione, tuttavia - se così non fosse - sono scaricabili (per Debian GNU/Linux) all'indirizzo http://packages.debian.org/stable/admin/bluez-utils.<br />
<br />
:Installare anche il pacchetto ppp, che contiene gli script "pon" e "poff".<br />
<br />
==Configurare il bluetooth==<br />
Per permettere la comunicazione tra il Pc e il Cellulare è necessario accoppiare i due dispositivi. Durante questa fase è richiesto:<br />
*Un pin;<br />
*Il MAC Address del dispositivo bluetooth;<br />
*I parametri forniti dal provider;<br />
<br />
<br />
'''Nota bene:''' per utilizzare il bluetooth può essere necessario avviare il demone hcid. Col comando:<br />
<pre># /usr/sbin/hcid</pre><br />
ed è buona norma farlo fare in automatico al boot.<br />
La maggior parte delle distribuzioni, comunque, lo lanciano automaticamente una volta installati i pacchetti inerenti il bluetooth.<br />
<br />
===Il file "etc/bluetooth/pin"===<br />
Le BlueZ-utils permettono di impostare il pin attrverso il file di configurazione "/etc/bluetooth/pin"<br />
<br />
Credo che il file pin nelle ultime versioni sia stato eliminato, giacché il pin è configurabile anche nel file /etc/bluetooth/hcid.conf sotto la voce di "passkey"; come mostrato nell'esempio sottostante.<br />
<pre>options {<br />
# ...<br />
# tutte le opzioni...<br />
# ...<br />
passkey "1234";<br />
}</pre><br />
<br />
In alternativa, al file pin o hcid.conf, si può gestire il pin con delle utility grafiche. Da segnalare è bluez-gnome (per chi usa GNOME) o kdebluetooth (per chi utilizza KDE).<br />
<br />
{{Box | Come scelgo il pin? |Il pin può essere scelto a picere, purché durante l'accoppiamento col pc - sul cellulare - si inserisca il pin specificato all'interno del file "/etc/bluetooth/pin" o nella maschera grafica di bluez-gnome (o kdebluetooth)}}<br />
<br />
===Il MAC Address===<br />
Per accoppiare il cellulare bisogna essere a conoscenza del MAC Address. Per fare ciò si può usare il comando '''hcitool''' con il parametro '''scan'''<br />
<br />
<pre># hcitool scan</pre><br />
L'output del comando dovrebbe risultare simile a questo riportato di seguito<br />
<pre>04:F0:65:92:A5:BE NomeCellulare</pre><br />
<br />
===Accoppiare il dispositivo===<br />
<br />
Editare il file "/etc/bluetooth/rfcomm.conf" come segue:<br />
<br />
<pre>rfcomm0 {<br />
bind yes;<br />
device 04:F0:65:92:A5:BE;<br />
channel 1;<br />
}</pre><br />
dove l'indirizzo che succede alla voce device è l'indirizzo MAC, precedentemente ricavato grazie a hctool.<br />
<br />
È ora di procedere alla creazione del device /dev/rfcomm0 e alla procedura di accoppiamento.<br />
Per fare ciò basterà eseguire il comando:<br />
<pre># rfcomm bind 0 04:F0:65:92:A5:BE 1</pre> che creerà /dev/rfcomm0 e successivamente si potrà procedere all'associazione dei dispositivi dal cellulare, oppure dal pc col comando:<br />
<pre>rfcomm connect 0 04:F0:65:92:A5:BE 1</pre><br />
<br />
==Gli script per la connessione==<br />
<br />
Gli script di connessione sono rilasciati assieme a i parametri relativi ai maggiori gestori di telefonia mobile.<br />
<br />
===Il file "/etc/chatscripts/provider"===<br />
<br />
Bisogna editare il file /etc/chatscripts/provider come segue:<br />
<br />
<pre>ABORT BUSY<br />
ABORT 'NO CARRIER'<br />
ABORT VOICE<br />
ABORT 'NO DIALTONE'<br />
ABORT 'NO DIAL TONE'<br />
ABORT 'NO ANSWER'<br />
ABORT DELAYED<br />
<br />
'' ATZ<br />
<br />
#Scegliere la riga corrispondente il proprio provider<br />
#Per vodafone<br />
OK-AT-OK AT+CGDCONT=1,"IP","web.omnitel.it"<br />
#Per wind<br />
OK-AT-OK AT+CGDCONT=1,"IP","internet.wind"<br />
#Per tim<br />
OK-AT-OK AT+CGDCONT=1,"IP","ibox.tim.it"<br />
#Per 3HG<br />
OK-AT-OK AT+CGDCONT=1,"IP","tre.it"<br />
#Per 3HG con promozione NAVIGA3<br />
OK-AT-OK AT+CGDCONT=1,"IP","naviga.tre.it"<br />
<br />
OK-AT-OK ATDT_numero_<br />
<br />
CONNECT ''</pre> e al posto di _numero_ va inserito il numero di telefono corrispondente alla marca del proprio cellulare:<br />
<br />
<pre>Numeri: Nokia e Motorola: *99#<br />
Siemens, Sharp e Panasonic: *99***1#<br />
Samsung: *99***1*#<br />
Ericsson e SonyEricsson *99***CID# (CID = N° profilo GPRS)<br />
Altri: *99#</pre><br />
<br />
{{Box | ESEMPIO:|Con un Nokia la stringa col numero sarà: '''OK-AT-OK ATDT*99#'''}}<br />
<br />
===Il file "/etc/ppp/peers/provider"===<br />
<br />
Bisogna editare il file /etc/ppp/peers/provider come segue:<br />
<br />
<pre>noauth<br />
connect "/usr/sbin/chat -v -f /etc/chatscripts/provider"<br />
/dev/rfcomm0<br />
921600<br />
defaultroute<br />
noipdefault<br />
usepeerdns<br />
persist<br />
ipcp-accept-remote<br />
ipcp-accept-local<br />
lcp-echo-interval 0<br />
lcp-echo-failure 0</pre><br />
<br />
==Connetersi e Disconnettersi==<br />
<br />
Per connetersi basta usare<br />
<pre>$ pon</pre> e per disconnetersi <pre>$ poff</pre><br />
<br />
<br />
<br />
Per avere un output, sull'esito dell'operazione, si può usare (da root) il comando:<br />
<pre># pon;plog</pre><br />
in modo da avere informazioni per risolvere eventuali problemi.<br />
<br />
''Per qualsiasi cosa, non esitate a contattarmi.''<br />
----<br />
<br />
<br />
<br />
Autore: [[Utente:Clockwork orange|Clockwork Orange]]<br />
<br />
[[Categoria: Networking]][[Categoria: Hardware]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Old:OpenMosix&diff=14933Old:OpenMosix2007-08-22T18:51:41Z<p>TheNoise: aggiunte categorie</p>
<hr />
<div>{{stub}}<br />
<br />
=Intro=<br />
== Prerequisiti ==<br />
<br />
Per affrontare la costruzione di un cluster si dovra' sapere installare e configurare correttamente un sistema Debian/Linux, ricompilare un Kernel e avere buone conoscenze di networking.<br />
<br />
<br />
== Brevi accenni al clustering ==<br />
<br />
Un cluster (letteralmente grappolo) e' un insieme di unita' indipendenti di calcolo (es. PC) che cooperano <br />
per la soluzione di un problema comune.<br />
Le varie unita' di calcolo sono connesse tra loro tramite un mezzo di comunicazione e il calcolo viene distribuito in maniera differente in base a come e' stato creato il cluster.<br />
<br />
In questa guida si trattera' solo di una parte del calcolo distribuito, quella piu' "casalinga", ricordando pero' che esistono altre soluzioni molto piu' performanti e dedicate.<br />
<br />
OpenMosix svolge un tipo di distribuzione del calcolo molto semplice e trasparente per l'utente.<br />
Esso si occupa di dividere in maniera equa i processi tra tutti i nodi che cooperano, funziona molto bene con i programmi che svolgono un lavoro non sequenziale ma che dividono il lavoro in parti (fork).<br />
<br />
Un esempio di operazione che viene distribuita ben e' la ricompilazione del kernel o il rendering di immagini.<br />
<br />
<br />
== Scenario == <br />
Lo scenario tipico in cui si usa OpenMosix e' una serie di PC collegati tra loro tramite una connessione ethernet.<br />
Non importa che i PC siano tutti uguali, inquanto si occupera' il sistema a decidere se un processo deve essere distribuito tra i nodi oppure no.<br />
<br />
= Installazione =<br />
Openmosix lavora tra il livello Userspace e il livello kernelspace, per la costruzione si deve patchare e ricompilare il kernel<br />
<br />
==Patch del kernel==<br />
*Scaricare il kernel 2.4.26 <br />
/root># wget http://www.kernel.org/pub/linux/kernel/v2.4/linux-2.4.6.tar.bz2<br />
*Scompattarlo in /usr/src<br />
/root># mv kernel-2.4.26.tar.bz /usr/src<br />
/root># cd /usr/src<br />
/usr/src# tar xfvj linux-2.4.26.tar.bz<br />
*Creare un link simbolico come segue<br />
/usr/src># ln -s linux-2.4.26 linux-openmosix<br />
*Scaricare la patch openmosix<br />
/usr/src> wget http://switch.dl.sourceforge.net/sourceforge/openmosix/openMosix-2.4.26-1.bz2 <br />
*Patchare il kernel<br />
bzcat openMosix-2.4.26-1.bz2 | patch -Np1<br />
*Ricompilare il kernel attivando le voci relative ad openmosix<br />
<br />
==Installare OMtools==<br />
*Scarichiamo il pacchetto e scompattiamolo<br />
/root># wget http://heanet.dl.sourceforge.net/sourceforge/openmosix/openmosix-tools-0.3.6-2.tar.gz<br />
/root># mv openmosix-tools-0.3.6-2.tar.gz /opt<br />
/root># tar xfvz openmosix-tools-0.3.6-2.tar.gz<br />
*Installiamolo <br />
/root># cd /opt/openmosix-tools-0.3.6-2 <br />
/opt/omtools># ./configure && make && make install<br />
<br />
= Configurazione =<br />
<br />
== openmosix.map==<br />
Editare /etc/openmosix.map per indicare ad OpenMosix quali sono i nodi appartenti alla rete che coopereranno.<br />
<br />
Il file dovra' contenere nel primo campo il numero del nodo e poi il suo indirizzo IP o il suo nome (che dovra' essere presente in /etc/hosts).<br />
L'ultimo campo sara' il numero di processori presenti in ogni macchina.<br />
<br />
1 nodo1 1<br />
2 nodo2 1<br />
3 nodo3 1<br />
4 nodo4 2<br />
<br />
oppure<br />
<br />
1 192.168.0.1 1 <br />
2 192.168.0.2. 2<br />
3 192.168.0.43 1<br />
4 192.168.0.3 1<br />
<br />
=Test=<br />
*Avviare il demone in tutti i nodi <br />
/root># /etc/init.d/openmosix start<br />
<br />
*Lanciare il contro grafico<br />
/root># mosmon<br />
Se tutto e' apposto si dovrebbe vedere il grafico col nostro nodo.<br />
<br />
<br />
[[Categoria:Kernel]][[Categoria: Networking]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Linux_Kernel_in_a_Nutshell&diff=14932Linux Kernel in a Nutshell2007-08-22T18:47:47Z<p>TheNoise: </p>
<hr />
<div>{{Box|Copyright Notice|This is a free translation of the book [http://www.kroah.com/lkn/ Linux Kernel in a Nutshell] by [http://www.kroah.com/log/ Greg Kroah-Hartman]. The original book and this translation are available under the terms of [http://creativecommons.org/licenses/by-sa/2.5/ Creative Commons Attribution-ShareAlike 2.5]. To support the original author you can purchase the book [http://www.oreilly.com/catalog/9780596100797/ here] or [http://www.amazon.com/Linux-Kernel-Nutshell-OReilly/dp/0596100795 elsewhere].<br />
<br />
The translation work is an indipendent project not affiliated with Greg Kroah-Hartman or his editor.<br />
----<br />
Questa è una traduzione del libro [http://www.kroah.com/lkn/ Linux Kernel in a Nutshell] di [http://www.kroah.com/log/ Greg Kroah-Hartman], pubblicato da [http://www.oreilly.com/ O'Reilly]. Il libro è disponibile nei termini della licenza [http://creativecommons.org/licenses/by-sa/2.5/ Creative Commons Attribution-ShareAlike 2.5], che permette il libero download e la redistribuzione dell'opera, e viene pubblicato qui, tradotto, nei termini della stessa licenza.<br />
}}<br />
<br />
{{Warningbox|La traduzione è in corso e chiunque abbia buona volontà e una conoscenza sufficiente della lingua è invitato a contribuire attivamente. Grazie a tutti e buona lettura.}}<br />
<br />
__TOC__<br />
<br />
<big><big>Prefazione</big></big><br />
<br />
<br />
<big><big><big>Parte I.</big></big></big><br />
==Compilare il kernel==<br />
Questa parte del libro mostra come scaricare, compilare e installare il kernel. &Egrave; in gran parte una guida passo passo.<br />
<br />
* <span style="color: green;">'''Capitolo 1''', [[LKN:_Introduzione|Introduzione]] (''tradotto 100%'')</span><br />
<br />
* <span style="color: green;">'''Capitolo 2''', [[LKN:_Requisiti_per_Compilare_ed_Utilizzare_il_Kernel|Requisiti per Compilare ed Utilizzare il Kernel]] (''tradotto 100%'')</span><br />
<br />
* <span style="color: green;">'''Capitolo 3''', [[LKN:_Procurarsi_i_Sorgenti_del_Kernel|Procurarsi i Sorgenti del Kernel]] (''tradotto 100%'')</span><br />
<br />
* <span style="color: green;">'''Capitolo 4''', [[LKN:_Configurare_e_Compilare|Configurare e Compilare]] (''tradotto 100%'')</span><br />
<br />
* <span style="color: green;">'''Capitolo 5''', [[LKN:_Installare_ed_Avviare_con_un_Kernel|Installare ed Avviare con un Kernel]] (''tradotto 100%'')</span><br />
<br />
* <span style="color: green;">'''Capitolo 6''', [[LKN:_Aggiornare_il_Kernel|Aggiornare il Kernel]] (''tradotto 100%'')</span><br />
<br />
<br />
<big><big><big>Parte II.</big></big></big> <br />
==Personalizzazioni principali==<br />
Questa parte spiega le personalizzazioni più comuni effettuate dagli utenti di Linux, ed utili combinazioni di opzioni da personalizzare.<br />
<br />
* <span style="color: brown;">'''Capitolo 7''', [[LKN:_Personalizzare_un_Kernel|Personalizzare un Kernel]] (''tradotto 50%'')</span><br />
<br />
* <span style="color: red;">'''Capitolo 8''', [[LKN:_Ricette_per_Configurare_il_Kernel|Ricette per Configurare il Kernel]] (''tradotto 4%'')</span><br />
<br />
<br />
<big><big><big>Parte III.</big></big></big><br />
<br />
==Guide di riferimento per il kernel==<br />
Questa sezione fornisce informazioni di riferimento su parametri per il Kernel di tutti i tipi.<br />
<br />
* <span style="color: red;">'''Capitolo 9''', [[LKN:_Guida_di_Riferimento_dei_Parametri_di_Boot_del_Kernel|Guida di Riferimento dei Parametri di Boot del Kernel]] (''tradotto 20%'')</span><br />
<br />
* <span style="color: green;">'''Capitolo 10''', [[LKN:_Guida_di_Riferimento_dei_Parametri_di_Compilazione_del_Kernel|Guida di Riferimento dei Parametri di Compilazione del Kernel]] (''tradotto 100%'')</span><br />
<br />
* <span style="color: green;">'''Capitolo 11''', [[LKN:_Guida_di_Riferimento_delle_Opzioni_di_Configurazione_del_Kernel|Guida di Riferimento delle Opzioni di Configurazione del Kernel]] (''tradotto 100%'')</span><br />
<br />
<br />
<big><big><big>Parte IV.</big></big></big><br />
==Informazioni aggiuntive==<br />
Questa sezione include un'Appendice su programmi utili, e riferimenti per ulteriori approfondimenti.<br />
<br />
* <span style="color: green;">'''Appendice A''', [[LKN:_Programmi_Utili|Programmi Utili]] (''tradotto 100%'')</span><br />
<br />
* <span style="color: green;">'''Appendice B''', [[LKN:_Bibliografia|Bibliografia]] (''tradotto 100%'')</span><br />
<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Linux_Kernel_in_a_Nutshell&diff=14931Linux Kernel in a Nutshell2007-08-22T18:47:04Z<p>TheNoise: aggiunti colori e stato traduzione</p>
<hr />
<div></div>TheNoisehttps://guide.debianizzati.org/index.php?title=Linux_Kernel_in_a_Nutshell&diff=14930Linux Kernel in a Nutshell2007-08-22T18:34:55Z<p>TheNoise: /* Personalizzazioni principali */ colori per indicare lo stato traduzione</p>
<hr />
<div></div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Guida_di_Riferimento_dei_Parametri_di_Compilazione_del_Kernel&diff=14928LKN: Guida di Riferimento dei Parametri di Compilazione del Kernel2007-08-22T18:20:39Z<p>TheNoise: aggiunto link pdf originale</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
__TOC__<br />
<br />
Come discusso nel Capitolo 4, lo strumento che unisce insieme il kernel è ''make'', al quale si passa un ''target'' che specifica cosa si vuole compilare. Il capitolo 4 è andato oltre gli obiettivi base necessari alla corretta compilazione del kernel, ma il sistema di compilazione del kernel ha anche una larga scala di altri ''target''. Questo capitolo dettaglia questi target, e per cosa possono venir utilizzati.<br />
<br />
* Nota di prima traduzione: nel testo, target è stato tradotto a volte come obiettivi, anche se forse sarebbe meglio parlare di etichette dal momento che in un Makefile si chiamano così, la maggior parte delle volte inceve si è preferito lasciare la parola in lingua originale ''italianizzandola'' in ''target'' senza ''s''. <br />
<br />
Tutti questi target vengono passati al programma ''make'' a linea di comando, e un numero di questi può venir raggruppato insieme se lo si desidera. Per esempio:<br />
<br />
<pre><br />
$ make mrproper xconfig<br />
</pre><br />
<br />
I target sono suddivisi sotto per differenti tipi nelle sezioni seguenti.<br />
<br />
Si può avere un sommario della maggior parte di essi eseguendo nella directory di compilazione:<br />
<br />
<pre><br />
$ make help<br />
</pre><br />
<br />
Questo target mostra molti dei target comuni di ''make'' che vengono descritti nel resto del capitolo.<br />
<br />
<br />
== Target informativi ==<br />
<br />
La tabella 10-1 mostra i target che stampano la versione del kernel, basato su un numero di opzioni differenti. Sono solitamente usati da script per determinare la versione del kernel che si sta per compilare.<br />
<br />
''Tabella 10-1. Target informativi''<br />
<br />
<table border="1"><br />
<tr><br />
<td width="50%">'''Target'''</td><br />
<td>'''Descrizione'''</td><br />
</tr><br />
<tr><br />
<td width="50%">kernelrelease</td> <br />
<td width="50%">Visualizza la versione corrente del kernel, la stessa determinata dal sistema di compilazione.</td><br />
</tr><br />
<tr><br />
<td width="50%">kernelversion</td> <br />
<td width="50%">Visualizza la versione corrente del kernel, come detto dal Makefile principale. Questa differisce da ''kernelrelease'' dal fatto che non usa altre informazioni di versione aggiuntive basate su opzioni di configurazione o file ''localversion''.</td><br />
</tr><br />
</table><br />
<br />
<br />
== Target di pulizia ==<br />
<br />
La tabella 10-2 mostra i target che semplicemente rimuovono i file delle compilazioni precedenti. Il loro uso è vivamente consigliato per essere sicuri di non contaminare le nuove compilazioni con file abbandonati che possono essere stati compilati con opzioni differenti. Differiscono da quanto eliminano; a volte si preferisce mantenere file che si è cambiati.<br />
<br />
''Table 10-2. Target di pulizia''<br />
<br />
<table border="1"><br />
<tr><br />
<td width="50%">'''Target'''</td><br />
<td width="50%">'''Descrizione'''</td><br />
</tr><br />
<tr><br />
<td width="50%">clean</td><br />
<td width="50%">Rimuove la maggior parte dei file generati dal sistema di compilazione del kernel, ma mantiene la configurazione del kernel.</td><br />
</tr><br />
<tr><br />
<td width="50%">mrproper</td><br />
<td width="50%">Rimuove tutti i file generati dal sistema di compilazione del kernel, inclusa la configurazione e alcuni file di backup.</td><br />
</tr><br />
<tr><br />
<td width="50%">distclean</td><br />
<td width="50%">Fa tutto ci&ograve; che mrproper fa e rimuove alcuni editor backup e file patch abbandonate.</td><br />
</tr><br />
</table><br />
<br />
<br />
== Target di configurazione ==<br />
<br />
<br />
La tabella 10-3 mostra i target che permettono al kernel di essere configurato in un largo campo di modi differenti.<br />
<br />
''Tabella 10-3. Target di configurazione''<br />
<br />
<table border="1"><br />
<tr><br />
<td width="50%">'''Target'''</td><br />
<td width="50%">'''Descrizione'''</td><br />
</tr><br />
<tr><br />
<td width="50%">config</td><br />
<td width="50%">Aggiorna la configurazione corrente del kernel usando il programma a riga di comando.</td><br />
</tr><br />
<tr><br />
<td width="50%">menuconfig</td><br />
<td width="50%">Aggiorna la configurazione corrente del kernel usando un programma a menu testuale.</td><br />
</tr><br />
<tr><br />
<td width="50%">xconfig</td><br />
<td width="50%">Aggiorna la configurazione corrente del kernel usando un programma grafico basato su librerie QT.</td><br />
</tr><br />
<tr><br />
<td width="50%">gconfig</td><br />
<td width="50%">Aggiorna la configurazione corrente del kernel usando un programma grafico basato su librerie GTK+.</td><br />
</tr><br />
<tr><br />
<td width="50%">oldconfig</td><br />
<td width="50%">Aggiorna la configurazione corrente del kernel usando il file .config corrente e chiedendo conferma per ogni nuova opzione che aggiunta al kernel.</td><br />
</tr><br />
<tr><br />
<td width="50%">silentoldconfig</td><br />
<td width="50%">Come oldconfig, ma non stampa nulla su schermo tranne quando una questione ha bisogno di una risposta.</td><br />
</tr><br />
<tr><br />
<td width="50%">randconfig</td><br />
<td width="50%">Genera una nuova configurazione di kernel con risposte casuali a tutte le differenti opzioni.</td><br />
</tr><br />
<tr><br />
<td width="50%">defconfig</td><br />
<td width="50%">Genera una nuova configurazione del kernel che usa le risposte predefinite per tutte le ozioni. I valori predefiniti sono presi da un file situato in ''arch/$ARCH/defconfig, dove $ARCH si riferisce alla specifica architettura per il quale il kernel viene compilato.</td><br />
</tr><br />
<tr><br />
<td width="50%">allmodconfig</td><br />
<td width="50%">Genera una nuova configurazione del kernel nel quale i moduli sono attivati dove possibile.</td><br />
</tr><br />
<tr><br />
<td width="50%">allyesconfig</td><br />
<td width="50%">Genera una nuova configurazione del kernel nel quale tutte le opzioni sono impostate a ''yes''.</td><br />
</tr><br />
<tr><br />
<td width="50%">allnoconfig</td><br />
<td width="50%">Genera una nuova configurazione del kernel nel quale tutte le opzioni sono impostate a ''no''.</td><br />
</tr><br />
</table><br />
<br />
Notare che allyesconfig, allmodconfig, allnoconfig, e randconfig target prendono anche vantaggio della variabile d'ambiente KCONFIG_ALLCONFIG. Se quella variabile punta a un file, quel file verrà usato come lista di valori di configurazione che si richiede essere imposti a uno specifico valore. In altre parole, il file scavalca il comportamento normale di ''make'' target.<br />
<br />
Per esempio, se il file ''~/linux/must_be_set'' contiene le seguenti variabili:<br />
<br />
<pre><br />
$ cat ~/linux/must_be_set<br />
CONFIG_SWAP=y<br />
CONFIG_DEBUG_FS=y<br />
</pre><br />
<br />
e si inserisce ''make allnoconfig'' con l'appropriata variabile d'ambiente KCONFIG_ALLCONFIG attiva:<br />
<br />
<pre><br />
$ KCONFIG_ALLCONFIG=../must_be_set make allnoconfig<br />
$ grep CONFIG_SWAP .config<br />
CONFIG_SWAP=y<br />
</pre><br />
<br />
quindi i risultati includono:<br />
<br />
<pre><br />
$ grep CONFIG_DEBUG_FS .config<br />
CONFIG_DEBUG_FS=y<br />
</pre><br />
<br />
Questa variabile non sarebbe stata impostata a ''y'' altrimenti.<br />
<br />
Se la variabile KCONFIG_ALLCONFIG non è impostata, il sistema di compilazione controlla i file nella directory di compilazione a più alto livello con nome:<br />
<br />
* ''allmod.config''<br />
<br />
* ''allno.config''<br />
<br />
* ''allrandom.config''<br />
<br />
* ''allyes.config''<br />
<br />
Se qualsiasi di questi file è presente, la compilazione li usa come lista di valori di configurazione che devono essere forzati ai valori specificati. Se nessuno di questi file viene trovato, il sistema di compilazione alla fine cerca un file chiamato ''all.config'' per una lista di valori di configurazione forzati.<br />
<br />
Si possono usare questi file differenti per impostare una buona configurazione di base che funzionerà sempre. In seguito le altre opzioni di configurazione possono essere usate per generare differenti configurazioni di test per le situazioni che lo necessitano.<br />
<br />
<br />
== Target di compilazione ==<br />
<br />
<br />
La tabella 10-4 mostra i target che compilano il kernel stesso in una molteciplità di metodi.<br />
<br />
''Table 10-4. Target di compilazione''<br />
<br />
<table border="1"><br />
<tr><br />
<td width="50%">'''Target'''</td><br />
<td width="50%">'''Descrizione'''</td><br />
</tr><br />
<tr><br />
<td width="50%">all</td><br />
<td width="50%">Compila tutti i differenti target necessari al kernel per venir usato. Ciò include sia i moduli che le porzioni statiche del kernel.</td><br />
</tr><br />
<tr><br />
<td width="50%">vmlinux</td><br />
<td width="50%">Compila solo la parte statica del kernel, nessun modulo caricabile.</td><br />
</tr><br />
<tr><br />
<td width="50%">modules</td><br />
<td width="50%">Compila tutti i moduli caricabili del kernel per questa configurazione.</td><br />
</tr><br />
<tr><br />
<td width="50%">module_install</td><br />
<td width="50%">Installa tutti i moduli nella specifica locazione. Se nessuna posizione è specificata con la variabile d'ambiente INSTALL_MODULE_PATH, vengono installati nella directory root predefinita della macchina.</td><br />
</tr><br />
<tr><br />
<td width="50%">dir/</td><br />
<td width="50%">Compila tutti i file nella directory specificata e in tutte le sottodirectory sotto questa.</td><br />
</tr><br />
<tr><br />
<td width="50%">dir/file.[o|i|s]</td><br />
<td width="50%">Compila solo i file specificati.</td><br />
</tr><br />
<tr><br />
<td width="50%">dir/file.ko</td><br />
<td width="50%">Compila tutti i file necessari e li unisce per formare il modulo specificato.</td><br />
</tr><br />
<tr><br />
<td width="50%">tags</td><br />
<td width="50%">Compila tutti i tag necessari che la maggior parte degli editor di testo possono usare mentre modificano il codice sorgente.</td><br />
</tr><br />
<tr><br />
<td width="50%">TAGS</td><br />
<td width="50%">Compila tutti i tag necessari che la maggior parte degli editor di testo possono usare mentre modificano il codice sorgente.</td><br />
</tr><br />
<tr><br />
<td width="50%">cscope</td><br />
<td width="50%">Compila un'immagine ''cscope'', utile nel sorgente treesearches, dell'albero sorgente per l'architettura specificata dal file di configurazione (non tutti i file sorgenti del kernel).</td><br />
</tr><br />
</table><br />
<br />
Potete anche passare un numero di variabili d'ambiente a ''make'' che cambierà la compilazione. Queste possono essere specificate per quasi ogni target, come mostrato nella tabella 10-5.<br />
<br />
''Tabella 10-5. Variabili d'ambiente''<br />
<br />
<table border="1"><br />
<tr><br />
<td width="33%">'''Variabile'''</td><br />
<td width="33%">'''Valore'''</td><br />
<td width="33%">'''Descrizione'''</td><br />
</tr><br />
<tr><br />
<td width="10%">V</td><br />
<td width="10%">0</td><br />
<td width="80%">Questa dice al sistema di compilazione di funzionare in maniera silenziosa, mostrando solo il file in compilazione, e non il comando intero che sta girando ai fini di compilare il file. Questa è l'opzione predefinita per il sistema di compilazione.</td><br />
</tr><br />
<tr><br />
<td width="10%">V</td><br />
<td width="10%">1</td><br />
<td width="80%">Questo dice al sistema di compilazione di operare in modalità prolissa, mostrando il comando completo che si sta usando per generare ognuno dei file specifici.</td><br />
</tr><br />
<tr><br />
<td width="10%">O</td><br />
<td width="10%">dir</td><br />
<td width="80%">Questo dice al sistema di compilazione di mettere tutti i file di output nella directory ''dir'', inclusi i file di configurazione del kernel. Questo permette di compilare il kernel da un filesystem in sola lettura e avere l'output posto in un'altra posizione.</td><br />
</tr><br />
<tr><br />
<td width="10%">C</td><br />
<td width="10%">1</td><br />
<td width="80%">Questo ''checksall'' i file C che verranno compilati con lo strumento ''sparse'', che scova gli errori comuni di configurazione nei file sorgenti del kernel. ''sparse'' può essere scaricato usando ''git'' da ''git://git.kernel.org/pub/scm/devel/sparse/sparse.git''. Snapshot giornalieri possono essere trovati a ''http://www.codemonkey.org.uk/projects/git-snapshots/sparse/''. Maggiori informazioni su come usare ''sparse'' possono essere reperite nel file Documentation/sparse.txt nell'albero dei sorgenti del kernel.</td><br />
</tr><br />
<tr><br />
<td width="10%">C</td><br />
<td width="10%">2</td><br />
<td width="80%">Questa ''forcesall'' i file C da controllare con lo strumento ''sparse'', anche se essi non devono essere compilati.</td><br />
</tr><br />
</table><br />
<br />
<br />
== Target di pacchettizzazione ==<br />
<br />
<br />
Questi target impacchettano un kernel compilato in un pacchetto autonomo che può essere installato su un'ampia varietà di macchine differenti, come mostrato nella tabella 10-6.<br />
<br />
''Tabella 10-6. Packaging target''<br />
<br />
<table border="1"><br />
<tr><br />
<td width="30%">'''Target'''</td><br />
<td width="70%">'''Descrizione'''</td><br />
</tr><br />
<tr><br />
<td width="30%">rpm</td><br />
<td width="70%">Compila il kernel e poi lo impacchetta in un pacchetto RPM che può essere installato.</td><br />
</tr><br />
<tr><br />
<td width="30%">rpm-pkg</td><br />
<td width="70%">Crea un pacchetto RPM sorgente che contiene un kernel di base.</td><br />
</tr><br />
<tr><br />
<td width="30%">binrpmpkg</td><br />
<td width="70%">Crea un pacchetto RPM che contiene un kernel compilato e i moduli.</td><br />
</tr><br />
<tr><br />
<td width="30%">deb-pkg</td><br />
<td width="70%">Crea un pacchetto Debian che contiene un kernel compilato e i moduli.</td><br />
</tr><br />
<tr><br />
<td width="30%">tar-pkg</td><br />
<td width="70%">Crea un tarball che contiene un kernel compilato e i moduli.</td><br />
</tr><br />
<tr><br />
<td width="30%">targz-pkg</td><br />
<td width="70%">Crea un tarball compresso con ''gzip'' che contiene il kernel compilato e i moduli.</td><br />
</tr><br />
<tr><br />
<td width="30%">tarbz2-pkg</td><br />
<td width="70%">Crea un tarball compresso con ''bzip2'' che contiene il kernel compilato e i moduli.</td><br />
</tr><br />
</table><br />
<br />
<br />
== Target di documentazione ==<br />
<br />
<br />
La tabella 10-7 mostra target che costruiscono la documentazione interna del kernel in molteplici formati.<br />
<br />
''Tabella 10-7'' target di documentazione''<br />
<br />
<table border="1"><br />
<tr><br />
<td width="30%">'''Target'''</td><br />
<td width="70%">'''Descrizione'''</td><br />
</tr><br />
<tr><br />
<td width="30%">xmldocs</td><br />
<td width="70%">Crea la documentazione del kernel come file XML DocBook.</td><br />
</tr><br />
<tr><br />
<td width="30%">psdocs</td><br />
<td width="70%">Crea la documentazione del kernel come file Postscript.</td><br />
</tr><br />
<tr><br />
<td width="30%">pdfdocs</td><br />
<td width="70%">Crea la documentazione del kernel come file PDF.</td><br />
</tr><br />
<tr><br />
<td width="30%">htmldocs</td><br />
<td width="70%">Crea la documentazione del kernel come file HTML.</td><br />
</tr><br />
<tr><br />
<td width="30%">mandocs</td><br />
<td width="70%">Crea la documentazione del kernel come un insieme di pagine man, che possono essere installate con il target ''install-mandocs''.</td><br />
</tr><br />
</table><br />
<br />
<br />
== Target per architetture specifiche ==<br />
<br />
<br />
Ogni architettura kernel ha un insieme di target specifici unici a se stessi. La tabella 10-8 mostra i target disponibili per l'architettura Intel a 32-bit.<br />
<br />
''Tabella 10-8. Target specifici per architettura 32-bit Intel''<br />
<br />
<table border="1"><br />
<tr><br />
<td width="30%">'''Target'''</td><br />
<td width="70%">'''Descrizione'''</td><br />
</tr><br />
<tr><br />
<td width="30%">bzImage</td><br />
<td width="70%">Crea un'immagine compressa del kernel e la pone nel file ''arch/i386/boot/bzImage''. Questo è il target predefinito per i kernel i386.</td><br />
</tr><br />
<tr><br />
<td width="30%">install</td><br />
<td width="70%">Installa l'immagine del kernel usando il programma specifico di distribuzione ''/sbin/installkernel''. Notare che questo non installa i moduli del kernel; ciò deve essere fatto con il target ''module_install''.</td><br />
</tr><br />
<tr><br />
<td width="30%">bzdisk</td><br />
<td width="70%">Crea un'immagine di boot per floppy e la scrive sul dispositivo ''/dev/fd0''.</td><br />
</tr><br />
<tr><br />
<td width="30%">fdimage</td><br />
<td width="70%">Crea un'immagine di boot per floppy e la mette nel file ''arch/i386/boot/fdimage''. Il pacchetto ''mtools'' deve essere presente sul vostro sistema affinché questo funzioni correttamente.</td><br />
</tr><br />
<tr><br />
<td width="30%">isoimage</td><br />
<td width="70%">Crea un'immagine di boot CD-ROM e la pone nel file ''arch/i386/boot/image.iso''. Il pacchetto ''syslinux'' deve essere presente nel vostro sistema affiché questo funzioni correttamente.</td><br />
</tr><br />
</table><br />
<br />
<br />
== Target di analisi ==<br />
<br />
<br />
La tabella 10-9 mostra i target che sono d'aiuto per trovare problemi nel codice del kernel. &Egrave; una buona idea creare una lista degli spazi di stack quando si crea del nuovo codice per determinare che i vostri cambiamenti non stiano prendendo troppo spazio di stack del kernel. Il target namespacecheck è utile per determinare se i vostri cambiamenti possono, in sicurezza, aggiungere i propri simboli al namespace globale del kernel.<br />
<br />
''Tabella 10-9. Targets di analisi''<br />
<br />
<table border="1"><br />
<tr><br />
<td width="30%">'''Target'''</td><br />
<td width="70%">'''Descrizione'''</td><br />
</tr><br />
<tr><br />
<td width="30%">checkstat</td><br />
<td width="70%">Genera una lista di funzioni che usano la maggior parte dello spazio di stack del kernel.</td><br />
</tr><br />
<tr><br />
<td width="30%">namespace check</td><br />
<td width="70%">Genera una lista di tutti i simboli del kernel e dei loro namespace. Questa sarà una lunga lista.</td><br />
</tr><br />
</table><br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/ch10.pdf ''Capitolo originale'']<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Bibliografia&diff=14926LKN: Bibliografia2007-08-22T18:19:03Z<p>TheNoise: aggiunto link pdf originale</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
__TOC__<br />
<br />
Molte delle informazioni contenute in questo libro sono state estratte dalla documentazione del kernel e dal codice sorgente. La documentazione è infatti il miglior posto dove trovare informazioni e riferimenti su come compilare e installare il kernel ed è normalmente tenuta aggiornata a seguito di cambiamenti nella procedura di compilazione.<br />
<br />
== Libri ==<br />
Sono disponibili molti ottimi libri relativi alla programmazione del kernel Linux, ma solo pochi di essi trattano la compilazione e installazione del kernel. Ecco un elenco di libri che ho trovato utili.<br />
<br />
=== Libri generici su Linux ===<br />
<br />
* Ellen Siever, Aaron Weber, Stephen Figgins, Robert Love, e Arnold Robbins. ''Linux in a Nutshell'' (O’Reilly), 2005.<br/>Questo libro comprende una delle più complete e autorevoli guide ai comandi per Linux. Essa copre praticamente ogni singolo comando di cui potreste mai aver bisogno.<br />
<br />
* Yaghmour, Karim. ''Building Embedded Linux Systems'' (O’Reilly), 2003.<br/>Questo libro, sebben principalmente rivolto agli sviluppatori di sistemi Linux embedded, contiene un'ottima sezione relativa a come creare una ''toolchain'' e un kernel con compilazione incrociata. Oltre a questa sezione del libro, è consigliato anche in virtù di altre sezioni che forniscono interessanti informazioni per coloro che vogliono imparare come personalizzare il kernel e il resto del sistema.<br />
<br />
=== Libri inerenti il kernel Linux ===<br />
<br />
Molti di questi libri sono indirizzati ai programmatori interessati ad apprendere come programmare all'interno del kernel. Sono generalmente molto tecnici rispetto a questo libro, ma sono un ottimo punto di partenza se desiderate imparare e capire il codice che governa il kernel.<br />
<br />
*Jonathan Corbet, Alessandro Rubini, e Greg Kroah-Hartman. ''Linux Device Drivers'' (O’Reilly), 2005.<br/>Questo libro illustra come differenti ''device driver'' operano e fornisce parecchi esempi applicatici di driver funzionanti. &Egrave; consigliato a chiunque vuole programmare driver per il kernel. &Egrave; disponibile in rete gratuitamente a questo indirizzo: http://lwn.net/Kernel/LDD3/<br />
<br />
* Love, Robert. ''Linux Kernel Development'' (Novell Press Publishing), 2005.<br/> Questo libro copre quasi tutti gli aspetti relativi al kernel Linux, illustrando come tutto opera insieme. Ottimo punto di partenza per iniziare a capire e conoscere le diverse componenti del kernel.<br />
<br />
* Bovet, Daniel P. e Cesate, Marco. ''Understanding the Linux Kernel'' (O’Reilly), 2005.<br/> Questo libro si addentra negli aspetti relativi la progettazione e implementazione del nucleo del kernel Linux. Un ottimo riferimento per apprendere e capire gli algoritmi utilizzati nelle diverse porzioni del kernel. Fortemente consigliato a coloro che vogliono comprendere nel dettaglio come funziona il kernel.<br />
<br />
== Strumenti ==<br />
<br />
In questo libro sono stati menzionati molti utili strumenti. Di seguito, presento un elenco dei siti dove è possibile reperire e scaricare tali strumenti.<br />
<br />
* ''Linux kernel''<br/> http://www.kernel.org e ftp://ftp.kernel.org contiene tutte le versioni del sorgente del kernel. http://www.kernel.org/git/ contiene una lista di tutti i ''git trees'' utilizzati dai diversi sviluppatori del kernel.<br />
<br />
* ''gcc''<br>http://gcc.gnu.org/ sito principale per tutto ciò che concerne il compilatore GNU C. <br />
<br />
* ''binutils''<br/>http://www.gnu.org/software/binutils/ è il sito principale dove trovare tutte le informazioni su binutils.<br />
<br />
* ''make''<br/>http://www.gnu.org/software/make/ è il sito principale dove trovare tutte le informazioni su make.<br />
<br />
*''util-linux''<br/>http://www.kernel.org/pub/linux/utils/util-linux/ è la directory da dove possono essere scaricate tutte le versioni di util-linux.<br />
<br />
* ''module-init-tools''<br/>http://www.kernel.org/pub/linux/utils/kernel/module-init-tools/ è la directory da dove possono essere scaricate tutte le versioni di module-init-tools.<br />
<br />
* ''e2fsprogs''<br/>http://e2fsprogs.sourceforge.net/ è la pagina principale del progetto e2fsprogs.<br />
<br />
* ''jfsutils''<br/>http://jfs.sourceforge.net/ è la pagina principale del progetto jfsutils.<br />
<br />
* ''reiserfsprogs''<br/>http://www.namesys.com/download.html è la pagina principale del progetto reiserfsprogs.<br />
<br />
* ''xfsprogs''<br/>http://oss.sgi.com/projects/xfs/ è la pagina principale del progetto xfsprogs.<br />
<br />
* ''quota-tools''<br/>http://sourceforge.net/projects/linuxquota/ è la pagina principale del progetto quota-tools.<br />
<br />
* ''nfs-utils''<br/>http://nfs.sf.net/ è la pagina principale del progetto nfs-utils.<br />
<br />
* ''udev''<br/>http://www.kernel.org/pub/linux/utils/kernel/hotplug/udev.html è la directory da dove possono essere scaricate tutte le versioni di udev.<br />
<br />
* ''procfs''<br/>http://procps.sourceforge.net/ è la pagina principale del progetto procfs.<br />
<br />
* ''patchutils''<br/>http://cyberelk.net/tim/patchutils è la directory da dove possono essere scaricate tutte le versioni di patchutils.<br />
<br />
* ''git''<br/>http://git.or.cz/ è il sito principale del progetto git.<br />
<br />
* ''ketchup''<br/>http://www.selenic.com/ketchup/ è la pagina principale del progetto ketchup.<br />
<br />
* ''quilt''<br/>http://savannah.nongnu.org/projects/quilt è la pagina principale del progetto quilt.<br />
<br />
* ''distcc''<br/>http://distcc.samba.org/ è la pagina principale del progetto distcc.<br />
<br />
* ''ccache''<br/>http://ccache.samba.org/ è la pagina principale del progetto ccache.<br />
<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/appb.pdf ''Capitolo originale'']<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Programmi_Utili&diff=14925LKN: Programmi Utili2007-08-22T18:18:10Z<p>TheNoise: sposato link pdf originale</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
__TOC__<br />
<br />
Scaricare [da Internet, NdT], compilare, aggiornare e mantenere i sorgenti del kernel Linux comporta diversi passi, come questo libro illustra. Essendo per natura creature pigre, gli sviluppatori hanno creato alcuni programmi a supporto di queste attività di routine. Descriviamo alcuni di tali utili strumenti e le nozioni di base sul loro utilizzo.<br />
<br />
Lo sviluppo del kernel Linux differisce per molti aspetti dal tradizionale processo di sviluppo software. A uno sviluppatore del kernel sono richieste alcune attività peculiari:<br />
<br />
* Applicare le modifiche ad un "bersaglio mobile" quale è il kernel, a causa della rapida pianificazione delle versioni di sviluppo.<br />
* Risolvere i conflitti derivanti dalla fusione del proprio lavoro con quello dagli altri sviluppatori.<br />
* Esportare i suoi cambiamenti in un formato che permetta agli altri sviluppatori di incorporarli facilmente nel proprio lavoro.<br />
<br />
==patch e diff==<br />
Questa sezione è basata su un articolo pubblicato originariamento su ''Linux Journal''.<br />
<br />
Una delle modalità più comuni per lavorare con il kernel è quella di usare i programmi ''patch'' e ''diff''. Per usare questi strumenti, sono necessarie due differenti directory: una "pulita" (clean) e una "di lavoro" (indicata con ''dirty'' in seguito). La directory clean contiene la versione originale del kernel, mentre quella dirty contiene le modifiche apportate dal programmatore alla stessa release.<br />
Utilizzando ''patch'' e ''diff'' è possibile estrarre i cambiamenti apportati sul sorgente e portarli nella nuova release del kernel.<br />
<br />
Per esempio, creiamo due directory contenenti l'ultima versione del kernel come descritto nel Capitolo 3.<br />
<br />
<pre><br />
$ tar -zxf linux-2.6.19.tar.gz<br />
$ mv linux-2.6.19 linux-2.6.19-dirty<br />
$ tar -zxf linux-2.6.19.tar.gz<br />
$ ls<br />
linux-2.6.19/<br />
linux-2.6.19-dirty/<br />
</pre><br />
<br />
Ora è possibile apportare tutte le modifiche desiderate al sorgente presente nella directory dirty, lasciando inalterata quella clean. Dopo aver apportato le modifiche, si potrà creare una patch da inviare agli altri sviluppatori tramite i seguenti comandi:<br />
<br />
<pre><br />
$ diff -Naur -X linux-2.6.19/Documentation/dontdiff linux-2.6.19/ \<br />
linux-2.6.19-dirty/ > my_patch<br />
</pre><br />
<br />
Questo comando creerà un file dal nome ''my_patch'' che conterrà tutti i cambiamenti apportati al sorgente del kernel rispetto alla versione pulita presente nella directory clean. Tale file potrà essere distribuito o inviato ad agli altri sviluppatori via email.<br />
<br />
<br />
===Nuove versioni del kernel===<br />
Al rilascio di una nuova versione del kernel, se si desidera portare i cambiamenti su questa nuova versione è necessario applicare la patch ad una versione ''pulita'' del kernel.<br />
Questo può essere fatto seguendo questi passi:<br />
* Creare la patch, come illustrato nell'esempio precedente.<br />
* Utilizzare la patch ufficiale dal sito ''kernel.org'' e aggiornare la vecchia versione alla nuova release:<br />
<br />
<pre><br />
$ cd linux-2.6.19<br />
$ patch -p1 < ../patch-2.6.20<br />
$ cd ..<br />
$ mv linux-2.6.19 linux-2.6.20<br />
</pre><br />
<br />
* Aggiornare la directory di lavoro rimuovendo la propria patch e, in seguito, applicando il nuovo aggiornamento:<br />
<pre><br />
$ cd linux-2.6.19-dirty<br />
$ patch -p1 -R < ../my_patch<br />
$ patch -p1 < ../patch-2.6.20<br />
$ cd ..<br />
$ mv linux-2.4.19-dirty linux-2.6.20-dirty<br />
</pre><br />
<br />
* Provare ad applicare la propria patch al nuovo aggiornamento:<br />
<pre><br />
$ cd linux-2.6.20-dirty<br />
$ patch -p1 < ../my_patch<br />
</pre><br />
<br />
Se l'applicazione della patch provoca dei problemi, è necessario risolvere i conflitti creati (il comando ''patch'' informerà circa questi conflitti creando i file ''.rej'' e ''.orig'' per l'analisi e la correzioni da parte dello sviluppatore). <br />
Questo processo di ''fusione'' (''merge'') può rappresentare la parte più difficile dell'intero processo se sono stati apportati cambiamenti a porzioni di codice che sono state modificate anche da altri.<br />
<br />
Per applicare correttamente questo processo di sviluppo, consiglio vivamente di utilizzare l'eccellente insieme di programmi ''patchutils'' (reperibile qui: ''http://cyberelk.net/tim/patchutils''). Questi programmi permettono di manipolare le patch facilmente e hanno risparmiato agli sviluppatori molte ore di tedioso lavoro.<br />
<br />
<br />
== Gestire le proprie patch con quilt ==<br />
<br />
I programmi ''patch'' e ''diff'' risultano essere molto utili e funzionali per lo sviluppo del kernel. Ma dopo un certo periodo di utilizzo, molti si stancano di questo modo si procedere nello sviluppo e cercano altra strade che non coinvolgano le noiose attività di pacthing e merging. Fortunatamente, alcuni sviluppatori del kernel hanno realizzato un programma chiamato ''quilt'' che gestisce il processo di manipolazione delle patch in modo molto più semplice.<br />
<br />
L'idea alla base di ''quilt'' discende da un insieme di script di Andrew Morton, realizzati originariamente per gestire il codice del sottosistema di gestione della memoria e, in seguito, utilizzati per l'intero kernel. I suoi script erano legati molto strettamente al processo di sviluppo, ma l'idea sottostante era molto potente.<br />
Andreas Gruenbacher ha quindi ripreso questa idea creando ''quilt''.<br />
<br />
L'idea principale sottostante ''quilt'' è di lavorare con una versione ''pulita'' del kernel alla quale aggiungere un insieme di patch. E&grave; possibile inserire e togliere diverse patch dal sorgente e mantenere una lista delle patch in modo molto semplice.<br />
<br />
1. Per iniziare, creiamo una directory contenente il sorgente del kernel:<br />
<pre><br />
$ tar -zxf linux-2.6.19.tar.gz<br />
$ ls<br />
linux-2.6.19/<br />
</pre><br />
<br />
2. Spostiamoci in tale directory:<br />
<pre><br />
$ cd linux-2.6.19<br />
</pre><br />
<br />
3. Creiamo una directory ''patches'' che conterrà tutte le nostre patch:<br />
<pre><br />
$ mkdir patches<br />
</pre><br />
<br />
4. Tramite ''quilt'' creiamo una nuova patch chiamata ''patch1'':<br />
<pre><br />
$ quilt new patch1<br />
Patch patches/patch1 is now on top<br />
</pre><br />
<br />
5. ''quilt'' necessita di sapere quali file saranno modificati da questa patch. Per fare questo, utilizziamo il comando ''add'':<br />
<pre><br />
$ quilt add Makefile<br />
File Makefile added to patch patches/patch1<br />
</pre><br />
<br />
6. Apriamo il file ''Makefile'' e modifichiamo la linea EXTRAVERSION, salvando poi il file. Alla fine, aggiorniamo la patch tramite ''quilt'':<br />
<br />
<pre><br />
$ quilt refresh<br />
Refreshed patch patches/patch1<br />
</pre><br />
<br />
Il file ''patches/patch1'' conterrà una patch con tutti i cambiamenti appena fatti:<br />
<pre><br />
$ cat patches/patch1<br />
Index: linux-2.6.19/Makefile<br />
===================================================================<br />
--- linux-2.6.19.orig/Makefile<br />
+++ linux-2.6.19/Makefile<br />
@@ -1,7 +1,7 @@<br />
VERSION = 2<br />
PATCHLEVEL = 6<br />
SUBLEVEL = 19<br />
-EXTRAVERSION =<br />
+EXTRAVERSION = -dirty<br />
NAME=Crazed Snow-Weasel<br />
# *DOCUMENTATION*<br />
</pre><br />
<br />
Ora è possibile continuare a lavorare su una patch, o crearne una nuova in testa a quella attuale.<br />
Ad esempio, se sono state create tre diverse patch ''patch1'', ''patch2'' e ''patch3'', esse saranno applicate una sopra l'altra.<br />
Per vedere la lista delle patch attualmente applicate:<br />
<pre><br />
$ quilt series -v<br />
+ patches/patch1<br />
+ patches/patch2<br />
= patches/patch3<br />
</pre><br />
<br />
Il risultato del comando mostra che tutte e tre le patch sono state applicate e che quella corrente è la ''patch3''.<br />
Al rilascio di una nuova versione del kernel, se si vuole portare i cambiamenti effettuati sulla versione precedente anche sulla nuova versione, è possibile utilizzare ''quilt'' secondo i seguenti passi:<br />
<br />
1. Togliere le patch attualmente applicate al sorgente<br />
<pre><br />
$ quilt pop -a<br />
Removing patch patches/patch3<br />
Restoring drivers/usb/Makefile<br />
Removing patch patches/patch2<br />
Restoring drivers/Makefile<br />
Removing patch patches/patch1<br />
Restoring Makefile<br />
No patches applied<br />
</pre><br />
<br />
2. Utilizzando la patch ufficiale da ''kernel.org'' aggiornare la vecchia versione del kernel:<br />
<pre><br />
$ patch -p1 < ../patch-2.6.20<br />
$ cd ..<br />
$ mv linux-2.6.19 linux-2.6.20<br />
</pre><br />
<br />
3. A questo punto, tramite ''quitl'' applicare nuovamente le patch sul nuovo sorgente:<br />
<pre><br />
$ quilt push<br />
Applying patch patches/patch1<br />
patching file Makefile<br />
Hunk #1 FAILED at 1.<br />
1 out of 1 hunk FAILED -- rejects in file Makefile<br />
Patch patches/patch1 does not apply (enforce with -f)<br />
</pre><br />
<br />
4. Come risultato, le patch non si applicano immediatamente senza problemi. E&grave; possibile forzare l'applicazione della patch e poi procedere alle correzioni necessarie:<br />
<pre><br />
$ quilt push -f<br />
Applying patch patches/patch1<br />
patching file Makefile<br />
Hunk #1 FAILED at 1.<br />
1 out of 1 hunk FAILED -- saving rejects to file Makefile.rej<br />
Applied patch patches/patch1 (forced; needs refresh)<br />
$ vim Makefile.rej Makefile<br />
</pre><br />
<br />
5. Dopo aver applicato manualmente la patch, aggiornare la patch:<br />
<pre><br />
$ quilt refresh<br />
Refreshed patch patches/patch1<br />
</pre><br />
<br />
6. Procedere all'applicazione delle altre patch:<br />
<pre><br />
$ quilt push<br />
Applying patch patches/patch2<br />
patching file drivers/Makefile<br />
Now at patch patches/patch2<br />
$ quilt push<br />
Applying patch patches/patch3<br />
patching file drivers/usb/Makefile<br />
Now at patch patches/patch3<br />
</pre><br />
<br />
<br />
''quilt'' ha anche delle opzioni che permettono di inviare automaticamente le nuove patch ad un gruppo di persone o a una mailing list, di eliminare specifiche patch all'interno della serie, di ricercare una specifica patch all'interno della serie e molte altre utili opzioni.<br />
<br />
''quilt'' è vivamente consigliato per qualsiasi attività di sviluppo del kernel, anche per tenere traccia di poche patch, invece di usare i più ostici ''diff'' e ''patch''. E&grave; decisamente più semplice e consente di risparmiare parecchio tempo e sforzi.<br />
<br />
Come nota personale, non raccomanderò mai abbastanza l'utilizzo di questo strumento, poiché lo utilizzo tutti i giorni per gestire centinaia di patch in diversi rami di sviluppo.<br />
Esso è anche usato da numerose distribuzioni Linux per gestire il proprio kernel e può contare su una comunità di sviluppo entusiasta e reattiva.<br />
<br />
== git ==<br />
<br />
''git'' è uno strumento di controllo del codice sorgente originariamente scritto da Linus Torvalds quando stava cercando un nuovo sistema di gestione del codice per il kernel di Linux.<br />
<br />
&Egrave; un sistema distribuito che differisce dai sistemi tradizionali di gestione del codice (come ad esempio CVS) nel fatto che non è necessario essere connessi al server per effettuare un commit sul deposito.<br />
<br />
''git'' è uno dei più potenti, flessibili e veloci sistemi di gestione del codice sorgente attualmente disponibili, e ha alle spalle un team di sviluppo molto attivo.<br />
La pagina principale di ''git'' è ''http://git.or.cz/''. <br />
Si consiglia ad ogni nuovo utente di seguire le guide pubblicate al fine di familiarizzare con la modalità di funzionamento di git, in modo da poterlo utilizzare correttamente.<br />
<br />
Il kernel di Linux è sviluppato utilizzando ''git'', e le ultime versioni possono essere trovate all'indirizzo ''http://www.kernel.org/git/'' insieme ad una vasta lista di altri depositi git.<br />
<br />
Non è necessario utilizzare ''git'' per sviluppare il kernel di Linux, ma è molto utile per tenere traccia dei bug rilevati.<br />
Se doveste segnalare un bug agli sviluppatori del kernel, essi potranno richiedevi di utilizzare ''git bisect'' al fine di identificare l'esatta modifica che ha causato il bug. In questo caso, potete seguire le indicazioni sulla documentazione di ''git'' per capire come procedere.<br />
<br />
== ketchup ==<br />
<br />
''ketchup'' è uno strumento molto comodo utilizzato per aggiornare una versione del kernel o per passare da una versione all'altra del codice sorgente.<br />
<br />
Esso offre la possibilità di:<br />
* Trovare l'ultima versione del kernel, scaricarla e decomprimerla.<br />
* Aggiornare una versione attualmente installata del codice sorgente del kernel, applicando le patch necessarie.<br />
* Gestire i diversi rami di sviluppo del kernel, incluse le versioni -mm e -stable<br />
* Scaricare qualsiasi patch o archivio tar necessario per l'aggiornamento, se non già presenti sulla macchina locale.<br />
* Controllare la firma GPG dell'archivio e delle patch per verificarne l'integrità.<br />
<br />
''ketchup'' si trova all'indirizzo ''http://www.selenic.com/ketchup/'' insieme a molta documentazione presente nel wiki ''http://www.selenic.com/ketchup/wiki/''.<br />
<br />
Di seguito un esempio che illustra quanto sia semplice utilizzare ''ketchup'' per fare scaricare una specifica versione del kernel e '''per passare ad un'altra versione''' con un numero minimo di comandi.'''VERIFICARE LA TRADUZIONE DELLA PARTE IN GRASSETTO [...and then have it switch the directory to another kernel version...]'''<br />
<br />
Per scaricare il sorgente del kernel 2.6.16.24 in una directory, e rinominare la directory perché abbia lo stesso nome della versione del kernel, utilizzare il seguente comando:<br />
<br />
<pre><br />
$ mkdir foo<br />
$ cd foo<br />
$ ketchup -r 2.6.16.24<br />
None -> 2.6.16.24<br />
Unpacking linux-2.6.17.tar.bz2<br />
Applying patch-2.6.17.bz2 -R<br />
Applying patch-2.6.16.24.bz2<br />
Current directory renamed to /home/gregkh/linux/linux-2.6.16.24<br />
</pre><br />
<br />
Ora, per aggiornare il sorgente affinché contenga l'ultimo rilascio stabile, digitare:<br />
<pre><br />
$ ketchup -r 2.6<br />
2.6.16.24 -> 2.6.17.11<br />
Applying patch-2.6.16.24.bz2 -R<br />
Applying patch-2.6.17.bz2<br />
Downloading patch-2.6.17.11.bz2<br />
--22:21:14-- http://www.kernel.org/pub/linux/kernel/v2.6/patch-2.6.17.11.bz2<br />
=> `/home/greg/.ketchup/patch-2.6.17.11.bz2.partial'<br />
Resolving www.kernel.org... 204.152.191.37, 204.152.191.5<br />
Connecting to www.kernel.org|204.152.191.37|:80... connected.<br />
HTTP request sent, awaiting response... 200 OK<br />
Length: 36,809 (36K) [application/x-bzip2]<br />
100%[====================================>] 36,809 93.32K/s<br />
22:21:14 (92.87 KB/s) - `/home/greg/.ketchup/patch-2.6.17.11.bz2.partial'saved [36809/36809]<br />
Downloading patch-2.6.17.11.bz2.sign<br />
--22:21:14-- http://www.kernel.org/pub/linux/kernel/v2.6/patch-2.6.17.11.bz2.sign<br />
=> `/home/greg/.ketchup/patch-2.6.17.11.bz2.sign.partial'<br />
Resolving www.kernel.org... 204.152.191.37, 204.152.191.5<br />
Connecting to www.kernel.org|204.152.191.37|:80... connected.<br />
HTTP request sent, awaiting response... 200 OK<br />
Length: 248 [application/pgp-signature]<br />
100%[====================================>] 248 --.--K/s<br />
22:21:14 (21.50 MB/s) - `/home/greg/.ketchup/patch-2.6.17.11.bz2.sign.<br />
partial' saved [248/248]<br />
Verifying signature...<br />
gpg: Signature made Wed Aug 23 15:01:04 2006 PDT using DSA key ID 517D0F0E<br />
gpg: Good signature from "Linux Kernel Archives Verification Key ><br />
ftpadmin@kernel.org<"<br />
gpg: WARNING: This key is not certified with a trusted signature!<br />
gpg: There is no indication that the signature belongs to the owner.<br />
Primary key fingerprint: C75D C40A 11D7 AF88 9981 ED5B C86B A06A 517D 0F0E<br />
Applying patch-2.6.17.11.bz2<br />
Current directory renamed to /home/greg/linux/tmp/x/linux-2.6.17.11<br />
</pre><br />
<br />
<br />
Questo esempio mostra come ''ketchup'' determini in modo automatico che la nuova versione stabile del kernel è la 2.6.17.11 e scarichi le patch necessarie per aggiornare il sorgente.<br />
<br />
L'uso di ''ketchup'' è vivamente consigliato per scaricare qualsiasi sorgente del kernel di Linux. Esso si occupa di reperire le patch necessarie sul server e applicarle automaticamente nel modo corretto, dopo averne controllato l'autenticità tramite la firma digitale.<br />
<br />
L'uso combinato di ''ketchup'' e ''quilt'' permette di avere tutto ciò che serve per gestire il kernel di Linux e per soddisfare le esigenze degli sviluppatori.<br />
<br />
----<br />
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].<br />
----<br />
<br />
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/appa.pdf ''Capitolo originale'']<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14924LKN: Personalizzare un Kernel2007-08-22T18:16:13Z<p>TheNoise: aggiunto link pdf originale</p>
<hr />
<div></div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Ricette_per_Configurare_il_Kernel&diff=14922LKN: Ricette per Configurare il Kernel2007-08-22T18:14:21Z<p>TheNoise: aggiunto link pdf originale</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
__TOC__<br />
<br />
Il [[LKN:_Personalizzare_un_Kernel|capitolo precedente]] ci ha insegnato i meccanismi per la riconfigurazione del kernel; in questo capitolo arriva la parte interessante, in cui si possono trovare tutte le modifiche più comuni che gli utenti hanno bisogno di apportare ai loro kernel, con le istruzioni specifiche per effettuarle.<br />
<br />
<br />
== '''Dischi''' ==<br />
<br />
Il kernel Linux supporta una grande varietà di differenti tipi di disco. Questa sezione mostra come configurare il kernel in modo tale che supporti la maggior parte dei modelli più comuni di controller di disco.<br />
<br />
'''Periferiche USB'''<br />
<br />
Per utilizzare una periferica di archiviazione USB (come quelle chiamate comunemente memorie "flash" USB, oppure dischi esterni USB) il supporto USB deve prima funzionare correttamente. Fare riferimento alla ricetta nella sezione chiamata [[USB]] per sapere come fare.<br />
<br />
Una periferica di archiviazione USB può essere identificata utilizzando il programma ''lsusb''. Se la sequenza di comandi che segue produce i risultati mostrati, nel sistema è presente una periferica di archiviazione USB:<br />
<br />
<pre><br />
$ /usr/sbin/lsusb -v | grep Storage<br />
bInterfaceClass 8 Mass Storage<br />
</pre><br />
<br />
Abilitatelo nel modo seguente.<br />
1. A USB Storage device is in reality a USB SCSI device that talks over a USB<br />
connection. Because of this, the SCSI subsystem must be enabled:<br />
<br />
<pre><br />
Device Drivers<br />
SCSI Device Support<br />
[*] SCSI Device Support<br />
</pre><br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/ch08.pdf ''Capitolo originale'']<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Ricette_per_Configurare_il_Kernel&diff=14921LKN: Ricette per Configurare il Kernel2007-08-22T18:14:00Z<p>TheNoise: aggiunto link pdf originale</p>
<hr />
<div>{{stub}}<br />
<br />
=Intro=<br />
== Prerequisiti ==<br />
<br />
Per affrontare la costruzione di un cluster si dovra' sapere installare e configurare correttamente un sistema Debian/Linux, ricompilare un Kernel e avere buone conoscenze di networking.<br />
<br />
<br />
== Brevi accenni al clustering ==<br />
<br />
Un cluster (letteralmente grappolo) e' un insieme di unita' indipendenti di calcolo (es. PC) che cooperano <br />
per la soluzione di un problema comune.<br />
Le varie unita' di calcolo sono connesse tra loro tramite un mezzo di comunicazione e il calcolo viene distribuito in maniera differente in base a come e' stato creato il cluster.<br />
<br />
In questa guida si trattera' solo di una parte del calcolo distribuito, quella piu' "casalinga", ricordando pero' che esistono altre soluzioni molto piu' performanti e dedicate.<br />
<br />
OpenMosix svolge un tipo di distribuzione del calcolo molto semplice e trasparente per l'utente.<br />
Esso si occupa di dividere in maniera equa i processi tra tutti i nodi che cooperano, funziona molto bene con i programmi che svolgono un lavoro non sequenziale ma che dividono il lavoro in parti (fork).<br />
<br />
Un esempio di operazione che viene distribuita ben e' la ricompilazione del kernel o il rendering di immagini.<br />
<br />
<br />
== Scenario == <br />
Lo scenario tipico in cui si usa OpenMosix e' una serie di PC collegati tra loro tramite una connessione ethernet.<br />
Non importa che i PC siano tutti uguali, inquanto si occupera' il sistema a decidere se un processo deve essere distribuito tra i nodi oppure no.<br />
<br />
= Installazione =<br />
Openmosix lavora tra il livello Userspace e il livello kernelspace, per la costruzione si deve patchare e ricompilare il kernel<br />
<br />
==Patch del kernel==<br />
*Scaricare il kernel 2.4.26 <br />
/root># wget http://www.kernel.org/pub/linux/kernel/v2.4/linux-2.4.6.tar.bz2<br />
*Scompattarlo in /usr/src<br />
/root># mv kernel-2.4.26.tar.bz /usr/src<br />
/root># cd /usr/src<br />
/usr/src# tar xfvj linux-2.4.26.tar.bz<br />
*Creare un link simbolico come segue<br />
/usr/src># ln -s linux-2.4.26 linux-openmosix<br />
*Scaricare la patch openmosix<br />
/usr/src> wget http://switch.dl.sourceforge.net/sourceforge/openmosix/openMosix-2.4.26-1.bz2 <br />
*Patchare il kernel<br />
bzcat openMosix-2.4.26-1.bz2 | patch -Np1<br />
*Ricompilare il kernel attivando le voci relative ad openmosix<br />
<br />
==Installare OMtools==<br />
*Scarichiamo il pacchetto e scompattiamolo<br />
/root># wget http://heanet.dl.sourceforge.net/sourceforge/openmosix/openmosix-tools-0.3.6-2.tar.gz<br />
/root># mv openmosix-tools-0.3.6-2.tar.gz /opt<br />
/root># tar xfvz openmosix-tools-0.3.6-2.tar.gz<br />
*Installiamolo <br />
/root># cd /opt/openmosix-tools-0.3.6-2 <br />
/opt/omtools># ./configure && make && make install<br />
<br />
= Configurazione =<br />
<br />
== openmosix.map==<br />
Editare /etc/openmosix.map per indicare ad OpenMosix quali sono i nodi appartenti alla rete che coopereranno.<br />
<br />
Il file dovra' contenere nel primo campo il numero del nodo e poi il suo indirizzo IP o il suo nome (che dovra' essere presente in /etc/hosts).<br />
L'ultimo campo sara' il numero di processori presenti in ogni macchina.<br />
<br />
1 nodo1 1<br />
2 nodo2 1<br />
3 nodo3 1<br />
4 nodo4 2<br />
<br />
oppure<br />
<br />
1 192.168.0.1 1 <br />
2 192.168.0.2. 2<br />
3 192.168.0.43 1<br />
4 192.168.0.3 1<br />
<br />
=Test=<br />
*Avviare il demone in tutti i nodi <br />
/root># /etc/init.d/openmosix start<br />
<br />
*Lanciare il contro grafico<br />
/root># mosmon<br />
Se tutto e' apposto si dovrebbe vedere il grafico col nostro nodo.</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Installare_ed_Avviare_con_un_Kernel&diff=14919LKN: Installare ed Avviare con un Kernel2007-08-22T18:13:31Z<p>TheNoise: aggiunto link pdf originale</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
__TOC__<br />
<br />
I precedenti capitoli hanno mostrato come scaricare e compilare il kernel. Ora che si ha un file eseguibile -- con tutti i moduli compilati -- è ora di installare il kernel e provare a fare il boot. In questo capitolo, a differenza dei precedenti, tutti i comandi necessitano di essere eseguiti come utente root. Questo può essere fatto anteponendo ad ogni comando ''sudo'', usando il comando ''su'' per diventare root, oppure accedendo come ''root''.<br />
<br />
Per vedere se si ha ''sudo'' installato e gli appropriati diritti di accesso, lanciate:<br />
<br />
<pre><br />
$ sudo ls ~/linux/linux-2.6.17.11/Makefile<br />
Password:<br />
Makefile<br />
</pre><br />
<br />
Inserite la vostra password personale al prompt di password, o la password dell'amministratore di sistema (root). La scelta dipende da come il comando di ''sudo'' è stato impostato. Se non ci sono problemi, e si vede una riga che contiene:<br />
<br />
<pre> Makefile </pre><br />
<br />
allora potete passare alla prossima sezione.<br />
<br />
Se ''sudo'' non è installato o non si hanno i diritti appropriati, si provi ad usare il comando ''su'':<br />
<br />
<pre><br />
$ su<br />
Password:<br />
# exit<br />
exit<br />
$<br />
</pre><br />
<br />
Al prompt della password, inserite la password dell'amministratore di sistema (''root''). Quando ''su'' accetta con successo la password, si è trasferiti ad eseguire ogni cosa con i pieni privilegi di root. State molto attenti mentre siete ''root'', e fate solo il minimo necessario; dopodiché uscite dal programma per tornare con il vostro utente normale.<br />
<br />
<br />
== Usare uno script di installazione di una distribuzione ==<br />
<br />
<br />
Quasi tutte le distribuzioni hanno uno script chiamato ''installkernel'' che può essere usato dal sistema di creazione del kernel per installarne uno pronto automaticamente nel giusto posto e per modificare il bootloader così che nulla di più debba essere fatto dallo sviluppatore *.<br />
<br />
<pre><br />
Le distribuzioni offrono installkernel solitamente in un pacchetto chiamato mkinitrd, provate ad installare <br />
questo pacchetto se non trovate lo script sulla vostra macchina.<br />
</pre><br />
<br />
Se avete compilato qualsiasi modulo e volete usare questo metodo per installare un kernel, inserite:<br />
<br />
'''# make modules_install'''<br />
<br />
Questo installerà tutti i moduli che avete compilato e li metterà nelle appropriate locazioni del filesystem per farli trovare correttamente dal nuovo kernel. I moduli sono posti in ''/lib/modules/kernel_version'', dove per ''kernel_version'' si intende la versione del nuovo kernel che state preparando.<br />
<br />
Dopo che i moduli sono stati installati con successo, l'immagine principale del kernel deve essere installata:<br />
<br />
'''# make install'''<br />
<br />
Questo causerà:<br />
<br />
1. Il sistema di creazione del kernel verificherà che il kernel sia stato correttamente costruito.<br />
<br />
2. Il sistema di creazione copierà la parte statica nella directory ''/boot'' e rinominerà l'eseguibile sulla base della versione del kernel.<br />
<br />
3. Qualsiasi immagine di ramdisk iniziale necessaria verrà creata automaticamente, usando i moduli che sono appena stati installati durante la fase di ''modules_install''.<br />
<br />
4. Al programma di bootloader verrà correttamente notificato che un nuovo kernel è presente, e verrà aggiunto nel giusto menu così che l'utente possa selezionarlo la prossima volta che la macchina verrà avviata.<br />
<br />
5. Dopo questo ha finito, il kernel è installato con successo, si può tranquillamente riavviare e provare la nuova immagine di kernel. Notare che questa installazione non sovrascrive nessuna vecchia immagine dei kernel, così se c'è un problema con la vostra nuova immagine del kernel, il vecchio kernel potrà essere selezionato al boot time.<br />
<br />
<pre><br />
* Eccezioni da riportare a questa regola sono Gentoo e altre distribuzioni tipo "from scratch", le quali si<br />
aspettano che l'utente sappia come installare i kernel da solo. Questi tipi di distribuzioni includono la <br />
documentazione su come installare un nuovo kernel, si consulti quest'ultima per l'esatto metodo richiesto.<br />
</pre><br />
<br />
== Installazione manuale ==<br />
<br />
<br />
Se la distribuzione non è provvista del comando ''installkernel'', o si desidera semplicemente fare il lavoro a mano per capire i passi che servono, eccoli qua:<br />
<br />
I moduli devono essere installati:<br />
<br />
<pre> # make modules_install </pre><br />
<br />
L'immagine statica del kernel deve essere copiata nella directory /boot. Per un kernel basato su piattaforma i386, fare:<br />
<br />
<pre> <br />
# make kernelversion <br />
2.6.17.11<br />
</pre><br />
<br />
Notare che la versione del kernel probabilmente sarà differente da quella del vostro. Usate questo valore al posto del testo KERNEL_VERSION nei seguenti passaggi:<br />
<br />
<pre><br />
# cp arch/i386/boot/bzImage /boot/bzImage-KERNEL_VERSION<br />
# cp System.map /boot/System.map-KERNEL_VERSION<br />
</pre><br />
<br />
Modificate il bootloader in modo che conosca il nuovo kernel. Questo implica modificare il file di configurazione per il bootloader che si usa, è spiegato più avanti in "Modificare il bootloader per il nuovo kernel" in GRUB e LILO.<br />
<br />
Se il processo di avvio non funziona, solitamente è perché una immagine iniziale di ramdisk (initial ramdisk) è necessaria. Per crearla correttamente, si usino i passi all'inizio di questo capitolo per installare un kernel automaticamente, poich&eacute; lo script di installazione della distribuzione sa come creare adeguatamente il ramdisk usando gli script e gli strumenti necessari. Dato che ogni distribuzione fa questo in maniera differente, è oltre lo scopo di questo libro ricoprire tutti i differenti metodi di costruzione dell'immagine di ramdisk.<br />
<br />
Qui c'è uno script comodo che può essere usato per installare un kernel automaticamente invece di dover digitare tutti i precedenti comandi ogni volta:<br />
<br />
<pre><br />
#!/bin/sh<br />
#<br />
# installs a kernel<br />
#<br />
make modules_install<br />
<br />
# find out what kernel version this is<br />
for TAG in VERSION PATCHLEVEL SUBLEVEL EXTRAVERSION ; do<br />
eval `sed -ne "/^$TAG/s/ //gp" Makefile`<br />
done<br />
SRC_RELEASE=$VERSION.$PATCHLEVEL.$SUBLEVEL$EXTRAVERSION<br />
<br />
# figure out the architecture<br />
ARCH=`grep "CONFIG_ARCH " include/linux/autoconf.h | cut -f 2 -d "\""`<br />
<br />
# copy the kernel image<br />
cp arch/$ARCH/boot/bzImage /boot/bzImage-"$SRC_RELEASE"<br />
<br />
# copy the System.map file<br />
cp System.map /boot/System.map-"$SRC_RELEASE"<br />
<br />
echo "Installed $SRC_RELEASE for $ARCH"<br />
</pre><br />
<br />
<br />
== Modificare il bootloader per il nuovo kernel ==<br />
<br />
<br />
Esistono due bootloader comuni per i kernel Linux: GRUB e LILO. GRUB è quello maggiormente usato nelle distribuzioni moderne, e fa' alcune cose un po' più facilmente di LILO, ma LILO é tuttora anch'esso utilizzato. Li vedremo entrambi in questa sezione.<br />
<br />
Per determinare quale bootloader il vostro sistema usa, guardate nella directory ''/boot/''. Se esiste una sottodirectory ''grub'':<br />
<br />
<pre><br />
$ ls -F /boot | grep grub<br />
grub/<br />
</pre><br />
<br />
allora si sta utilizzando GRUB come programma per fare il boot. Se questa directory non è presente, si guardi se è presente il file ''/etc/lilo.conf'':<br />
<br />
<pre><br />
$ ls /etc/lilo.conf<br />
/etc/lilo.conf<br />
</pre><br />
<br />
se è presente, state usando LILO come programma per fare il boot.<br />
I passi che implicano l'aggiunta del nuovo kernel a ognuno di questi programmi sono differenti, per cui si segua solo la sezione che corrisponde al programma che si sta usando.<br />
<br />
==='''GRUB'''===<br />
<br />
Per fare in modo che GRUB sappia che un nuovo kernel è presente, tutto ciò che dovete fare è modificare il file ''/boot/grub/menu/lst''. Per i dettagli completi della struttura di questo file, e tutte le differenti opzioni disponibili, consultate le pagine di info di GRUB:<br />
<br />
<br />
'''$ info grub'''<br />
<br />
<br />
Il metodo più veloce per aggiungere una nuova voce kernel a ''/boot/grub/menu.lst'' è quello di copiare una voce già esistente. Per esempio, considerate il seguente ''menu.lst'' da un sistema Gentoo:<br />
<br />
<pre><br />
timeout 300<br />
default 0<br />
<br />
splashimage=(hd0,0)/grub/splash.xpm.gz<br />
<br />
title 2.6.16.11<br />
root (hd0,0)<br />
kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305<br />
<br />
title 2.6.16<br />
root (hd0,0)<br />
kernel /bzImage-2.6.16 root=/dev/sda2 vga=0x0305<br />
</pre><br />
<br />
La linea che comincia con la parola title definisce una nuova voce di kernel, in questo modo questo file contiene due voci. Copiate semplicemente un blocco di linee che cominciano con la linea title, come:<br />
<br />
<pre><br />
title 2.6.16.11<br />
root (hd0,0)<br />
kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305<br />
</pre><br />
<br />
Dopodiché aggiungete il blocco alla fine del file, e modificate il numero di versione con la nuova versione del nuovo kernel che si è appena installato. Il titolo non ha alcuna importanza, purché unico, ma visualizzato nel menu di boot, per cui si dovrebbe dargli qualcosa che abbia un significato. Nel nostro esempio, abbiamo installato il kernel 2.6.17.11, per tanto la copia finale del file assomiglierà a:<br />
<br />
<pre><br />
timeout 300<br />
default 0<br />
<br />
splashimage=(hd0,0)/grub/splash.xpm.gz<br />
<br />
title 2.6.16.11<br />
root (hd0,0)<br />
kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305<br />
<br />
title 2.6.16<br />
root (hd0,0)<br />
kernel /bzImage-2.6.16 root=/dev/sda2 vga=0x0305<br />
<br />
title 2.6.17.11<br />
root (hd0,0)<br />
kernel /bzImage-2.6.17.11 root=/dev/sda2 vga=0x0305<br />
</pre><br />
<br />
Dopo che si è salvato il file, riavviate il sistema e assicuratevi che il titolo della nuova immagine del kernel sia presente nel menu di boot. Usate la freccia verso il basso per evidenziare la versione del nuovo kernel, e premete enter per avviare la nuova immagine.<br />
<br />
==='''LILO'''===<br />
<br />
Per fare in modo che LILO sappia che un nuovo kernel è presente, dovete modificare il file di configurazione ''/etc/lilo.conf'' ed eseguire il comando ''lilo'' per applicare le modifiche fatte al file di configurazione. Per i dettagli completi sulla struttura del file di configurazione di LILO, consultate la manpage di LILO:<br />
<br />
'''$ man lilo'''<br />
<br />
Il modo pi&ugrave; facile per aggiungere una nuova voce di kernel nel file ''/etc/lilo.conf'' è copiare una voce esistente. Per esempio, considerate il seguente file di configurazione di LILO di un sistema Gentoo:<br />
<br />
<pre><br />
boot=/dev/hda<br />
prompt<br />
timeout=50<br />
default=2.6.12<br />
<br />
image=/boot/bzImage-2.6.15<br />
label=2.6.15<br />
read-only<br />
root=/dev/hda2<br />
<br />
image=/boot/bzImage-2.6.12<br />
label=2.6.12<br />
read-only<br />
root=/dev/hda2<br />
</pre><br />
<br />
La linea che comincia con la parola image= definisce una nuova voce kernel, quindi questo file contiene due voci. Copiate semplicemente un blocco di linee che cominciano con image=, come:<br />
<br />
<pre><br />
image=/boot/bzImage-2.6.15<br />
label=2.6.15<br />
read-only<br />
root=/dev/hda2<br />
</pre><br />
<br />
Aggiungete dopo il blocco alla fine del file, e modificate il numero di versione per contenere quella del nuovo kernel appena installato. La label non ha alcuna importanza, purché unica, ma è visualizzata nel menu di boot, per cui dovreste dargli qualcosa di sensato. Nel nostro esempio, abbiamo installato il kernel 2.6.17.11, per cui la copia finale del file sarà:<br />
<br />
<pre><br />
boot=/dev/hda<br />
prompt<br />
timeout=50<br />
default=2.6.12<br />
<br />
image=/boot/bzImage-2.6.15<br />
label=2.6.15<br />
read-only<br />
root=/dev/hda2<br />
<br />
image=/boot/bzImage-2.6.12<br />
label=2.6.12<br />
read-only<br />
root=/dev/hda2<br />
<br />
image=/boot/bzImage-2.6.17<br />
label=2.6.17<br />
read-only<br />
root=/dev/hda2<br />
</pre><br />
<br />
Dopo aver salvato il file, lanciate il programma ''/sbin/lilo'' per salvare i cambiamenti del file di configurazione nella sezione di boot del disco:<br />
<br />
<pre> # /sbin/lilo </pre><br />
<br />
Ora il sistema può essere riavviato in sicurezza. La scelta del nuovo kernel si può vedere tra le scelte disponibili al momento del boot. Usate la freccia verso il basso per evidenziare la versione del nuovo kernel, premete Invio per avviare la nuova immagine.<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/ch05.pdf ''Capitolo originale'']<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Configurare_e_Compilare&diff=14918LKN: Configurare e Compilare2007-08-22T18:13:18Z<p>TheNoise: aggiunto link pdf originale</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
__TOC__<br />
<br />
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''.<br />
<br />
== '''Creare una configurazione''' ==<br />
<br />
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]].<br />
<br />
==='''Configurare dall'inizio'''===<br />
Il modo più spartano per configurare un kernel è usare il metodo ''make config'':<br />
<pre>$ cd linux-2.6.17.10<br />
$ make config<br />
make config<br />
scripts/kconfig/conf arch/i386/Kconfig<br />
*<br />
* Linux Kernel Configuration<br />
*<br />
*<br />
* Code maturity level option<br />
*<br />
Prompt for development and/or incomplete code/drivers (EXPERIMENTAL) [Y/n/?]<br />
Y<br />
<br />
*<br />
* General setup<br />
*<br />
Local version - append to kernel release (LOCALVERSION) []<br />
Automatically append version information to the version string<br />
(LOCALVERSION_AUTO) [Y/n/?] Y<br />
...</pre><br />
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:<br />
* <tt>Y</tt> Compilare direttamente nel kernel.<br />
* <tt>n</tt> Lasciare completamente al di fuori del kernel.<br />
* <tt>m</tt> Compilare come modulo, da caricare se necessario.<br />
* <tt>?</tt> Stampa un breve messaggio descrittivo e ripropone il quesito.<br />
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.<br />
<br />
==='''Opzioni della configurazione predefinita'''===<br />
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.<br />
<br />
Per creare questa configurazione predefinita, eseguite:<br />
<pre>$ cd linux-2.6.17.10<br />
$ make defconfig</pre><br />
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.<br />
<br />
==='''Modificare la configurazione'''===<br />
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.<br />
<br />
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''.<br />
<br />
==='''Configurazione tramite terminale'''===<br />
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:<br />
<pre>$ make menuconfig</pre><br />
Vi apparirà una schermata molto simile a quella di figura 4-1.<br />
<br />
[[Immagine:Menuconfig_1.png|center|500px|thumb|''Figura 4-1. Schermata iniziale di menuconfig'']]<br />
<br />
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.<br />
<br />
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>.<br />
<br />
[[Immagine:Menuconfig_2.png|center|500px|thumb|''Figura 4-2. Selezione dell'opzione Device Drivers'']]<br />
<br />
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.<br />
<br />
Premete poi il tasto Invio. Vi porterà nel sotto-menu <tt>Device Drivers</tt> e lo mostrerà come mostrato nella figura 4-3.<br />
<br />
[[Immagine:Menuconfig_3.png|center|500px|thumb|''Figura 4-3. Sottomenu Device Drivers'']]<br />
<br />
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.<br />
<br />
[[Immagine:Menuconfig_4.png|center|500px|thumb|''Figura 4-4. Sottomenu Generic Driver Options'']]<br />
<br />
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>).<br />
<br />
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.<br />
<br />
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.<br />
<br />
[[Immagine:Menuconfig_5.png|center|500px|thumb|''Figura 4-5. Sottomenu Generic Driver Options cambiato'']]<br />
<br />
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.<br />
<br />
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.<br />
<br />
[[Immagine:Menuconfig_6.png|center|500px|thumb|''Figura 4-6. Salvare le opzioni del kernel'']]<br />
<br />
Vi sarà mostrata la schermata in figura 4-6, che vi chiede se desiderate salvare la vostra modificata configurazione.<br />
<br />
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.<br />
<br />
<br />
==='''Metodi grafici di configurazione'''===<br />
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.<br />
<br />
[[Immagine:Gconfig_1.png|center|500px|thumb|''Figura 4-7. Schermata di make gconfig'']]<br />
<br />
Il metodo ''xconfig'' è scritto usando il toolkit QT e ha uno schermo diviso in tre regioni, come in figura 4-8.<br />
<br />
[[Immagine:Xconfig_1.png|center|500px|thumb|''Figura 4-8. Schermata di make xconfig'']]<br />
<br />
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. <br />
<br />
[[Immagine:Xconfig_2.png|center|500px|thumb|''Figura 4-9. Generic Driver Options in make xconfig'']]<br />
<br />
La corrispondente immagine di ''gconfig'' è in figura 4-10.<br />
<br />
[[Immagine:Gconfig_2.png|center|500px|thumb|''Figura 4-10. Generic Driver Options in make gconfig'']]<br />
<br />
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.<br />
<br />
[[Immagine:Xconfig_3.png|center|500px|thumb|''Figura 4-11. Generic Driver Options in make xconfig, modificato'']]<br />
[[Immagine:gconfig_3.png|center|500px|thumb|''Figura 4-12. Generic Driver Options in make gconfig, modificato'']]<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
=='''Compilazione del kernel'''==<br />
Ora che avete creato la configurazione che intendete usare, dovete compilare il kernel. Questo è semplice come digitare un comando di un parola:<br />
<pre>$ make<br />
CHK include/linux/version.h<br />
UPD include/linux/version.h<br />
SYMLINK include/asm -> include/asm-i386<br />
SPLIT include/linux/autoconf.h -> include/config/*<br />
CC arch/i386/kernel/asm-offsets.s<br />
GEN include/asm-i386/asm-offsets.h<br />
CC scripts/mod/empty.o<br />
HOSTCC scripts/mod/mk_elfconfig<br />
MKELF scripts/mod/elfconfig.h<br />
HOSTCC scripts/mod/file2alias.o<br />
HOSTCC scripts/mod/modpost.o<br />
HOSTCC scripts/mod/sumversion.o<br />
HOSTLD scripts/mod/modpost.o<br />
HOSTCC scripts/kallsyms<br />
HOSTCC scripts/conmakehash<br />
HOSTCC scripts/bin2c<br />
CC init/main.o<br />
CHK include/linux/compile.h<br />
UPD include/linux/compile.h<br />
CC init/version.o<br />
CC init/do_mounts.o<br />
...</pre><br />
<br />
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.<br />
<br />
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.<br />
<br />
È 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.<br />
<br />
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.<br />
<br />
=='''Opzioni di compilazione avanzate'''==<br />
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.<br />
<br />
==='''Velocizzare la compilazione in macchine multiprocessore'''===<br />
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.<br />
<br />
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:<br />
<pre>$ make -j4</pre><br />
e per macchine con quattro processori, usate:<br />
<pre>$ make -j8</pre><br />
Se non passate un numero all'opzione ''-j'':<br />
<pre>$ make -j</pre><br />
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''.<br />
<br />
==='''Compilare solo una parte del kernel'''===<br />
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><br />
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.<br />
<br />
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.<br />
<br />
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><br />
Il sistema di compilazione compilerà tutti i file necessari per il modulo visor.ko, e farà il collegamento finale per creare il modulo.<br />
<br />
==='''Sorgente in un posto, destinazione in un altro'''===<br />
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<br />
$ make O=~/linux/linux-2.6.17.11</pre><br />
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.<br />
<br />
==='''Architetture differenti'''===<br />
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.<br />
<br />
Per esempio, per avere la configurazione predefinita dell'architettura x86_64, si può inserire:<br />
<br />
<pre>$ make ARCH=x86_64 defconfig</pre><br />
<br />
Per compilare l'intero kernel con uno strumento per concatenare la compilazione situato in ''/usr/local/bin'', si può inserire:<br />
<pre>$ make ARCH=arm CROSS_COMPILE=/usr/local/bin/arm-linux-</pre><br />
<br />
È 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:<br />
<br />
<pre>$ make CC="ccache gcc"</pre><br />
<br />
Per usare contemporaneamente ''distcc'' e ''ccache'', inserite:<br />
<br />
<pre>$ make CC="ccache distcc"</pre><br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/ch04.pdf ''Capitolo originale'']<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Procurarsi_i_Sorgenti_del_Kernel&diff=14917LKN: Procurarsi i Sorgenti del Kernel2007-08-22T18:12:56Z<p>TheNoise: aggiunto link pdf originale</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
Quando si compila un kernel personalizzato ci si vorrebbe servire dell'ultima versione stabile. Molte distribuzioni forniscono i loro pacchetti dei sorgenti del kernel, ma raramente questi sono i più recenti e aggiornati. I pacchetti ufficiali delle distribuzioni hanno il vantaggio di essere compatibili con il compilatore e gli altri strumenti forniti dalla distribuzione stessa (Il capitolo 2 mette in evidenza l'importanza di questa compatibilità), ma non è detto che permettano di avere le funzionalità o le prestazioni di cui si ha bisogno. Preparando l'ambiente con il kernel più recente e le ultime versioni del compilatore e degli altri programmi sarà possibile ottenere esattamente ciò che si vuole. Questo capitolo spiega quali sorgenti del kernel scaricare e dove trovarli.<br />
<br />
=='''Quale ramo usare'''==<br />
[[Immagine:kernel_releases.png|300px|thumb|Figura 3-1: Ciclo di sviluppo e rilascio del kernel]]<br />
<br />
In passato il kernel Linux era diviso in 2 rami: quello di "sviluppo" e quello "stabile". Per distinguerli, il ramo di sviluppo era contrassegnato da un valore dispari nel secondo numero di release, quello stabile da un valore pari. Ad esempio, la 2.5.25 era una versione di sviluppo, mentre la 2.4.25 era la stabile.<br />
<br />
Quando fu creata la serie 2.6, gli sviluppatori decisero di abbandonare questo metodo basato su due rami separati e annunciarono che tutti i rilasci della serie 2.6 del kernel sarebbero stati considerati "stabili", indipendentemente da quanto veloce fosse stato il processo di sviluppo. I pochi mesi a disposizione tra le versioni maggiori della serie 2.6 avrebbero lasciato agli sviluppatori il tempo necessario per aggiungere nuove funzioni e renderle stabili per il rilascio successivo. Assieme a questo fu creato un ramo "-stabile" del kernel per permettere eventuali correzioni dei bug e aggiornamenti di sicurezza per l'ultima versione, prima che quella nuova venga rilasciata.<br />
Alcuni esempi, illustrati in [[:Immagine:kernel_releases.png|figura 3-1]], aiuteranno a chiarire tutto questo: il team del kernel rilascia la versione stabile 2.6.17; poi gli sviluppatori iniziano a lavorare su nuove caratteristiche e rilasciano la versione -rc del kernel in via di sviluppo, in modo che chi vuole possa aiutare nella fase di test e di debug dei cambiamenti. Quando tutti concordano sul fatto che la versione in via di sviluppo sia abbastanza stabile, questa viene rilasciata come 2.6.18. L'intero ciclo impiega solitamente due o tre mesi, dipendendo da svariati fattori.<br />
<br />
Durante lo sviluppo di nuove funzioni vengono rilasciate la 2.6.17.2, la 2.6.17.3 e altre release stabili del kernel, contenenti correzioni di bug e aggiornamenti di sicurezza.<br />
&Egrave; consigliabile che chi intenda usare l'ultima versione del kernel per lavoro si serva di quella stabile. Chi invece intende aiutare gli sviluppatori, può testare le caratteristiche della generazione successiva del kernel e darne una valutazione. Per quanto concerne gli scopi di questo capitolo, si suppone che venga utilizzata la versione stabile.<br />
<br />
=='''Dove trovare i sorgenti del kernel'''==<br />
Tutti i sorgenti del kernel Linux si possono trovare in ognuno dei siti kernel.org, una rete di mirror che permette a chiunque di trovare il server locale più vicino. Questo fa sì che i server principali possano rispondere più prontamente ai mirror e che gli utenti riescano a scaricare i file il più velocemente possibile.<br />
<br />
La pagina principale di http://www.kernel.org riporta tutte le versioni correnti del kernel per ogni differente ramo, come mostrato in [[:Immagine:kernel.org.png|figura 3-2]].<br />
<br />
[[Immagine:kernel.org.png|center|500px|thumb|Figura 3-2: Il sito ufficiale Kernel.org.]]<br />
<br />
Per scaricare l'ultima versione stabile del kernel è sufficiente fare clic sulla lettera F nella riga corrispondente: così facendo si scaricherà l'intero albero dei sorgenti. Altrimenti è possibile accedere alla sottocartella relativa ad ogni versione della serie 2.6 tramite la pagina http://www.kernel.org/pub/linux/kernel/v2.6/, mostrata in [[:Immagine:Kernel.org.v2.6.png|figura 3-3]].<br />
<br />
[[Immagine:Kernel.org.v2.6.png|center|500px|thumb|Figura 3-3: Directory dei sorgenti per il kernel 2.6]]<br />
<br />
&Egrave; anche possibile scaricare i sorgenti del kernel tramite riga di comando, usando il programma <tt>wget</tt> o <tt>curl</tt>, normalmente presenti in ogni distribuzione Linux.<br />
<br />
Per scaricare la versione 2.6.17.8 del kernel con <tt>wget</tt> il comando è:<br />
<br />
<pre>$ wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.17.8.tar.gz<br />
<br />
<br />
-> 'linux-2.6.17.8.tar.gz<br />
<br />
Resolving www.kernel.org... 204.152.191.5, 204.152.191.37<br />
<br />
Connecting to www.kernel.org|204.152.191.5|:80... connected.<br />
<br />
HTTP request sent, awaiting response... 200 OK<br />
<br />
Lenght: 51,707,742 (49M) [application/x-gzip]<br />
<br />
100%[-------------------------------------->] 51,707,742 35.25k/s<br />
<br />
ETA 00:00<br />
<br />
18:02:48 (47.12 kB/s) - 'linux-2.6.17.8.tar.gz' saved [51707742/51707742]</pre><br />
<br />
Per scaricarla con <tt>curl</tt>:<br />
<br />
<pre>$ curl http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.17.8.tar.gz \ -o linux-2.6.17.8.tar.gz</pre><br />
<br />
Il modo più semplice e veloce per scoprire quale sia l'ultima versione del kernel è usare le informazioni disponibili alla pagina http://www.kernel.org/kdist/finger_banner, come mostrato in [[:Immagine:Kernel.org.v2.6.png|figura 3-4]].<br />
<br />
[[Immagine:Kernel.org_finger_banner.png|center|500px|thumb|Figura 3-4: Ultima versione del kernel.]]<br />
<br />
=='''Cosa fare con i sorgenti'''==<br />
<br />
Una volta scaricati i sorgenti del kernel appropriati, dove è previsto che vengano messi? &Egrave; consigliabile creare una directory locale nella propria home chiamata linux per conservare tutti i file dei sorgenti del kernel:<br />
<br />
<pre>$ mkdir ~/linux</pre><br />
<br />
Spostate il codice sorgente nella directory linux:<br />
<br />
<pre>$ mv ~/linux-2.6.18.8.tar.gz ~/linux/</pre><br />
<br />
ed entrate nella directory linux:<br />
<br />
<pre>$ cd ~/linux<br />
$ ls<br />
linux-2.6.18.8.tar.gz</pre><br />
<br />
Adesso che il codice sorgente si trova nella directory giusta, decomprimetelo:<br />
<br />
<pre>$ tar -xzvf linux-2.6.18.8.tar.gz</pre><br />
<br />
Lo schermo si riempirà della lista dei file che verranno decompressi, e alla fine nella directory linux/ rimarrà:<br />
<br />
<pre>$ ls<br />
linux-2.6.18.8.tar.gz<br />
linux-2.6.18.8/</pre><br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/ch03.pdf ''Capitolo originale'']<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Requisiti_per_Compilare_ed_Utilizzare_il_Kernel&diff=14916LKN: Requisiti per Compilare ed Utilizzare il Kernel2007-08-22T18:09:18Z<p>TheNoise: aggiunto link pdf originale</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
Questo capitolo descrive i programmi necessari per configurare un kernel, compilarlo e fare il boot con successo. &Egrave; utile consultare il file ''Documentation/Changes'' per verificare esattamente quale sia la versione richiesta di ogni programma descritto. Qui vengono riportate le versioni dei programmi che funzionano con il kernel 2.6.18, su cui si basa la trattazione. Chi sta usando un kernel diverso verifichi di avere installate le versioni richieste, come riportato nel file sopra specificato, altrimenti qualcosa potrebbe non funzionare correttamente e potrebbe essere estremamente difficile capire cosa è andato nel modo sbagliato.<br />
<br />
<br />
=='''Strumenti per compilare il kernel'''==<br />
<br />
La maggior parte delle distribuzioni prevede la possibilità di installare una raccolta di pacchetti per lavorare con il kernel. Qualora la distribuzione offra questa possibilità è consigliabile sfruttarla, piuttosto che tentare di rintracciare ogni singola applicazione necessaria allo scopo.<br />
<br />
Per compilare un kernel servono solo tre pacchetti: un compilatore, un linker e un'utility ''make''. Questa sezione descrive il contenuto di ognuno di questi pacchetti.<br />
<br />
==='''Compilatore'''===<br />
<br />
Il kernel Linux è scritto in linguaggio C, con alcune piccole sezioni scritte in assembly. Per compilare un kernel è necessario utilizzare il compilatore per C gcc. La maggior parte delle distribuzioni comprendono un pacchetto di nome ''gcc'' che dovrebbe essere installato. Se volete scaricare il compilatore e compilarlo da soli, potete trovarlo all'indirizzo http://gcc.gnu.org .<br />
<br />
Per quanto concerne la release 2.6.18 del kernel, la versione 3.2 di ''gcc'' è la più vecchia tra quelle che possono compilare correttamente un kernel funzionante. Occorre fare attenzione che utilizzare l'ultima versione di ''gcc'' non è sempre una buona idea. Alcune delle versioni più recenti non compilano correttamente il kernel, quindi, a meno che non si voglia aiutare nel lavoro di debug del compilatore, ne è sconsigliato l'utilizzo.<br />
<br />
Per scoprire quale versione di ''gcc'' avete installata usate il seguente comando:<br />
<br />
<pre>$ gcc --version</pre><br />
<br />
==='''Linker'''===<br />
<br />
Il compilatore C, ''gcc'', non compie il lavoro di compilazione interamente da solo, ma ha bisogno di alcuni strumenti, chiamati ''binutils'', per effettuare il collegamento (linking) e l'assemblaggio dei file sorgente. Il pacchetto ''binutils'' contiene anche altre utili applicazioni che permettono di intervenire sui file oggetto (''object files'', prodotti dal compilatore ma non ancora collegati, dal linker, alle librerie e/o ad altri file oggetto necessari per l'esecuzione, N.d.T.) in molti modi, ad esempio per vedere il contenuto di una libreria.<br />
<br />
''binutils'' si trova di solito all'interno di un pacchetto di nome... ''binutils'' in ogni distribuzione. Se volete scaricarlo e installarlo da soli, potete trovarlo all'indirizzo http://www.gnu.org/software/binutils .<br />
<br />
La versione più vecchia di ''binutils'' che può essere utilizzata per collegare il kernel 2.6.18 è la 2.12. Per scoprire quale versione di ''binutils'' avete installata nel vostro sistema eseguite il comando seguente:<br />
<br />
<pre>$ ld -v</pre><br />
<br />
==='''Make'''===<br />
<br />
''make'' è uno strumento che cerca nei sorgenti del kernel quali file devono essere compilati e successivamente chiama il compilatore e gli altri strumenti necessari per costruire il kernel. Il kernel necessita della versione GNU di ''make'', che solitamente si trova in ogni distribuzione in un pacchetto chiamato ''make''.<br />
<br />
Se volete scaricare e installare ''make'' da soli potete trovarlo all'indirizzo:<br />
http://www.gnu.org/software/make .<br />
<br />
La release più vecchia di make che può essere utilizzata con un kernel 2.6.18 è la 3.79. Vi consiglio di installare la versione stabile più recente, perché le versioni più recenti lavorano più velocemente nel processare i file di compilazione.<br />
Per verificare quale versione di make avete installata usate il comando:<br />
<br />
<pre>$ make --version</pre><br />
<br />
=='''Strumenti per utilizzare il kernel'''==<br />
<br />
Anche se solitamente la versione del kernel che sta funzionando in un sistema non influisce su alcuna applicazione a livello utente, ci sono alcuni programmi per cui invece è importante. Questa sezione descrive alcuni strumenti che probabilmente sono già installati nel vostro sistema Linux: se aggiornate il kernel ad una versione diversa da quella inclusa nella vostra distribuzione, potrebbe essere necessario aggiornare anche alcuni di questi pacchetti, per permettere al sistema di funzionare correttamente.<br />
<br />
==='''util-linux'''===<br />
<br />
Il pacchetto ''util-linux'' è una raccolta di piccole utilità che assolvono ad un'ampia gamma di compiti; la maggior parte di queste utilità si occupa del montaggio e della creazione di partizioni su disco e della gestione dell'orologio di sistema.<br />
<br />
Se volete scaricare ed installare questo pacchetto da soli lo trovate al seguente indirizzo: http://www.kernel.org/pub/linux/utils/util-linux .<br />
<br />
La versione più vecchia di ''util-linux'' compatibile con il kernel 2.6.18 è la 2.10. &Egrave; consigliabile installare la più recente versione disponibile di questo pacchetto, perché le ultime versioni supportano le nuove caratteristiche implementate nel kernel. I ''bind mounts'' sono un esempio di un'opzione inclusa nei kernel più nuovi, che necessita della versione più recente di ''util-linux'' per poter funzionare correttamente.<br />
<br />
Per scoprire quale versione di ''util-linux'' avete installata nel vostro sistema usate il seguente comando:<br />
<br />
<pre>$ fdformat --version</pre><br />
<br />
==='''module-init-tools'''===<br />
<br />
Il pacchetto ''module-init-tools'' è necessario per poter utilizzare i moduli del kernel. Un ''modulo del kernel'' è un pezzetto di codice caricabile che può essere aggiunto o rimosso dal kernel anche mentre questo sta girando. &Egrave; comodo compilare i driver dei dispositivi come moduli per poter caricare solo quelli relativi allo hardware presente nel sistema. Tutte le distribuzioni di Linux usano i moduli per poter caricare solo i driver necessari al sistema in base allo hardware presente, invece di essere costretti a costruire tutti i possibili driver e opzioni del kernel in un unico blocco. L'uso dei moduli permette di risparmiare memoria, caricando solo il codice necessario per controllare correttamente la macchina.<br />
<br />
Il processo di caricamento dei moduli ha subito una revisione radicale nella versione 2.6 del kernel. Il linker per i moduli (il codice che si occupa di risolvere tutti i simboli e capire come associare i pezzi di codice in memoria) adesso è compilato all'interno del kernel, e questo permette di avere degli strumenti a livello userspace molto leggeri. Le distribuzioni più vecchie hanno un pacchetto che si chiama ''modutils'' che non funziona correttamente con il kernel 2.6. Il pacchetto ''module-init-tools'' è quello di cui avete bisogno per lavorare correttamente con i moduli di kernel 2.6.<br />
<br />
Chi volesse scaricare e installare da solo questo pacchetto, può trovarlo all'indirizzo:<br />
http://www.kernel.org/pub/linux/utils/kernel/module-init-tools .<br />
<br />
La versione più vecchia di ''module-init-tools'' compatibile con il kernel 2.6.18 è la 0.9.10. Si raccomanda di installare l'ultima release disponibile di ''module-init-tools'', in quanto permette di utilizzare alcune caratteristiche nuove del kernel. Ad esempio, la possibilità di creare una blacklist dei moduli che non si vuole vengano automaticamente caricati da udev è una delle opzioni che sono presenti solo nelle versioni più recenti di ''module-init-tools''.<br />
Per scoprire quale versione avete installata nel vostro sistema usate il comando:<br />
<br />
<pre>$ depmod -V</pre><br />
<br />
=='''Strumenti specifici per i filesystem'''==<br />
<br />
Per creare, formattare e riparare le partizioni dei dischi è necessario un ampio spettro di strumenti specifici per i vari filesystem. Il pacchetto ''util-linux'' ne contiene alcuni, ma alcuni dei più popolari filesystem hanno dei pacchetti separati che contengono le utilità necessarie.<br />
<br />
==='''ext2/ext3/ext4'''===<br />
<br />
I filesystem ''ext3'' e quello in fase di sviluppo ''ext4'' sono evoluzioni dell' ''ext2'' e possono essere gestiti con gli stessi strumenti; la versione più recente di qualunque applicazione basata su ''ext2'' può essere impiegata anche sugli altri due filesystem.<br />
<br />
Per utilizzare questi filesystem dovete avere il pacchetto ''e2fsprogs''; l'indirizzo a cui trovarlo per scaricarlo e installarlo da soli è: http://e2fsprogs.sourceforge.net.<br />
<br />
La versione più vecchia di ''e2fsprogs'' funzionante con il kernel 2.6.18 è la 1.29; è altamente consigliato utilizzare la release più recente per sfruttare al meglio le nuove caratteristiche dei filesystem ''ext3'' ed ''ext4''.<br />
<br />
Per scoprire quale versione di ''e2fsprogs'' è installata nel vostro sistema usate il comando:<br />
<br />
<pre>$ tune2fs</pre><br />
<br />
==='''JFS'''===<br />
<br />
Per usare il filesystem JFS di IBM è necessario avere il pacchetto ''jfsutils''; se volete scaricarlo e installarlo da soli lo trovate all'indirizzo: http://jfs.sourceforge.net.<br />
<br />
La versione più vecchia di ''jfsutils'' utilizzabile correttamente con il kernel 2.6.18 è la 1.1.3; per verificare quale versione avete installata lanciate il comando:<br />
<br />
<pre>$ fsck.jfs -V</pre><br />
<br />
==='''ReiserFS'''===<br />
<br />
Per usare il filesystem ReiserFS è necessario il pacchetto ''reiserfsprogs''. Per scaricarlo e installarlo da soli l'indirizzo è: http://www.nemesys.com/download.html.<br />
<br />
La versione più vecchia di ''reiserfsprogs'' funzionante con il kernel 2.6.18 è la 3.6.3; il comando per controllare quale versione è installata nel sistema è:<br />
<br />
<pre>$ reiserfsck -V</pre><br />
<br />
==='''XFS'''===<br />
<br />
Per usare il filesystem XFS di SGI è necessario avere il pacchetto ''xfsprogs''; è possibile scaricare il pacchetto da installare all'indirizzo: http://oss.sgi.com/project/xfs.<br />
<br />
La release più vecchia di ''xfsprogs'' compatibile con il kernel 2.6.18 è la 2.6.0; per verificare quale versione è installata nel sistema si utilizza:<br />
<br />
<pre>$ xfs_db -V</pre><br />
<br />
==='''Quota'''===<br />
<br />
Per utilizzare le quote come funzionalità del kernel è necessario avere installato il pacchetto ''quota-tools'';* {{Box|To do|nota a piè di pagina: scoprire come si fa}} Questo pacchetto contiene applicazioni che permettono di fissare le quote di filesystem a disposizione di ogni utente, forniscono statistiche sull'uso delle quote dei vari utenti e diramano degli avvertimenti quando questi stanno per esaurire la loro quota di filesystem.<br />
<br />
Per scaricare e installare questo pacchetto da soli l'indirizzo è: http://sourceforge.net/projects/quota. La versione più vecchia utilizzabile con il kernel 2.6.18 è la 3.0.9; è possibile visualizzare la versione installata con il comando:<br />
<br />
<pre>$ quota -V</pre><br />
<br />
==='''NFS'''===<br />
<br />
Per utilizzare correttamente il filesystem NFS è necessario il pacchetto ''nfs-utils''. ** {{Box|To do|nota a piè di pagina: scoprire come si fa}} Questo pacchetto contiene dei programmi con cui è possibile montare delle partizioni NFS come client e far girare un server NFS.<br />
<br />
L'indirizzo da cui prelevare questo pacchetto per installarlo da soli è: http://nfs.sf.net.<br />
<br />
La versione più vecchia funzionante con il kernel 2.6.18 è la 1.0.5; il comando per determinare la versione installata è:<br />
<br />
<pre>$ showmount --version</pre><br />
<br />
=='''Altri strumenti'''==<br />
<br />
Ci sono pochi altri programmi che sono strettamente legati alla versione del kernel. Di solito questi programmi non sono necessari per far funzionare il kernel, ma rendono possibile l'accesso a tipi di hardware e di funzioni differenti.<br />
<br />
==='''udev'''===<br />
<br />
''udev'' è un programma che permette a Linux di fornire uno schema persistemte di attribuzione dei nomi dei device nella directory ''/dev''. Inoltre fornisce una ''/dev'' dinamica, molto simile a quella fornita dal più vecchio (ed ora non più utilizzato) filesystem ''devfs''. Quasi tutte le distribuzioni Linux usano ''udev'' per gestire la directory ''/dev'', per cui risulta necessario per eseguire correttamente il boot del sistema.<br />
<br />
Sfortunatamente ''udev'' si appoggia alla struttura della directory ''/sys'', che è nota per cambiare continuamente con le release del kernel. Alcuni di questi cambiamenti in passato sono stati responsabili del malfunzionamento di ''udev'', cosicché il sistema non era più in grado di fare il boot correttamente. Se ''udev'' non funziona correttamente nonostante abbiate l'ultima versione raccomandata per il vostro kernel, contattate gli sviluppatori tramite la mailing list [mailto:linux-hotplug-devel@list.sourceforge.net].<br />
<br />
&Egrave; fortemente consigliato utilizzare l'ultima release di ''udev'' fornita con la vostra distribuzione, dato che è profondamente legata al processo di boot specifico della distribuzione stessa. In ogni caso, chi volesse aggiornare ''udev'' per conto proprio può trovarlo all'indirizzo: http:www.kernel.org/pub/linux/utils/kernel/hotplug/udev.html.<br />
<br />
La versione più vecchia di ''udev'' funzionante con il kernel 2.6.18 è la 0.81; è consigliabile usare la versione più recente, in quanto funziona meglio con i nuovi kernel, a causa del modo in cui ''udev'' e il kernel comunicano tra di loro.<br />
<br />
Per conoscere quale versione di udev è installata nel sistema il comando è:<br />
<br />
<pre>$ udevinfo -V</pre><br />
<br />
==='''Strumenti di analisi dei processi'''===<br />
<br />
Il pacchetto ''procps'' contiene i programmi di uso comune ''ps'' e ''top'', come anche molti altri strumenti per gestire e tenere sotto controllo i processi in esecuzione nel sistema.<br />
Se preferite scaricare ed installare da soli questo pacchetto potete trovarlo all'indirizzo<br />
http://procps.sourceforge.net.<br />
La versione 3.2.0 è la più vecchia compatibile con il kernel 2.6.18; per determinare quale versione è installata si usa il comando:<br />
<br />
<pre>$ ps --version</pre><br />
<br />
==='''Strumenti per periferiche PCMCIA'''===<br />
<br />
Per poter utilizzare correttamente le periferiche PCMCIA è necessario un programma a livello utente che permetta di configurarle. Per i kernel più vecchi questo programma si chiamava ''pcmcia-cs'', ma è stato sostituito con un sistema più semplice chiamato ''pcmciautils''. Se volete utilizzare periferiche PCMCIA dovete avere installato questo pacchetto.<br />
<br />
Se preferite scaricare ed installare da soli questo pacchetto potete trovarlo all'indirizzo ftp://ftp.kernel.org/pub/utils/kernel/pcmcia.<br />
<br />
La versione più vecchia di ''pcmciautils'' funzionante con il kernel 2.6.18 è la 004, ma è consigliabile installare la versione più recente, per poter sfruttare tutte le nuove funzioni del sottosistema PCMCIA, come ad esempio la possibilità di caricare automaticamente i driver quando viene rilevata una nuova periferica. Il comando per scoprire quale versione di pcmciautils è installata è:<br />
<br />
<pre>$ pccardctl -V</pre><br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/ch02.pdf ''Capitolo originale'']<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Introduzione&diff=14915LKN: Introduzione2007-08-22T18:08:04Z<p>TheNoise: aggiunto link pdf originale</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
Nonostante la sua grande base di codice (oltre sette milioni di linee di codice), il kernel Linux è il sistema operativo più flessibile che sia mai stato creato.<br />
Può essere messo a punto per una grande varietà di sistemi differenti e funzionare su qualunque cosa, da un modello di elicottero radio-comandato, a un telefono cellulare, alla maggior parte dei più grandi supercalcolatori nel mondo.<br />
Adattando il kernel a un ambiente specifico, è possibile creare qualcosa che sia contemporaneamente più piccolo e più veloce del kernel fornito dalla gran parte delle distribuzioni di Linux. Questo libro entrerà nel come costruire e installare un kernel personalizzato, e fornirà qualche spunto su come abilitare opzioni specifiche che probabilmente vorrete usare per specifiche situazioni.<br />
<br />
Nessuna distribuzione di Linux fornisce esattamente il kernel che gran parte dei suoi utenti vuole. Le distribuzioni moderne sono diventate molto accomodanti, compilando il supporto per ogni periferica conosciuta, per l'audio, e anche per il risparmio energetico.<br />
Ma probabilmente ognuno di voi ha necessità differenti dalla maggioranza degli utenti (e ogni distribuzione deve cercare ad andare incontro alle necessità della maggioranza).<br />
Voi potreste semplicemente avere un hardware differente.<br />
E quando esce un nuovo kernel potreste voler iniziare ad usarlo senza aspettare che una distribuzione venga costruita attorno ad esso.<br />
<br />
Per un certo numero di ragioni, durante il vostro cammino con Linux, qualche volta potreste voler compilare un kernel, o mettere a punto i parametri di quello che state utilizzando.<br />
Questo libro vi fornisce le informazioni necessarie per comprendere il kernel dal punto di vista dell'utente, e per effettuare i cambiamenti più comuni.<br />
<br />
Ci sono anche delle buone ragioni per rimuovere alcune caratteristiche da un kernel, in particolare se lo fate funzionare in un sistema embedded o in uno con uno ''small form factor'' (piccolo fattore di forma, cioè dalle risorse limitate, N.d.T.)<br />
<br />
Nel mettere a punto, &egrave; utile comprendere le motivazioni intime del comportamento del kernel.<br />
Queste sono al di là dello scopo di questo libro, eccetto brevi sommari che appaiono con certe opzioni.<br />
L'appendice B include riferimenti ad altri libri e a materiale che può fornirvi maggiori basi.<br />
<br />
<br />
'''Usare questo libro'''<br />
<br />
<br />
[[Image:Cesoia.png|left]] Non configurate n&eacute; compilate il vostro kernel con i permessi di superutente!<br />
<br />
<br />
Questo avvertimento è la cosa più importante da ricordare percorrendo i passaggi di questo libro. Ogni cosa in questo libro - scaricare il codice sorgente del kernel, decomprimerlo, configurare il kernel e compilarlo - dovrebbe essere fatta come utente comune del sistema.<br />
Solo i due o tre comandi necessari per installare un nuovo kernel dovrebbero essere impartiti come superutente (''root'').<br />
<br />
Ci sono stati bug nel processo di costruzione del kernel, nel passato, che causavano la cancellazione di qualche file speciale nella directory ''/dev'' se l'utente aveva i permessi da superutente durante la compilazione del kernel Linux. Ci sono anche problemi che possono facilmente insorgere decomprimendo il kernel Linux con diritti di superutente, poiché qualche file nel pacchetto dei sorgenti del kernel non finirà per avere i permessi adeguati e causerà errori di compilazione più avanti.<br />
<br />
Il codice sorgente del kernel, inoltre, non dovrebbe essere mai posto nella directory ''/usr/src/linux/'', poiché quella è la posizione del kernel con cui sono state compilate le librerie di sistema, non del vostro kernel personalizzato. Non effettuate neppure alcun tipo di sviluppo del kernel nella directory ''/usr/src/'', ma fatelo solo nella vostra directory da utente locale, dove non può accadere nulla di male al sistema.<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/ch01.pdf ''Capitolo originale'']<br />
<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Ricette_per_Configurare_il_Kernel&diff=14914LKN: Ricette per Configurare il Kernel2007-08-22T17:45:44Z<p>TheNoise: pre chiusi male</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
__TOC__<br />
<br />
Il [[LKN:_Personalizzare_un_Kernel|capitolo precedente]] ci ha insegnato i meccanismi per la riconfigurazione del kernel; in questo capitolo arriva la parte interessante, in cui si possono trovare tutte le modifiche più comuni che gli utenti hanno bisogno di apportare ai loro kernel, con le istruzioni specifiche per effettuarle.<br />
<br />
<br />
== '''Dischi''' ==<br />
<br />
Il kernel Linux supporta una grande varietà di differenti tipi di disco. Questa sezione mostra come configurare il kernel in modo tale che supporti la maggior parte dei modelli più comuni di controller di disco.<br />
<br />
'''Periferiche USB'''<br />
<br />
Per utilizzare una periferica di archiviazione USB (come quelle chiamate comunemente memorie "flash" USB, oppure dischi esterni USB) il supporto USB deve prima funzionare correttamente. Fare riferimento alla ricetta nella sezione chiamata [[USB]] per sapere come fare.<br />
<br />
Una periferica di archiviazione USB può essere identificata utilizzando il programma ''lsusb''. Se la sequenza di comandi che segue produce i risultati mostrati, nel sistema è presente una periferica di archiviazione USB:<br />
<br />
<pre><br />
$ /usr/sbin/lsusb -v | grep Storage<br />
bInterfaceClass 8 Mass Storage<br />
</pre><br />
<br />
Abilitatelo nel modo seguente.<br />
1. A USB Storage device is in reality a USB SCSI device that talks over a USB<br />
connection. Because of this, the SCSI subsystem must be enabled:<br />
<br />
<pre><br />
Device Drivers<br />
SCSI Device Support<br />
[*] SCSI Device Support<br />
</pre><br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14890LKN: Personalizzare un Kernel2007-08-14T15:30:26Z<p>TheNoise: /* Dispositivi PCI */ Tradotta qualche pagina</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
Uno dei punti più delicati e difficili nella creazione della propria versione del kernel Linux è quello di determinare esattamente quali driver e quali opzioni di configurazione sono richiesti per il corretto funzionamento dalla macchina su cui viene installato.<br />
Questo capitolo guiderà il lettore attraverso questo processo di selezione e scelta dei driver corretti.<br />
<br />
==Usare un kernel di una distribuzione==<br />
<br />
Uno dei metodi più semplici, per determinare quali moduli siano necessari, è quello di partire dalla configurazione che viene installata dal pacchetto del kernel della distribuzione che si sta usando. È infatti molto più semplice determinare di quali driver si ha bisogno basandosi su quelli installati in un sistema in funzione, in cui i driver corretti sono già associati all'hardware in utilizzo.<br />
<br />
Se invece si sta personalizzando un kernel per una macchina sulla quale non è installata una distribuzione Linux, allora conviene partire dalla versione LiveCD di una distribuzione. Questo consente all'utente di far partire Linux sulla macchina in oggetto e di determinare in maniera semplice le opzioni di configurazione del kernel e che consentono il funzionamento ottimale della macchina stessa.<br />
<br />
===Dove si trova la configurazione del kernel?===<br />
<br />
Quasi tutte le distribuzioni forniscono il file di configurazione nello stesso pacchetto del kernel. Si consiglia di leggere la documentazione relativa alla distribuzione stessa per sapere dove viene installato il file di configurazione. Solitamente si trova da qualche parte in una sotto-directory di <tt>/usr/src/linux/</tt>.<br />
<br />
{{Box|Nota per Debian (NdT)|In debian il file di configurazione di ogni kernel installato si trova in <tt>/boot/</tt> ed ha come nome <tt>config-''versione''</tt>.}}<br />
<br />
Se avete difficoltà a trovare la configurazione del kernel, allora guardate nel kernel stesso. I kernel di molte distribuzioni sono compilati in modo da includere il file di configurazione dentro il filesystem <tt>/proc</tt>. Per verificare se questo è il vostro caso, digitate:<br />
<br />
<pre><br />
$ ls /proc/config.gz<br />
/proc/config.gz<br />
</pre><br />
<br />
Se il file ''/proc/config.gz'' è presente, allora copiatelo nella directory del sorgente kernel ed estraetelo:<br />
<br />
<pre><br />
$ cp /proc/config.gz -/linux/<br />
$ cd -/linux<br />
$ gzip -dv config.gz<br />
config.gz: 74.9% - - replaced with config<br />
</pre><br />
<br />
Copiate questo file di configurazione nella vostra directory del kernel e rinominatelo in ''.config''.<br />
Ora potrete utilizzare questo file come base di partenza nella personalizzazione della configurazione del kernel così come descritto nel [[LKN:_Configurare_e_Compilare|Capitolo 4]].<br />
<br />
Usando questo file di configurazione si dovrebbe ottenere sempre un file immagine del kernel (un ''kernel ricompilato'', NdT) funzionante sulla propria macchina.<br />
Lo svantaggio di questa immagine è che verranno compilati quasi tutti i moduli e driver presenti nei sorgenti del kernel. Ciò non è quasi mai necessario per una singola macchina, quindi sarebbe meglio disabilitare tutti i driver e le opzioni non necessarie. Si raccomanda di disabilitare solo quelle opzioni che si è sicuri non serviranno, poiché ci sono parti del sistema che richiedono l'abilitazione di certe opzioni.<br />
<br />
===Determinare quali moduli siano necessari===<br />
Usando il file di configurazione fornito dalla vostra distribuzione il tempo richiesto per la compilazione del kernel è molto lungo poiché tutti i possibili driver vengono abilitati. Si dovrebbe cercare di abilitare solo i driver per l'hardware presente nel sistema, così da ridurre i tempi di compilazione del kernel. Inoltre, compilando ''staticamente'' (invece che come moduli) alcuni o tutti i driver necessari, si riduce la memoria utilizzata ed in alcune architetture si velocizza il funzionamento del sistema. Per escludere i driver dal kernel è necessario però determinare quali moduli sono indispensabili per il funzionamento dell'hardware installato. Attraverso l'utilizzo di due esempi, cercheremo di spiegare come determinare quali driver siano indispensabili al controllo dell'hardware.<br />
<br />
Le informazioni che mettono in relazione i dispositivi ai driver presenti nel kernel sono conservate in varie parti del sistema. Uno dei posti più importanti dove sono salvate queste informazioni è il filesystem virtuale ''sysfs''. All'avvio di Linux, ''sysfs'', dovrebbe essere montato dagli script di inizializzazione della vostra distribuzione nella directory ''/sys''. ''sysfs'' consente di dare un'occhiata a come le varie parti del kernel sono legate l'una a l'altra, questo lo si deduce grazie ai vari collegamenti simbolici (''symlink'' NdT) che puntano all'interno dell'intero filesystem.<br />
<br />
In tutti gli esempi di seguito, saranno riportati i veri percorsi (''path'' NdT) di ''sysfs'' corrispondenti ad hardware specifico. La vostra macchina sarà certamente diversa, ma la posizione relativa delle informazioni sarà la stessa. Non ci si deve allarmare se i nomi di file nel ''sysfs'' non sono i medesimi, ciò è normale e prevedibile.<br />
<br />
Inoltre, la struttura interna del file di sistema ''sysfs'' subisce modifiche, a causa sia della riorganizzazione dei driver sia del fatto che gli sviluppatori del kernel trovano nuovi modi per meglio presentare in ''user space'' le strutture interne del kernel. A causa di questo, col tempo, alcuni dei ''symlink'', precedentemente menzionati in questo capitolo, possono non essere presenti. Tuttavia, le informazioni sono ancora tutte presenti, al massimo sono state un po' spostate.<br />
<br />
====Esempio: Come determinare il driver di rete====<br />
<br />
Uno degli elementi più comuni ed importanti in un sistema è la scheda di rete. È essenziale capire quale driver la controlla ed attivarlo nella configurazione in maniera da consentire un corretto funzionamento delle connessioni di rete.<br />
<br />
Primo: partendo dalle connessioni di rete si risale al device PCI <br />
<pre>$ ls /sys/class/net/<br />
eth0 eth1 eth2 lo</pre><br />
<br />
La directory ''lo'' rappresenta il dispositivo di rete loopback, ed non è dipendente da nessun dispositivo di rete realmente installato. Invece si dovrebbe riservare particolare attenzione alle directory ''eth0'', ''eth1'' e ''eth2'', dato che si riferiscono a dispositivi realmente esistenti<br />
<br />
Per determinare di quali dispositivi ci si deve occupare, si utilizza il comando ''ifconfig'':<br />
<br />
<pre>$ /sbin/ifconfig -a<br />
eth0 Link encap:Ethernet HWaddr 00:12:3F:65:7D:C2<br />
inet addr:192.168.0.13 Bcast:192.168.0.255 Mask:255.255.255.0<br />
UP BROADCAST NOTRAILERS RUNNING MULTICAST MTU:1500 Metric:1<br />
RX packets:2720792 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:1815488 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:100<br />
RX bytes:3103826486 (2960.0 Mb) TX bytes:371424066 (354.2 Mb)<br />
Base address:0xdcc0 Memory:dfee0000-dff00000<br />
eth1 Link encap:UNSPEC HWaddr 80-65-00-12-7D-C2-3F-00-00-00-00-00-00-00-00<br />
BROADCAST MULTICAST MTU:1500 Metric:1<br />
RX packets:0 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)<br />
eth2 Link encap:UNSPEC HWaddr 00-02-3C-04-11-09-D2-BA-00-00-00-00-00-00-00<br />
BROADCAST MULTICAST MTU:1500 Metric:1<br />
RX packets:0 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)<br />
lo Link encap:Local Lookback<br />
inet addr:127.0.0.1 Mask:255.0.0.0<br />
UP LOOPBACK RUNNING MTU:16436 Metric:1<br />
RX packets:60 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:60 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:13409 (13.0 Kb) TX bytes:13409 (13.0 Kb)</pre><br />
<br />
Da questo listato si può riconoscere nel dispositivo di rete <tt>eth0</tt>, quello attivo e funzionante, infatti nelle righe;<br />
<br />
<pre>eth0 Link encap:Ethernet HWaddr 00:12:3F:65:7D:C2<br />
inet addr:192.168.0.13 Bcast:192.168.0.255 Mask:255.255.255.0</pre><br />
<br />
Questo risultato dimostra che il dispositivo Ethernet si vede assegnato un indirizzo IP valido (<tt>inet</tt>).<br />
<br />
Ora, dopo che abbiamo individuato il dispositivo <tt>eth0</tt> e ci siamo accertati di volerlo abilitare nel nostro nuovo kernel, dobbiamo individuare quale driver lo controlla. Ciò si realizza con una semplice procedura, che è quella si seguire i link nel filesystem sysfs, basta digitare un comando di una sola riga:<br />
<br />
<pre>$ basename `readlink /sys/class/net/eth0/device/driver/module`<br />
e1000</pre><br />
<br />
Il risultato mostra che il modulo <tt>e1000</tt> controlla il dispositivo di rete <tt>eth0</tt>. Il comando ''basename'' racchiude in un'unica linea di comando i seguenti passaggi:<br />
<br />
: 1. Individua il symlink ''/sys/class/net/eth0/device'' contenuto all'interno della directory ''/sys/device/'', la quale contiene le informazioni relative al dispositivo che controlla ''eth0''. Fate attenzione al fatto che nelle nuove versioni del kernel la directory ''/sys/class/net/eth0'' potrebbe essere un symlink. <br />
<br />
: 2. All'interno della directory che descrive il dispositivo in sysfs, c'è un symlink che punta al driver relativo a questo dispositivo. Questo symlink è nominato ''driver'', pertanto si segue questo collegamento.<br />
<br />
: 3. All'interno della directory che descrive il driver in sysfs, c'è un symlink che punta al modulo che si trova all'interno del driver in oggetto. Questo symlink è chiamato <tt>module</tt>. Noi cerchiamo l'oggetto a cui punta questo symlink, per ottenerlo ci serviamo del comando ''readlink'', il quale produce un risultato simile a questo:<br />
:<pre>$ readlink /sys/class/net/eth0/device/driver/module </pre><br />
:<pre> ../../../../module/e1000</pre><br />
<br />
: 4. Dato che a noi interessa solo il nome del modulo e ci disinteressiamo del resto del risultato ottenuto con il comando ''readlink'', tenendo solo la parte più a destra del risultato. Questo è appunto ciò che il comando ''basename'' realizza. Applicandolo direttamente all'intero percorso, questo comando ci ritorna quanto segue: <br />
: <pre>$ basename ../../../../module/e1000</pre><br />
: <pre>e1000</pre><br />
<br />
Così abbiamo inserito il lungo risultato del symlink, ottenuto da ''readlink'', quale parametro nel programma ''basemane'', permettendo così l'intero processo di essere realizzato in una sola riga.<br />
<br />
Ora che abbiamo identificato il nome del modulo, si dovrebbe trovare l'opzione della configurazione del kernel che lo controlla. Si può cercare nei vari menu di configurazione dei dispositivi di rete oppure cercare nel codice sorgente del kernel stesso per essere sicuri di avere l'opzione giusta.<br />
<br />
<pre><br />
$ cd ~/linux/linux-2.6.17.8<br />
$ find -type f -name Makefile | xargs grep e1000<br />
./drivers/net/Makefile:obj-$(CONFIG_E1000) += e1000/<br />
./drivers/net/e1000/Makefile:obj-$(CONFIG_E1000) += e1000.o<br />
./drivers/net/e1000/Makefile:e1000-objs := e1000_main.o e1000_hw.o e1000_ethtool.o e1000_param.o<br />
</pre><br />
<br />
Si precisa che "e1000'', usato in questo esempio, deve essere sostituito con il nome del modulo che state analizzando.<br />
<br />
La cosa che ci interessa nel risultato del precedente comando ''find'' sono le righe dove compaia il termine <tt>'''CONFIG_'''</tt>. Questa è l'opzione di configurazione che il kernel deve aver attivato per poter compilare il modulo. Nell'esempio precedente l'opzione di configurazione che c'interessa è pertanto <tt>CONFIG_E1000</tt>.<br />
<br />
Adesso si dispone dell'informazione necessaria per poter configurare il kernel. Si esegue lo strumento menu di configurazione:<br />
<br />
<pre>$ make menuconfig</pre><br />
<br />
Dopodiché si prema il tasto / (slash) (che ha il compito di far partire una ricerca), e si digita l'opzione di configurazione, senza la parte di testo <tt>CONFIG_</tt>. Questo processo è mostrato nella [[:Immagine:Config_search.png|figura 7-1]].<br />
<br />
[[Immagine:Config_search.png|center|frame|''Figura 7-1. Ricerca in menuconfig.'']]<br />
<br />
Il sistema di configurazione del kernel vi dirà ora esattamente dove selezionare l'opzione per abilitare questo modulo. Vedi [[:Immagine:Config_search_found.png|figura 7-2]].<br />
<br />
[[Immagine:Config_search_found.png|center|frame|''Figura 7-2. Risultato della ricerca in menuconfig.'']]<br />
<br />
Il primo elemento nella schermata mostra l'opzione che stavate cercando. Le informazioni mostrate dalla schermata vi dicono che, per attivare il modulo <tt>E1000</tt> nel kernel, la seguente opzione di configurazione deve essere abilitata:<br />
<br />
Device Drivers<br />
Network device support<br />
[*] Network device support<br />
Ethernet (1000 Mbit)<br />
[*] Intel(R) PRO/1000 Gigabit Ethernet support<br />
<br />
Questo modo di procedere funziona per ogni tipo di dispositivo attivo nel kernel.<br />
<br />
====Esempio: Un dispositivo USB====<br />
<br />
Come secondo esempio, esaminiamo ora un convertitore USB-seriale che è presente nel nostro sistema preso ad esempio. Attualmente il convertitore è collegato alla porta ''/dev/ttyUSB0'', pertanto si deve prendere in esame la sezione tty del ''sysfs''.<br />
<pre>$ ls /sys/class/tty/ | grep USB<br />
ttyUSB0</pre><br />
Potete ora eseguire una ricerca di questo dispositivo nel ''sysfs'' allo scopo di trovare il modulo che lo gestisce, utilizzando la stessa procedura mostrata nella sezione precedente:<br />
<br />
<pre>$ basename `readlink /sys/class/tty/ttyUSB0/device/driver/module`<br />
pl2303</pre><br />
Dopodiché, per poter individuare l'opzione di configurazione che si deve abilitare, si cerca nell'albero del codice sorgente del kernel:<br />
<pre>$ cd ~/linux/linux-2.6.17.8<br />
$ find -type f -name Makefile | xargs grep pl2303<br />
./drivers/usb/serial/Makefile:obj-$(CONFIG_USB_SERIAL_PL2303) += pl2303.o</pre><br />
<br />
Si utilizzi lo strumento di configurazione del kernel, come indicato in [[:Immagine:Config_search_pl2303.png|figura 7-3]], per trovare l'opzione adeguata da abilitare relativa al settaggio dell'opzione CONFIG_USB_SERIAL_PL2303.<br />
<br />
[[Immagine:Config_search_pl2303.png|center|frame|''Figura 7-3. Ricerca di USB_SERIAL_PL2303''.]]<br />
<br />
Nel nostro caso il risultato è mostrato nella [[:Immagine:Config_search_pl2303_found.png|figura 7-4]].<br />
<br />
[[Immagine:Config_search_pl2303_found.png|center|frame|''Figura 7-4. Risultato della ricerca di USB_SERIAL_PL2303'']]<br />
<br />
Ciò mostra esattamente dove trovare l'opzione <tt>USB Profilic 2303 Single Port Serial Driver</tt> che è necessaria alla corretta gestione di questo dispositivo.<br />
<br />
====Riassunto: Alla scoperta del dispositivo====<br />
<br />
Riassumendo, ecco i vari passaggi che servono per identificare il driver funzionante di un dispositivo ad esso collegato:<br />
: 1. Trovate la corretta classe di dispositivi in ''sysfs'' relativa al dispositivo che ci interessa. I dispositivi di rete sono elencati in ''/sys/class/net'', mentre i dispositivi tty sono elencati in ''/sys/class/tty''. Gli altri vari dispositivi si trovano in altre sotto-directory di ''/sys/class'', a seconda del tipo.<br />
: 2. Ricercate nell'albero di ''sysfs'' il nome del modulo che controlla il dispositivo in oggetto. Lo si trova in ''/sys/class/class_name/device_name/device/driver/module'', la ricerca è agevolata se si utilizzano i comandi ''readlink'' e ''basename''.<br />
:<pre>$ basename `readlink /sys/class/class_name/device_name/device/driver/module`</pre><br />
: 3. Ricercate nei file Makefile con ''find'' e ''grep'' le opzioni <tt>CONFIG_</tt> che abilitano il modulo<br />
:<pre>$ find -type f -name Makefile | xargs grep ''module_name''</pre><br />
: 4. Ricercate l'opzione trovata nel sistema di configurazione del kernel, dopodiché andate dove indicato dal menu per attivare il driver in oggetto.<br />
<br />
====Lasciamo che il kernel ci dica ciò di cui abbiamo bisogno====<br />
Dopo esserci infilati nel ''sysfs'' e aver seguito i sui symlinks per ricercare passo passo i nomi dei moduli, presentiamo un semplice script che farà per noi tutto il lavoro in un modo leggermente diverso:<br />
<br />
<pre><br />
#!/bin/bash<br />
#<br />
# find_all_modules.sh<br />
#<br />
for i in `find /sys/ -name modalias -exec cat {} \;`; do<br />
/sbin/modprobe --config /dev/null --show-depends $1 ;<br />
done | rev | cut -f i -d '/' | rev | sort -u<br />
</pre><br />
<br />
Si può scaricare un file d'esempio, contenente questo script, dal sito web del libro, riportato nella sezione ''Come contattarci'' che si trova nella prefazione.<br />
<br />
Questo script cerca nel ''sysfs'' tutti file chiamati ''modalias''. Il file ''modalias'' contiene gli alias dei moduli e comunica al comando ''modprobe'' quali moduli debbano essere caricati per ogni dispositivo. L'alias del modulo è composto da una combinazione di: produttore del dispositivo, ID, tipo di classe ed altri identificativi univoci per il tipo di dispositivo in questione. Tutti i moduli del driver del kernel hanno una lista interna dei dispositivi che supportano, che è generata automaticamente dalla lista dei dispositivi che il driver comunica al kernel di poter supportare. Il comando ''modprobe'' ricerca tutti i dispositivi nella lista di tutti i driver e cerca di trovare una corrispondenza confrontando l'alias. Se trova una corrispondenza, allora provvede al caricamento del modulo (questa procedura è la stessa seguita dal caricamento automatico dei driver in Linux).<br />
<br />
Lo script prevede l'arresto del programma ''modprobe'' prima di caricare il modulo, e visualizza a schermo solo le azioni che eseguirebbe. Questo ci d&agrave; una lista di tutti i moduli che sono necessari al controllo di tutti i dispositivi del sistema. Eseguendo una piccola pulizia della lista, ordinandola e selezionando i campi adeguati, <br />
otteniamo il seguente risultato:<br />
<br />
<pre><br />
$ find_all_modules.sh<br />
8139cp.ko<br />
8139too.koo<br />
ehci-hcd.ko<br />
fimware_vlass.ko<br />
i2c-i801.ko<br />
ieee80211.ko<br />
ieee80211_crypt.ko<br />
ipw2200.ko<br />
mii.ko<br />
mmc_core.ko<br />
pcmcia_core.ko<br />
rsrc_nonstatic.ko<br />
sdhci.ko<br />
snd-hda-codec.ko<br />
snd-hda-intel.ko<br />
snd-page-alloc.ko<br />
snd-pmc.ko<br />
snd-timer.ko<br />
snd.ko<br />
soundcore.ko<br />
uhci-hcd.ko<br />
usbcore.ko<br />
yenta_socket.ko<br />
</pre><br />
<br />
Questa è la lista di tutti i moduli che sono necessari alla gestione dell'hardware della macchina.<br />
<br />
Lo script mostrerà probabilmente alcuni messaggi di errore che possono essere del tipo:<br />
<br />
<pre>FATAL: Module pci:v00008086d00002592sv000010CFsd000012E0bc03sc00i00 not found.<br />
FATAL: Module serio:ty01pr00id00ex00 not found.</pre><br />
<br />
Questo ci dice che non si trova un modulo che gestisce quel dispositivo. Questo non deve comunque interessare più di tanto, poiché alcuni dispositivi non hanno driver nel kernel che lavorino per loro.<br />
<br />
==Determinare il modulo corretto partendo da zero==<br />
Talvolta non c'è la possibilità di avere un kernel funzionante su una macchina in modo da determinare quali moduli del kernel siano necessari per gestire l'hardware. Oppure si è aggiunto del nuovo hardware al sistema e bisogna trovare le opzioni della configurazione necessarie a farlo funzionare correttamente. Questa sezione illustrerà come determinare le opzioni di configurazione necessarie ad far funzionare l'hardware.<br />
<br />
Il modo più semplice per capire quale driver controlla un nuovo dispositivo è quello di compilare come moduli tutti i driver di quel tipo disponibili nei sorgenti del kernel, e lasciare che il processo di avvio tramite ''udev'' associ il driver al dispositivo. Una volta fatto ciò, si dovrebbe essere in grado di risalire al driver necessario seguendo i passi descritti precedentemente, ed infine ricompilare il kernel abilitando il solo driver necessario.<br />
<br />
Se invece non si vogliono compilare tutti i driver, o questo meccanismo non funziona per qualche motivo, sarà necessario un pò più di lavoro per individuare il driver necessario. I passi successivi sono complessi e richiedono talvolta di dover cercare nei sorgenti del kernel. Non abbiate timore di ciò, sarà solo di aiuto a comprendere meglio l'hardware ed i sorgenti del kernel.<br />
<br />
I passi necessari per trovare il driver corrispondente di un dispositivo cambiano a seconda del tipo di dispositivo in questione. In questo capitolo discuteremo le due tipologie di dispositivi più comuni: PCI e USB. I metodi descritti qui saranno validi anche per altri tipi di dispositivi.<br />
<br />
&Egrave; inoltre molto importante per il kernel di essere in grado di trovare tutti i filesystem presenti nel sistema, ed in particolare il filesystem di root. Approfondiremop questo aspetto successivamente in [[LKN: Personalizzare un Kernel#Root filesystem|"Root filesystem"]].<br />
<br />
<br />
===Dispositivi PCI===<br />
I dispositivi PCI si distinguono per ''vendor ID'' e ''device ID''; ogni combinazione di ''vendor ID'' e di ''device ID'' può richiedere un driver unico. Questa è la base per la ricerca mostrata in questa sezione.<br />
<br />
Per questo esempio useremo un scheda di rete PCI che supporremo non funzionante con l'attuare versione del kernele in esecuzione. Questo esempio sarà diverso dalla vostra situazione, con differenti device PCI e valori ID del bus, ma i passi salienti dovrebbero essere rilevanti per ogni tipo di dispositivo PCI per il quale vogliate trovare un driver funzionante.<br />
<br />
In primo luogo troviamo nel sistema il dispositivo PCI che non stà funzionando. Per ottenere una lista di tutti i dispositivi PCI usiamo il programma <code>lspci</code>. Poiché a noi interessano solo dispositivi PCI ethernet restringeremo la nostra ricerca filtrado tra i risultati solo quelli che conterranno la parola ''ethernet'' (case-insensitive):<br />
<br />
<pre><br />
$ /usr/sbin/lspci | grep -i ethernet<br />
06:04.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL-8139/<br />
8139C/8139C+ (rev 10)<br />
</pre><br />
<br />
Questo è il dispositivo che vorremmo fare funzionare.<br />
<br />
{{Box|Nota:|Potreste anche provare a cercare in tutta la configurazione del kernel un dispositivo che corrisponde alla stringa mostrata sopra (un dispositivo della Realtek Semiconductors con nome prodotto RTL-8139/8139C/8139C+), ma questo non funziona sempre. Per questo motivo useremo la via lunga in questo capitolo.}}<br />
<br />
::[[Immagine:Warning_65x68.jpg|left]] Quasi tutte le distribuzioni mettono il programma <tt>lspci</tt> in <tt>/usr/sbin/</tt>, ma alcune lo mettono in altri percorsi. Per trovare in quale posizione è stato messo digitare:<br />
<br />
::<tt>$ '''which lspci'''</tt><br />
::<tt>/usr/sbin/lspci</tt><br />
<br />
Se state usando una distribuzione che mette ''lspci'' in una altra posizione usate il percorso corretto per il vostro caso negli esempi seguenti.<br />
<br />
Le primi bit d'informazione che l'output di ''lspci'' ci mostra sono l'ID del bus PCI per questo dispositivo, <tt>06:04.0</tt>. Questo è il valore che useremo quando guarderemo nel ''sysfs'' per trovare più informazioni riguardo questo dispositivo.<br />
<br />
Andiamo in ''sysfs'' dove tutti i dispositivi PCI sono elencati, e guardiamo i loro nomi:<br />
<br />
<pre><br />
$ cd /sys/bus/pci/devices/<br />
$ ls<br />
0000:00:00.0 0000:00:1d.0 0000:00:1e.0 0000:00:1f.3 0000:06:03.3<br />
0000:00:02.0 0000:00:1d.1 0000:00:1f.0 0000:06:03.0 0000:06:03.4<br />
0000:00:02.1 0000:00:1d.2 0000:00:1f.1 0000:06:03.1 0000:06:04.0<br />
0000:00:1b.0 0000:00:1d.7 0000:00:1f.2 0000:06:03.2 0000:06:05.0<br />
</pre><br />
<br />
Il kernel numera i dispositivi PCI con un <tt>0000:</tt> iniziale che non viene mostrato nell'output di ''lspci''. Dunque, aggiungiamo un <tt>0000:</tt> al numero datoci da ''lspci'' e entriamo in quella directory:<br />
<br />
$ cd 0000:06:04.0<br />
<br />
In questa directory vogliamo conoscere il valori dei file ''vendor'' e ''device''.<br />
<br />
<pre><br />
$ cat vendor<br />
0x10ec<br />
$ cat device<br />
0x8139<br />
</pre><br />
<br />
Questi sono il ''vednor ID'' ed il ''device ID'' per questo dispositivo PCI. Il kernel usa questi valori per associare correttamente un driver ad un dispositivo.<br />
<br />
===Dispositivi USB===<br />
<br />
===Root filesystem===<br />
<br />
<br />
====Controller del disco====<br />
<br />
===Un aiuto dallo script===<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14889LKN: Personalizzare un Kernel2007-08-14T14:19:16Z<p>TheNoise: /* Determinare il modulo corretto partendo da zero */</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
Uno dei punti più delicati e difficili nella creazione della propria versione del kernel Linux è quello di determinare esattamente quali driver e quali opzioni di configurazione sono richiesti per il corretto funzionamento dalla macchina su cui viene installato.<br />
Questo capitolo guiderà il lettore attraverso questo processo di selezione e scelta dei driver corretti.<br />
<br />
==Usare un kernel di una distribuzione==<br />
<br />
Uno dei metodi più semplici, per determinare quali moduli siano necessari, è quello di partire dalla configurazione che viene installata dal pacchetto del kernel della distribuzione che si sta usando. È infatti molto più semplice determinare di quali driver si ha bisogno basandosi su quelli installati in un sistema in funzione, in cui i driver corretti sono già associati all'hardware in utilizzo.<br />
<br />
Se invece si sta personalizzando un kernel per una macchina sulla quale non è installata una distribuzione Linux, allora conviene partire dalla versione LiveCD di una distribuzione. Questo consente all'utente di far partire Linux sulla macchina in oggetto e di determinare in maniera semplice le opzioni di configurazione del kernel e che consentono il funzionamento ottimale della macchina stessa.<br />
<br />
===Dove si trova la configurazione del kernel?===<br />
<br />
Quasi tutte le distribuzioni forniscono il file di configurazione nello stesso pacchetto del kernel. Si consiglia di leggere la documentazione relativa alla distribuzione stessa per sapere dove viene installato il file di configurazione. Solitamente si trova da qualche parte in una sotto-directory di <tt>/usr/src/linux/</tt>.<br />
<br />
{{Box|Nota per Debian (NdT)|In debian il file di configurazione di ogni kernel installato si trova in <tt>/boot/</tt> ed ha come nome <tt>config-''versione''</tt>.}}<br />
<br />
Se avete difficoltà a trovare la configurazione del kernel, allora guardate nel kernel stesso. I kernel di molte distribuzioni sono compilati in modo da includere il file di configurazione dentro il filesystem <tt>/proc</tt>. Per verificare se questo è il vostro caso, digitate:<br />
<br />
<pre><br />
$ ls /proc/config.gz<br />
/proc/config.gz<br />
</pre><br />
<br />
Se il file ''/proc/config.gz'' è presente, allora copiatelo nella directory del sorgente kernel ed estraetelo:<br />
<br />
<pre><br />
$ cp /proc/config.gz -/linux/<br />
$ cd -/linux<br />
$ gzip -dv config.gz<br />
config.gz: 74.9% - - replaced with config<br />
</pre><br />
<br />
Copiate questo file di configurazione nella vostra directory del kernel e rinominatelo in ''.config''.<br />
Ora potrete utilizzare questo file come base di partenza nella personalizzazione della configurazione del kernel così come descritto nel [[LKN:_Configurare_e_Compilare|Capitolo 4]].<br />
<br />
Usando questo file di configurazione si dovrebbe ottenere sempre un file immagine del kernel (un ''kernel ricompilato'', NdT) funzionante sulla propria macchina.<br />
Lo svantaggio di questa immagine è che verranno compilati quasi tutti i moduli e driver presenti nei sorgenti del kernel. Ciò non è quasi mai necessario per una singola macchina, quindi sarebbe meglio disabilitare tutti i driver e le opzioni non necessarie. Si raccomanda di disabilitare solo quelle opzioni che si è sicuri non serviranno, poiché ci sono parti del sistema che richiedono l'abilitazione di certe opzioni.<br />
<br />
===Determinare quali moduli siano necessari===<br />
Usando il file di configurazione fornito dalla vostra distribuzione il tempo richiesto per la compilazione del kernel è molto lungo poiché tutti i possibili driver vengono abilitati. Si dovrebbe cercare di abilitare solo i driver per l'hardware presente nel sistema, così da ridurre i tempi di compilazione del kernel. Inoltre, compilando ''staticamente'' (invece che come moduli) alcuni o tutti i driver necessari, si riduce la memoria utilizzata ed in alcune architetture si velocizza il funzionamento del sistema. Per escludere i driver dal kernel è necessario però determinare quali moduli sono indispensabili per il funzionamento dell'hardware installato. Attraverso l'utilizzo di due esempi, cercheremo di spiegare come determinare quali driver siano indispensabili al controllo dell'hardware.<br />
<br />
Le informazioni che mettono in relazione i dispositivi ai driver presenti nel kernel sono conservate in varie parti del sistema. Uno dei posti più importanti dove sono salvate queste informazioni è il filesystem virtuale ''sysfs''. All'avvio di Linux, ''sysfs'', dovrebbe essere montato dagli script di inizializzazione della vostra distribuzione nella directory ''/sys''. ''sysfs'' consente di dare un'occhiata a come le varie parti del kernel sono legate l'una a l'altra, questo lo si deduce grazie ai vari collegamenti simbolici (''symlink'' NdT) che puntano all'interno dell'intero filesystem.<br />
<br />
In tutti gli esempi di seguito, saranno riportati i veri percorsi (''path'' NdT) di ''sysfs'' corrispondenti ad hardware specifico. La vostra macchina sarà certamente diversa, ma la posizione relativa delle informazioni sarà la stessa. Non ci si deve allarmare se i nomi di file nel ''sysfs'' non sono i medesimi, ciò è normale e prevedibile.<br />
<br />
Inoltre, la struttura interna del file di sistema ''sysfs'' subisce modifiche, a causa sia della riorganizzazione dei driver sia del fatto che gli sviluppatori del kernel trovano nuovi modi per meglio presentare in ''user space'' le strutture interne del kernel. A causa di questo, col tempo, alcuni dei ''symlink'', precedentemente menzionati in questo capitolo, possono non essere presenti. Tuttavia, le informazioni sono ancora tutte presenti, al massimo sono state un po' spostate.<br />
<br />
====Esempio: Come determinare il driver di rete====<br />
<br />
Uno degli elementi più comuni ed importanti in un sistema è la scheda di rete. È essenziale capire quale driver la controlla ed attivarlo nella configurazione in maniera da consentire un corretto funzionamento delle connessioni di rete.<br />
<br />
Primo: partendo dalle connessioni di rete si risale al device PCI <br />
<pre>$ ls /sys/class/net/<br />
eth0 eth1 eth2 lo</pre><br />
<br />
La directory ''lo'' rappresenta il dispositivo di rete loopback, ed non è dipendente da nessun dispositivo di rete realmente installato. Invece si dovrebbe riservare particolare attenzione alle directory ''eth0'', ''eth1'' e ''eth2'', dato che si riferiscono a dispositivi realmente esistenti<br />
<br />
Per determinare di quali dispositivi ci si deve occupare, si utilizza il comando ''ifconfig'':<br />
<br />
<pre>$ /sbin/ifconfig -a<br />
eth0 Link encap:Ethernet HWaddr 00:12:3F:65:7D:C2<br />
inet addr:192.168.0.13 Bcast:192.168.0.255 Mask:255.255.255.0<br />
UP BROADCAST NOTRAILERS RUNNING MULTICAST MTU:1500 Metric:1<br />
RX packets:2720792 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:1815488 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:100<br />
RX bytes:3103826486 (2960.0 Mb) TX bytes:371424066 (354.2 Mb)<br />
Base address:0xdcc0 Memory:dfee0000-dff00000<br />
eth1 Link encap:UNSPEC HWaddr 80-65-00-12-7D-C2-3F-00-00-00-00-00-00-00-00<br />
BROADCAST MULTICAST MTU:1500 Metric:1<br />
RX packets:0 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)<br />
eth2 Link encap:UNSPEC HWaddr 00-02-3C-04-11-09-D2-BA-00-00-00-00-00-00-00<br />
BROADCAST MULTICAST MTU:1500 Metric:1<br />
RX packets:0 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)<br />
lo Link encap:Local Lookback<br />
inet addr:127.0.0.1 Mask:255.0.0.0<br />
UP LOOPBACK RUNNING MTU:16436 Metric:1<br />
RX packets:60 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:60 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:13409 (13.0 Kb) TX bytes:13409 (13.0 Kb)</pre><br />
<br />
Da questo listato si può riconoscere nel dispositivo di rete <tt>eth0</tt>, quello attivo e funzionante, infatti nelle righe;<br />
<br />
<pre>eth0 Link encap:Ethernet HWaddr 00:12:3F:65:7D:C2<br />
inet addr:192.168.0.13 Bcast:192.168.0.255 Mask:255.255.255.0</pre><br />
<br />
Questo risultato dimostra che il dispositivo Ethernet si vede assegnato un indirizzo IP valido (<tt>inet</tt>).<br />
<br />
Ora, dopo che abbiamo individuato il dispositivo <tt>eth0</tt> e ci siamo accertati di volerlo abilitare nel nostro nuovo kernel, dobbiamo individuare quale driver lo controlla. Ciò si realizza con una semplice procedura, che è quella si seguire i link nel filesystem sysfs, basta digitare un comando di una sola riga:<br />
<br />
<pre>$ basename `readlink /sys/class/net/eth0/device/driver/module`<br />
e1000</pre><br />
<br />
Il risultato mostra che il modulo <tt>e1000</tt> controlla il dispositivo di rete <tt>eth0</tt>. Il comando ''basename'' racchiude in un'unica linea di comando i seguenti passaggi:<br />
<br />
: 1. Individua il symlink ''/sys/class/net/eth0/device'' contenuto all'interno della directory ''/sys/device/'', la quale contiene le informazioni relative al dispositivo che controlla ''eth0''. Fate attenzione al fatto che nelle nuove versioni del kernel la directory ''/sys/class/net/eth0'' potrebbe essere un symlink. <br />
<br />
: 2. All'interno della directory che descrive il dispositivo in sysfs, c'è un symlink che punta al driver relativo a questo dispositivo. Questo symlink è nominato ''driver'', pertanto si segue questo collegamento.<br />
<br />
: 3. All'interno della directory che descrive il driver in sysfs, c'è un symlink che punta al modulo che si trova all'interno del driver in oggetto. Questo symlink è chiamato <tt>module</tt>. Noi cerchiamo l'oggetto a cui punta questo symlink, per ottenerlo ci serviamo del comando ''readlink'', il quale produce un risultato simile a questo:<br />
:<pre>$ readlink /sys/class/net/eth0/device/driver/module </pre><br />
:<pre> ../../../../module/e1000</pre><br />
<br />
: 4. Dato che a noi interessa solo il nome del modulo e ci disinteressiamo del resto del risultato ottenuto con il comando ''readlink'', tenendo solo la parte più a destra del risultato. Questo è appunto ciò che il comando ''basename'' realizza. Applicandolo direttamente all'intero percorso, questo comando ci ritorna quanto segue: <br />
: <pre>$ basename ../../../../module/e1000</pre><br />
: <pre>e1000</pre><br />
<br />
Così abbiamo inserito il lungo risultato del symlink, ottenuto da ''readlink'', quale parametro nel programma ''basemane'', permettendo così l'intero processo di essere realizzato in una sola riga.<br />
<br />
Ora che abbiamo identificato il nome del modulo, si dovrebbe trovare l'opzione della configurazione del kernel che lo controlla. Si può cercare nei vari menu di configurazione dei dispositivi di rete oppure cercare nel codice sorgente del kernel stesso per essere sicuri di avere l'opzione giusta.<br />
<br />
<pre><br />
$ cd ~/linux/linux-2.6.17.8<br />
$ find -type f -name Makefile | xargs grep e1000<br />
./drivers/net/Makefile:obj-$(CONFIG_E1000) += e1000/<br />
./drivers/net/e1000/Makefile:obj-$(CONFIG_E1000) += e1000.o<br />
./drivers/net/e1000/Makefile:e1000-objs := e1000_main.o e1000_hw.o e1000_ethtool.o e1000_param.o<br />
</pre><br />
<br />
Si precisa che "e1000'', usato in questo esempio, deve essere sostituito con il nome del modulo che state analizzando.<br />
<br />
La cosa che ci interessa nel risultato del precedente comando ''find'' sono le righe dove compaia il termine <tt>'''CONFIG_'''</tt>. Questa è l'opzione di configurazione che il kernel deve aver attivato per poter compilare il modulo. Nell'esempio precedente l'opzione di configurazione che c'interessa è pertanto <tt>CONFIG_E1000</tt>.<br />
<br />
Adesso si dispone dell'informazione necessaria per poter configurare il kernel. Si esegue lo strumento menu di configurazione:<br />
<br />
<pre>$ make menuconfig</pre><br />
<br />
Dopodiché si prema il tasto / (slash) (che ha il compito di far partire una ricerca), e si digita l'opzione di configurazione, senza la parte di testo <tt>CONFIG_</tt>. Questo processo è mostrato nella [[:Immagine:Config_search.png|figura 7-1]].<br />
<br />
[[Immagine:Config_search.png|center|frame|''Figura 7-1. Ricerca in menuconfig.'']]<br />
<br />
Il sistema di configurazione del kernel vi dirà ora esattamente dove selezionare l'opzione per abilitare questo modulo. Vedi [[:Immagine:Config_search_found.png|figura 7-2]].<br />
<br />
[[Immagine:Config_search_found.png|center|frame|''Figura 7-2. Risultato della ricerca in menuconfig.'']]<br />
<br />
Il primo elemento nella schermata mostra l'opzione che stavate cercando. Le informazioni mostrate dalla schermata vi dicono che, per attivare il modulo <tt>E1000</tt> nel kernel, la seguente opzione di configurazione deve essere abilitata:<br />
<br />
Device Drivers<br />
Network device support<br />
[*] Network device support<br />
Ethernet (1000 Mbit)<br />
[*] Intel(R) PRO/1000 Gigabit Ethernet support<br />
<br />
Questo modo di procedere funziona per ogni tipo di dispositivo attivo nel kernel.<br />
<br />
====Esempio: Un dispositivo USB====<br />
<br />
Come secondo esempio, esaminiamo ora un convertitore USB-seriale che è presente nel nostro sistema preso ad esempio. Attualmente il convertitore è collegato alla porta ''/dev/ttyUSB0'', pertanto si deve prendere in esame la sezione tty del ''sysfs''.<br />
<pre>$ ls /sys/class/tty/ | grep USB<br />
ttyUSB0</pre><br />
Potete ora eseguire una ricerca di questo dispositivo nel ''sysfs'' allo scopo di trovare il modulo che lo gestisce, utilizzando la stessa procedura mostrata nella sezione precedente:<br />
<br />
<pre>$ basename `readlink /sys/class/tty/ttyUSB0/device/driver/module`<br />
pl2303</pre><br />
Dopodiché, per poter individuare l'opzione di configurazione che si deve abilitare, si cerca nell'albero del codice sorgente del kernel:<br />
<pre>$ cd ~/linux/linux-2.6.17.8<br />
$ find -type f -name Makefile | xargs grep pl2303<br />
./drivers/usb/serial/Makefile:obj-$(CONFIG_USB_SERIAL_PL2303) += pl2303.o</pre><br />
<br />
Si utilizzi lo strumento di configurazione del kernel, come indicato in [[:Immagine:Config_search_pl2303.png|figura 7-3]], per trovare l'opzione adeguata da abilitare relativa al settaggio dell'opzione CONFIG_USB_SERIAL_PL2303.<br />
<br />
[[Immagine:Config_search_pl2303.png|center|frame|''Figura 7-3. Ricerca di USB_SERIAL_PL2303''.]]<br />
<br />
Nel nostro caso il risultato è mostrato nella [[:Immagine:Config_search_pl2303_found.png|figura 7-4]].<br />
<br />
[[Immagine:Config_search_pl2303_found.png|center|frame|''Figura 7-4. Risultato della ricerca di USB_SERIAL_PL2303'']]<br />
<br />
Ciò mostra esattamente dove trovare l'opzione <tt>USB Profilic 2303 Single Port Serial Driver</tt> che è necessaria alla corretta gestione di questo dispositivo.<br />
<br />
====Riassunto: Alla scoperta del dispositivo====<br />
<br />
Riassumendo, ecco i vari passaggi che servono per identificare il driver funzionante di un dispositivo ad esso collegato:<br />
: 1. Trovate la corretta classe di dispositivi in ''sysfs'' relativa al dispositivo che ci interessa. I dispositivi di rete sono elencati in ''/sys/class/net'', mentre i dispositivi tty sono elencati in ''/sys/class/tty''. Gli altri vari dispositivi si trovano in altre sotto-directory di ''/sys/class'', a seconda del tipo.<br />
: 2. Ricercate nell'albero di ''sysfs'' il nome del modulo che controlla il dispositivo in oggetto. Lo si trova in ''/sys/class/class_name/device_name/device/driver/module'', la ricerca è agevolata se si utilizzano i comandi ''readlink'' e ''basename''.<br />
:<pre>$ basename `readlink /sys/class/class_name/device_name/device/driver/module`</pre><br />
: 3. Ricercate nei file Makefile con ''find'' e ''grep'' le opzioni <tt>CONFIG_</tt> che abilitano il modulo<br />
:<pre>$ find -type f -name Makefile | xargs grep ''module_name''</pre><br />
: 4. Ricercate l'opzione trovata nel sistema di configurazione del kernel, dopodiché andate dove indicato dal menu per attivare il driver in oggetto.<br />
<br />
====Lasciamo che il kernel ci dica ciò di cui abbiamo bisogno====<br />
Dopo esserci infilati nel ''sysfs'' e aver seguito i sui symlinks per ricercare passo passo i nomi dei moduli, presentiamo un semplice script che farà per noi tutto il lavoro in un modo leggermente diverso:<br />
<br />
<pre><br />
#!/bin/bash<br />
#<br />
# find_all_modules.sh<br />
#<br />
for i in `find /sys/ -name modalias -exec cat {} \;`; do<br />
/sbin/modprobe --config /dev/null --show-depends $1 ;<br />
done | rev | cut -f i -d '/' | rev | sort -u<br />
</pre><br />
<br />
Si può scaricare un file d'esempio, contenente questo script, dal sito web del libro, riportato nella sezione ''Come contattarci'' che si trova nella prefazione.<br />
<br />
Questo script cerca nel ''sysfs'' tutti file chiamati ''modalias''. Il file ''modalias'' contiene gli alias dei moduli e comunica al comando ''modprobe'' quali moduli debbano essere caricati per ogni dispositivo. L'alias del modulo è composto da una combinazione di: produttore del dispositivo, ID, tipo di classe ed altri identificativi univoci per il tipo di dispositivo in questione. Tutti i moduli del driver del kernel hanno una lista interna dei dispositivi che supportano, che è generata automaticamente dalla lista dei dispositivi che il driver comunica al kernel di poter supportare. Il comando ''modprobe'' ricerca tutti i dispositivi nella lista di tutti i driver e cerca di trovare una corrispondenza confrontando l'alias. Se trova una corrispondenza, allora provvede al caricamento del modulo (questa procedura è la stessa seguita dal caricamento automatico dei driver in Linux).<br />
<br />
Lo script prevede l'arresto del programma ''modprobe'' prima di caricare il modulo, e visualizza a schermo solo le azioni che eseguirebbe. Questo ci d&agrave; una lista di tutti i moduli che sono necessari al controllo di tutti i dispositivi del sistema. Eseguendo una piccola pulizia della lista, ordinandola e selezionando i campi adeguati, <br />
otteniamo il seguente risultato:<br />
<br />
<pre><br />
$ find_all_modules.sh<br />
8139cp.ko<br />
8139too.koo<br />
ehci-hcd.ko<br />
fimware_vlass.ko<br />
i2c-i801.ko<br />
ieee80211.ko<br />
ieee80211_crypt.ko<br />
ipw2200.ko<br />
mii.ko<br />
mmc_core.ko<br />
pcmcia_core.ko<br />
rsrc_nonstatic.ko<br />
sdhci.ko<br />
snd-hda-codec.ko<br />
snd-hda-intel.ko<br />
snd-page-alloc.ko<br />
snd-pmc.ko<br />
snd-timer.ko<br />
snd.ko<br />
soundcore.ko<br />
uhci-hcd.ko<br />
usbcore.ko<br />
yenta_socket.ko<br />
</pre><br />
<br />
Questa è la lista di tutti i moduli che sono necessari alla gestione dell'hardware della macchina.<br />
<br />
Lo script mostrerà probabilmente alcuni messaggi di errore che possono essere del tipo:<br />
<br />
<pre>FATAL: Module pci:v00008086d00002592sv000010CFsd000012E0bc03sc00i00 not found.<br />
FATAL: Module serio:ty01pr00id00ex00 not found.</pre><br />
<br />
Questo ci dice che non si trova un modulo che gestisce quel dispositivo. Questo non deve comunque interessare più di tanto, poiché alcuni dispositivi non hanno driver nel kernel che lavorino per loro.<br />
<br />
==Determinare il modulo corretto partendo da zero==<br />
Talvolta non c'è la possibilità di avere un kernel funzionante su una macchina in modo da determinare quali moduli del kernel siano necessari per gestire l'hardware. Oppure si è aggiunto del nuovo hardware al sistema e bisogna trovare le opzioni della configurazione necessarie a farlo funzionare correttamente. Questa sezione illustrerà come determinare le opzioni di configurazione necessarie ad far funzionare l'hardware.<br />
<br />
Il modo più semplice per capire quale driver controlla un nuovo dispositivo è quello di compilare come moduli tutti i driver di quel tipo disponibili nei sorgenti del kernel, e lasciare che il processo di avvio tramite ''udev'' associ il driver al dispositivo. Una volta fatto ciò, si dovrebbe essere in grado di risalire al driver necessario seguendo i passi descritti precedentemente, ed infine ricompilare il kernel abilitando il solo driver necessario.<br />
<br />
Se invece non si vogliono compilare tutti i driver, o questo meccanismo non funziona per qualche motivo, sarà necessario un pò più di lavoro per individuare il driver necessario. I passi successivi sono complessi e richiedono talvolta di dover cercare nei sorgenti del kernel. Non abbiate timore di ciò, sarà solo di aiuto a comprendere meglio l'hardware ed i sorgenti del kernel.<br />
<br />
I passi necessari per trovare il driver corrispondente di un dispositivo cambiano a seconda del tipo di dispositivo in questione. In questo capitolo discuteremo le due tipologie di dispositivi più comuni: PCI e USB. I metodi descritti qui saranno validi anche per altri tipi di dispositivi.<br />
<br />
&Egrave; inoltre molto importante per il kernel di essere in grado di trovare tutti i filesystem presenti nel sistema, ed in particolare il filesystem di root. Approfondiremop questo aspetto successivamente in [[LKN: Personalizzare un Kernel#Root filesystem|"Root filesystem"]].<br />
<br />
<br />
===Dispositivi PCI===<br />
<br />
<br />
===Dispositivi USB===<br />
<br />
===Root filesystem===<br />
<br />
<br />
====Controller del disco====<br />
<br />
===Un aiuto dallo script===<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14888LKN: Personalizzare un Kernel2007-08-14T14:02:57Z<p>TheNoise: /* Lasciate che il kernel ci dica ciò di cui abbiamo bisogno */</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
Uno dei punti più delicati e difficili nella creazione della propria versione del kernel Linux è quello di determinare esattamente quali driver e quali opzioni di configurazione sono richiesti per il corretto funzionamento dalla macchina su cui viene installato.<br />
Questo capitolo guiderà il lettore attraverso questo processo di selezione e scelta dei driver corretti.<br />
<br />
==Usare un kernel di una distribuzione==<br />
<br />
Uno dei metodi più semplici, per determinare quali moduli siano necessari, è quello di partire dalla configurazione che viene installata dal pacchetto del kernel della distribuzione che si sta usando. È infatti molto più semplice determinare di quali driver si ha bisogno basandosi su quelli installati in un sistema in funzione, in cui i driver corretti sono già associati all'hardware in utilizzo.<br />
<br />
Se invece si sta personalizzando un kernel per una macchina sulla quale non è installata una distribuzione Linux, allora conviene partire dalla versione LiveCD di una distribuzione. Questo consente all'utente di far partire Linux sulla macchina in oggetto e di determinare in maniera semplice le opzioni di configurazione del kernel e che consentono il funzionamento ottimale della macchina stessa.<br />
<br />
===Dove si trova la configurazione del kernel?===<br />
<br />
Quasi tutte le distribuzioni forniscono il file di configurazione nello stesso pacchetto del kernel. Si consiglia di leggere la documentazione relativa alla distribuzione stessa per sapere dove viene installato il file di configurazione. Solitamente si trova da qualche parte in una sotto-directory di <tt>/usr/src/linux/</tt>.<br />
<br />
{{Box|Nota per Debian (NdT)|In debian il file di configurazione di ogni kernel installato si trova in <tt>/boot/</tt> ed ha come nome <tt>config-''versione''</tt>.}}<br />
<br />
Se avete difficoltà a trovare la configurazione del kernel, allora guardate nel kernel stesso. I kernel di molte distribuzioni sono compilati in modo da includere il file di configurazione dentro il filesystem <tt>/proc</tt>. Per verificare se questo è il vostro caso, digitate:<br />
<br />
<pre><br />
$ ls /proc/config.gz<br />
/proc/config.gz<br />
</pre><br />
<br />
Se il file ''/proc/config.gz'' è presente, allora copiatelo nella directory del sorgente kernel ed estraetelo:<br />
<br />
<pre><br />
$ cp /proc/config.gz -/linux/<br />
$ cd -/linux<br />
$ gzip -dv config.gz<br />
config.gz: 74.9% - - replaced with config<br />
</pre><br />
<br />
Copiate questo file di configurazione nella vostra directory del kernel e rinominatelo in ''.config''.<br />
Ora potrete utilizzare questo file come base di partenza nella personalizzazione della configurazione del kernel così come descritto nel [[LKN:_Configurare_e_Compilare|Capitolo 4]].<br />
<br />
Usando questo file di configurazione si dovrebbe ottenere sempre un file immagine del kernel (un ''kernel ricompilato'', NdT) funzionante sulla propria macchina.<br />
Lo svantaggio di questa immagine è che verranno compilati quasi tutti i moduli e driver presenti nei sorgenti del kernel. Ciò non è quasi mai necessario per una singola macchina, quindi sarebbe meglio disabilitare tutti i driver e le opzioni non necessarie. Si raccomanda di disabilitare solo quelle opzioni che si è sicuri non serviranno, poiché ci sono parti del sistema che richiedono l'abilitazione di certe opzioni.<br />
<br />
===Determinare quali moduli siano necessari===<br />
Usando il file di configurazione fornito dalla vostra distribuzione il tempo richiesto per la compilazione del kernel è molto lungo poiché tutti i possibili driver vengono abilitati. Si dovrebbe cercare di abilitare solo i driver per l'hardware presente nel sistema, così da ridurre i tempi di compilazione del kernel. Inoltre, compilando ''staticamente'' (invece che come moduli) alcuni o tutti i driver necessari, si riduce la memoria utilizzata ed in alcune architetture si velocizza il funzionamento del sistema. Per escludere i driver dal kernel è necessario però determinare quali moduli sono indispensabili per il funzionamento dell'hardware installato. Attraverso l'utilizzo di due esempi, cercheremo di spiegare come determinare quali driver siano indispensabili al controllo dell'hardware.<br />
<br />
Le informazioni che mettono in relazione i dispositivi ai driver presenti nel kernel sono conservate in varie parti del sistema. Uno dei posti più importanti dove sono salvate queste informazioni è il filesystem virtuale ''sysfs''. All'avvio di Linux, ''sysfs'', dovrebbe essere montato dagli script di inizializzazione della vostra distribuzione nella directory ''/sys''. ''sysfs'' consente di dare un'occhiata a come le varie parti del kernel sono legate l'una a l'altra, questo lo si deduce grazie ai vari collegamenti simbolici (''symlink'' NdT) che puntano all'interno dell'intero filesystem.<br />
<br />
In tutti gli esempi di seguito, saranno riportati i veri percorsi (''path'' NdT) di ''sysfs'' corrispondenti ad hardware specifico. La vostra macchina sarà certamente diversa, ma la posizione relativa delle informazioni sarà la stessa. Non ci si deve allarmare se i nomi di file nel ''sysfs'' non sono i medesimi, ciò è normale e prevedibile.<br />
<br />
Inoltre, la struttura interna del file di sistema ''sysfs'' subisce modifiche, a causa sia della riorganizzazione dei driver sia del fatto che gli sviluppatori del kernel trovano nuovi modi per meglio presentare in ''user space'' le strutture interne del kernel. A causa di questo, col tempo, alcuni dei ''symlink'', precedentemente menzionati in questo capitolo, possono non essere presenti. Tuttavia, le informazioni sono ancora tutte presenti, al massimo sono state un po' spostate.<br />
<br />
====Esempio: Come determinare il driver di rete====<br />
<br />
Uno degli elementi più comuni ed importanti in un sistema è la scheda di rete. È essenziale capire quale driver la controlla ed attivarlo nella configurazione in maniera da consentire un corretto funzionamento delle connessioni di rete.<br />
<br />
Primo: partendo dalle connessioni di rete si risale al device PCI <br />
<pre>$ ls /sys/class/net/<br />
eth0 eth1 eth2 lo</pre><br />
<br />
La directory ''lo'' rappresenta il dispositivo di rete loopback, ed non è dipendente da nessun dispositivo di rete realmente installato. Invece si dovrebbe riservare particolare attenzione alle directory ''eth0'', ''eth1'' e ''eth2'', dato che si riferiscono a dispositivi realmente esistenti<br />
<br />
Per determinare di quali dispositivi ci si deve occupare, si utilizza il comando ''ifconfig'':<br />
<br />
<pre>$ /sbin/ifconfig -a<br />
eth0 Link encap:Ethernet HWaddr 00:12:3F:65:7D:C2<br />
inet addr:192.168.0.13 Bcast:192.168.0.255 Mask:255.255.255.0<br />
UP BROADCAST NOTRAILERS RUNNING MULTICAST MTU:1500 Metric:1<br />
RX packets:2720792 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:1815488 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:100<br />
RX bytes:3103826486 (2960.0 Mb) TX bytes:371424066 (354.2 Mb)<br />
Base address:0xdcc0 Memory:dfee0000-dff00000<br />
eth1 Link encap:UNSPEC HWaddr 80-65-00-12-7D-C2-3F-00-00-00-00-00-00-00-00<br />
BROADCAST MULTICAST MTU:1500 Metric:1<br />
RX packets:0 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)<br />
eth2 Link encap:UNSPEC HWaddr 00-02-3C-04-11-09-D2-BA-00-00-00-00-00-00-00<br />
BROADCAST MULTICAST MTU:1500 Metric:1<br />
RX packets:0 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)<br />
lo Link encap:Local Lookback<br />
inet addr:127.0.0.1 Mask:255.0.0.0<br />
UP LOOPBACK RUNNING MTU:16436 Metric:1<br />
RX packets:60 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:60 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:13409 (13.0 Kb) TX bytes:13409 (13.0 Kb)</pre><br />
<br />
Da questo listato si può riconoscere nel dispositivo di rete <tt>eth0</tt>, quello attivo e funzionante, infatti nelle righe;<br />
<br />
<pre>eth0 Link encap:Ethernet HWaddr 00:12:3F:65:7D:C2<br />
inet addr:192.168.0.13 Bcast:192.168.0.255 Mask:255.255.255.0</pre><br />
<br />
Questo risultato dimostra che il dispositivo Ethernet si vede assegnato un indirizzo IP valido (<tt>inet</tt>).<br />
<br />
Ora, dopo che abbiamo individuato il dispositivo <tt>eth0</tt> e ci siamo accertati di volerlo abilitare nel nostro nuovo kernel, dobbiamo individuare quale driver lo controlla. Ciò si realizza con una semplice procedura, che è quella si seguire i link nel filesystem sysfs, basta digitare un comando di una sola riga:<br />
<br />
<pre>$ basename `readlink /sys/class/net/eth0/device/driver/module`<br />
e1000</pre><br />
<br />
Il risultato mostra che il modulo <tt>e1000</tt> controlla il dispositivo di rete <tt>eth0</tt>. Il comando ''basename'' racchiude in un'unica linea di comando i seguenti passaggi:<br />
<br />
: 1. Individua il symlink ''/sys/class/net/eth0/device'' contenuto all'interno della directory ''/sys/device/'', la quale contiene le informazioni relative al dispositivo che controlla ''eth0''. Fate attenzione al fatto che nelle nuove versioni del kernel la directory ''/sys/class/net/eth0'' potrebbe essere un symlink. <br />
<br />
: 2. All'interno della directory che descrive il dispositivo in sysfs, c'è un symlink che punta al driver relativo a questo dispositivo. Questo symlink è nominato ''driver'', pertanto si segue questo collegamento.<br />
<br />
: 3. All'interno della directory che descrive il driver in sysfs, c'è un symlink che punta al modulo che si trova all'interno del driver in oggetto. Questo symlink è chiamato <tt>module</tt>. Noi cerchiamo l'oggetto a cui punta questo symlink, per ottenerlo ci serviamo del comando ''readlink'', il quale produce un risultato simile a questo:<br />
:<pre>$ readlink /sys/class/net/eth0/device/driver/module </pre><br />
:<pre> ../../../../module/e1000</pre><br />
<br />
: 4. Dato che a noi interessa solo il nome del modulo e ci disinteressiamo del resto del risultato ottenuto con il comando ''readlink'', tenendo solo la parte più a destra del risultato. Questo è appunto ciò che il comando ''basename'' realizza. Applicandolo direttamente all'intero percorso, questo comando ci ritorna quanto segue: <br />
: <pre>$ basename ../../../../module/e1000</pre><br />
: <pre>e1000</pre><br />
<br />
Così abbiamo inserito il lungo risultato del symlink, ottenuto da ''readlink'', quale parametro nel programma ''basemane'', permettendo così l'intero processo di essere realizzato in una sola riga.<br />
<br />
Ora che abbiamo identificato il nome del modulo, si dovrebbe trovare l'opzione della configurazione del kernel che lo controlla. Si può cercare nei vari menu di configurazione dei dispositivi di rete oppure cercare nel codice sorgente del kernel stesso per essere sicuri di avere l'opzione giusta.<br />
<br />
<pre><br />
$ cd ~/linux/linux-2.6.17.8<br />
$ find -type f -name Makefile | xargs grep e1000<br />
./drivers/net/Makefile:obj-$(CONFIG_E1000) += e1000/<br />
./drivers/net/e1000/Makefile:obj-$(CONFIG_E1000) += e1000.o<br />
./drivers/net/e1000/Makefile:e1000-objs := e1000_main.o e1000_hw.o e1000_ethtool.o e1000_param.o<br />
</pre><br />
<br />
Si precisa che "e1000'', usato in questo esempio, deve essere sostituito con il nome del modulo che state analizzando.<br />
<br />
La cosa che ci interessa nel risultato del precedente comando ''find'' sono le righe dove compaia il termine <tt>'''CONFIG_'''</tt>. Questa è l'opzione di configurazione che il kernel deve aver attivato per poter compilare il modulo. Nell'esempio precedente l'opzione di configurazione che c'interessa è pertanto <tt>CONFIG_E1000</tt>.<br />
<br />
Adesso si dispone dell'informazione necessaria per poter configurare il kernel. Si esegue lo strumento menu di configurazione:<br />
<br />
<pre>$ make menuconfig</pre><br />
<br />
Dopodiché si prema il tasto / (slash) (che ha il compito di far partire una ricerca), e si digita l'opzione di configurazione, senza la parte di testo <tt>CONFIG_</tt>. Questo processo è mostrato nella [[:Immagine:Config_search.png|figura 7-1]].<br />
<br />
[[Immagine:Config_search.png|center|frame|''Figura 7-1. Ricerca in menuconfig.'']]<br />
<br />
Il sistema di configurazione del kernel vi dirà ora esattamente dove selezionare l'opzione per abilitare questo modulo. Vedi [[:Immagine:Config_search_found.png|figura 7-2]].<br />
<br />
[[Immagine:Config_search_found.png|center|frame|''Figura 7-2. Risultato della ricerca in menuconfig.'']]<br />
<br />
Il primo elemento nella schermata mostra l'opzione che stavate cercando. Le informazioni mostrate dalla schermata vi dicono che, per attivare il modulo <tt>E1000</tt> nel kernel, la seguente opzione di configurazione deve essere abilitata:<br />
<br />
Device Drivers<br />
Network device support<br />
[*] Network device support<br />
Ethernet (1000 Mbit)<br />
[*] Intel(R) PRO/1000 Gigabit Ethernet support<br />
<br />
Questo modo di procedere funziona per ogni tipo di dispositivo attivo nel kernel.<br />
<br />
====Esempio: Un dispositivo USB====<br />
<br />
Come secondo esempio, esaminiamo ora un convertitore USB-seriale che è presente nel nostro sistema preso ad esempio. Attualmente il convertitore è collegato alla porta ''/dev/ttyUSB0'', pertanto si deve prendere in esame la sezione tty del ''sysfs''.<br />
<pre>$ ls /sys/class/tty/ | grep USB<br />
ttyUSB0</pre><br />
Potete ora eseguire una ricerca di questo dispositivo nel ''sysfs'' allo scopo di trovare il modulo che lo gestisce, utilizzando la stessa procedura mostrata nella sezione precedente:<br />
<br />
<pre>$ basename `readlink /sys/class/tty/ttyUSB0/device/driver/module`<br />
pl2303</pre><br />
Dopodiché, per poter individuare l'opzione di configurazione che si deve abilitare, si cerca nell'albero del codice sorgente del kernel:<br />
<pre>$ cd ~/linux/linux-2.6.17.8<br />
$ find -type f -name Makefile | xargs grep pl2303<br />
./drivers/usb/serial/Makefile:obj-$(CONFIG_USB_SERIAL_PL2303) += pl2303.o</pre><br />
<br />
Si utilizzi lo strumento di configurazione del kernel, come indicato in [[:Immagine:Config_search_pl2303.png|figura 7-3]], per trovare l'opzione adeguata da abilitare relativa al settaggio dell'opzione CONFIG_USB_SERIAL_PL2303.<br />
<br />
[[Immagine:Config_search_pl2303.png|center|frame|''Figura 7-3. Ricerca di USB_SERIAL_PL2303''.]]<br />
<br />
Nel nostro caso il risultato è mostrato nella [[:Immagine:Config_search_pl2303_found.png|figura 7-4]].<br />
<br />
[[Immagine:Config_search_pl2303_found.png|center|frame|''Figura 7-4. Risultato della ricerca di USB_SERIAL_PL2303'']]<br />
<br />
Ciò mostra esattamente dove trovare l'opzione <tt>USB Profilic 2303 Single Port Serial Driver</tt> che è necessaria alla corretta gestione di questo dispositivo.<br />
<br />
====Riassunto: Alla scoperta del dispositivo====<br />
<br />
Riassumendo, ecco i vari passaggi che servono per identificare il driver funzionante di un dispositivo ad esso collegato:<br />
: 1. Trovate la corretta classe di dispositivi in ''sysfs'' relativa al dispositivo che ci interessa. I dispositivi di rete sono elencati in ''/sys/class/net'', mentre i dispositivi tty sono elencati in ''/sys/class/tty''. Gli altri vari dispositivi si trovano in altre sotto-directory di ''/sys/class'', a seconda del tipo.<br />
: 2. Ricercate nell'albero di ''sysfs'' il nome del modulo che controlla il dispositivo in oggetto. Lo si trova in ''/sys/class/class_name/device_name/device/driver/module'', la ricerca è agevolata se si utilizzano i comandi ''readlink'' e ''basename''.<br />
:<pre>$ basename `readlink /sys/class/class_name/device_name/device/driver/module`</pre><br />
: 3. Ricercate nei file Makefile con ''find'' e ''grep'' le opzioni <tt>CONFIG_</tt> che abilitano il modulo<br />
:<pre>$ find -type f -name Makefile | xargs grep ''module_name''</pre><br />
: 4. Ricercate l'opzione trovata nel sistema di configurazione del kernel, dopodiché andate dove indicato dal menu per attivare il driver in oggetto.<br />
<br />
====Lasciamo che il kernel ci dica ciò di cui abbiamo bisogno====<br />
Dopo esserci infilati nel ''sysfs'' e aver seguito i sui symlinks per ricercare passo passo i nomi dei moduli, presentiamo un semplice script che farà per noi tutto il lavoro in un modo leggermente diverso:<br />
<br />
<pre><br />
#!/bin/bash<br />
#<br />
# find_all_modules.sh<br />
#<br />
for i in `find /sys/ -name modalias -exec cat {} \;`; do<br />
/sbin/modprobe --config /dev/null --show-depends $1 ;<br />
done | rev | cut -f i -d '/' | rev | sort -u<br />
</pre><br />
<br />
Si può scaricare un file d'esempio, contenente questo script, dal sito web del libro, riportato nella sezione ''Come contattarci'' che si trova nella prefazione.<br />
<br />
Questo script cerca nel ''sysfs'' tutti file chiamati ''modalias''. Il file ''modalias'' contiene gli alias dei moduli e comunica al comando ''modprobe'' quali moduli debbano essere caricati per ogni dispositivo. L'alias del modulo è composto da una combinazione di: produttore del dispositivo, ID, tipo di classe ed altri identificativi univoci per il tipo di dispositivo in questione. Tutti i moduli del driver del kernel hanno una lista interna dei dispositivi che supportano, che è generata automaticamente dalla lista dei dispositivi che il driver comunica al kernel di poter supportare. Il comando ''modprobe'' ricerca tutti i dispositivi nella lista di tutti i driver e cerca di trovare una corrispondenza confrontando l'alias. Se trova una corrispondenza, allora provvede al caricamento del modulo (questa procedura è la stessa seguita dal caricamento automatico dei driver in Linux).<br />
<br />
Lo script prevede l'arresto del programma ''modprobe'' prima di caricare il modulo, e visualizza a schermo solo le azioni che eseguirebbe. Questo ci d&agrave; una lista di tutti i moduli che sono necessari al controllo di tutti i dispositivi del sistema. Eseguendo una piccola pulizia della lista, ordinandola e selezionando i campi adeguati, <br />
otteniamo il seguente risultato:<br />
<br />
<pre><br />
$ find_all_modules.sh<br />
8139cp.ko<br />
8139too.koo<br />
ehci-hcd.ko<br />
fimware_vlass.ko<br />
i2c-i801.ko<br />
ieee80211.ko<br />
ieee80211_crypt.ko<br />
ipw2200.ko<br />
mii.ko<br />
mmc_core.ko<br />
pcmcia_core.ko<br />
rsrc_nonstatic.ko<br />
sdhci.ko<br />
snd-hda-codec.ko<br />
snd-hda-intel.ko<br />
snd-page-alloc.ko<br />
snd-pmc.ko<br />
snd-timer.ko<br />
snd.ko<br />
soundcore.ko<br />
uhci-hcd.ko<br />
usbcore.ko<br />
yenta_socket.ko<br />
</pre><br />
<br />
Questa è la lista di tutti i moduli che sono necessari alla gestione dell'hardware della macchina.<br />
<br />
Lo script mostrerà probabilmente alcuni messaggi di errore che possono essere del tipo:<br />
<br />
<pre>FATAL: Module pci:v00008086d00002592sv000010CFsd000012E0bc03sc00i00 not found.<br />
FATAL: Module serio:ty01pr00id00ex00 not found.</pre><br />
<br />
Questo ci dice che non si trova un modulo che gestisce quel dispositivo. Questo non deve comunque interessare più di tanto, poiché alcuni dispositivi non hanno driver nel kernel che lavorino per loro.<br />
<br />
==Determinare il modulo corretto partendo da zero==<br />
Talvolta non c'è la possibilità di avere un kernel funzionante su una macchina in modo da determinare quali moduli del kernel siano necessari per gestire l'hardware. Oppure si è aggiunto del nuovo hardware al sistema e bisogna trovare le opzioni della configurazione necessarie a farlo funzionare correttamente. Questa sezione illustrerà come determinare le opzioni di configurazione necessarie ad far funzionare l'hardware.<br />
<br />
Il modo più semplice per capire quale driver controlla un nuovo dispositivo è quello di compilare come moduli tutti i driver di quel tipo disponibili nei sorgenti del kernel, e lasciare che il processo di avvio tramite ''udev'' associ il driver al dispositivo. Una volta fatto ciò, si dovrebbe essere in grado di risalire al driver necessario seguendo i passi descritti precedentemente, ed infine ricompilare il kernel abilitando il solo driver necessario.<br />
<br />
===Dispositivi PCI===<br />
<br />
<br />
===Dispositivi USB===<br />
<br />
===Root Filesystem===<br />
<br />
<br />
====Controller di Disco====<br />
<br />
===Un aiuto dallo script===<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Migliorare_l%27aspetto_dei_font&diff=14860Migliorare l'aspetto dei font2007-07-09T08:32:11Z<p>TheNoise: aggiunte categorie</p>
<hr />
<div>Stufo del rendering di firefox, ho cercato un pò in giro ed ho trovato vari spunti il modo più veloce è questo.<br />
Apriamo un terminale root e diamo<br />
<br />
<pre># dpkg-reconfigure fontconfig-config</pre><br />
<br />
rispondiamo nell'ordine<br />
<br />
<pre>Native<br />
Always<br />
No</pre><br />
<br />
installiamo due librerie importanti<br />
<br />
<pre># apt-get install libcairo2 libxft2</pre><br />
<br />
ora da un terminale non da root creiamo il file .fonts.conf nella nostra home<br />
<br />
<pre>$ gedit .fonts.conf</pre><br />
<br />
ed inseriamo quanto segue<br />
<pre><br />
<?xml version="1.0"?><br />
<!DOCTYPE fontconfig SYSTEM "fonts.dtd"><br />
<fontconfig><br />
<br />
<match target="font" ><br />
<edit mode="assign" name="rgba" ><br />
<const>rgb</const><br />
</edit><br />
</match><br />
<match target="font" ><br />
<edit mode="assign" name="hinting" ><br />
<bool>true</bool><br />
</edit><br />
</match><br />
<match target="font" ><br />
<edit mode="assign" name="hintstyle" ><br />
<const>hintfull</const><br />
</edit><br />
</match><br />
<match target="font" ><br />
<edit mode="assign" name="antialias" ><br />
<bool>true</bool><br />
</edit><br />
</match><br />
</fontconfig><br />
</pre><br />
<br />
Salviamo il file e riavviamo X con ctrl+alt+backspace<br />
<br />
<br />
== KDE ==<br />
<br />
<br />
Una volta avviato kde se i font sono piccoli è perchè kdm sta utilizzando di default i 75dpi, bisogna quindi modificare /etc/kde3/kdm/kdmrc<br />
<br />
cercare la riga<br />
<br />
<pre>ServerArgsLocal=-nolisten tcp</pre><br />
<br />
e modificarla così<br />
<br />
<pre>ServerArgsLocal=-nolisten tcp -dpi 100</pre><br />
<br />
<br />
[[Categoria:Desktop]][[Categoria:Sistema]][[Categoria:Tips&Tricks]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Bibliografia&diff=14818LKN: Bibliografia2007-06-15T15:53:28Z<p>TheNoise: link pagina di indice</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
__TOC__<br />
<br />
Molte delle informazioni contenute in questo libro sono state estratte dalla documentazione del kernel e dal codice sorgente. La documentazione è infatti il miglior posto dove trovare informazioni e riferimenti su come compilare e installare il kernel ed è normalmente tenuta aggiornata a seguito di cambiamenti nella procedura di compilazione.<br />
<br />
== Libri ==<br />
Sono disponibili molti ottimi libri relativi alla programmazione del kernel Linux, ma solo pochi di essi trattano la compilazione e installazione del kernel. Ecco un elenco di libri che ho trovato utili.<br />
<br />
=== Libri generici su Linux ===<br />
<br />
* Ellen Siever, Aaron Weber, Stephen Figgins, Robert Love, e Arnold Robbins. ''Linux in a Nutshell'' (O’Reilly), 2005.<br/>Questo libro comprende una delle più complete e autorevoli guide ai comandi per Linux. Essa copre praticamente ogni singolo comando di cui potreste mai aver bisogno.<br />
<br />
* Yaghmour, Karim. ''Building Embedded Linux Systems'' (O’Reilly), 2003.<br/>Questo libro, sebben principalmente rivolto agli sviluppatori di sistemi Linux embedded, contiene un'ottima sezione relativa a come creare una ''toolchain'' e un kernel con compilazione incrociata. Oltre a questa sezione del libro, è consigliato anche in virtù di altre sezioni che forniscono interessanti informazioni per coloro che vogliono imparare come personalizzare il kernel e il resto del sistema.<br />
<br />
=== Libri inerenti il kernel Linux ===<br />
<br />
Molti di questi libri sono indirizzati ai programmatori interessati ad apprendere come programmare all'interno del kernel. Sono generalmente molto tecnici rispetto a questo libro, ma sono un ottimo punto di partenza se desiderate imparare e capire il codice che governa il kernel.<br />
<br />
*Jonathan Corbet, Alessandro Rubini, e Greg Kroah-Hartman. ''Linux Device Drivers'' (O’Reilly), 2005.<br/>Questo libro illustra come differenti ''device driver'' operano e fornisce parecchi esempi applicatici di driver funzionanti. &Egrave; consigliato a chiunque vuole programmare driver per il kernel. &Egrave; disponibile in rete gratuitamente a questo indirizzo: http://lwn.net/Kernel/LDD3/<br />
<br />
* Love, Robert. ''Linux Kernel Development'' (Novell Press Publishing), 2005.<br/> Questo libro copre quasi tutti gli aspetti relativi al kernel Linux, illustrando come tutto opera insieme. Ottimo punto di partenza per iniziare a capire e conoscere le diverse componenti del kernel.<br />
<br />
* Bovet, Daniel P. e Cesate, Marco. ''Understanding the Linux Kernel'' (O’Reilly), 2005.<br/> Questo libro si addentra negli aspetti relativi la progettazione e implementazione del nucleo del kernel Linux. Un ottimo riferimento per apprendere e capire gli algoritmi utilizzati nelle diverse porzioni del kernel. Fortemente consigliato a coloro che vogliono comprendere nel dettaglio come funziona il kernel.<br />
<br />
== Strumenti ==<br />
<br />
In questo libro sono stati menzionati molti utili strumenti. Di seguito, presento un elenco dei siti dove è possibile reperire e scaricare tali strumenti.<br />
<br />
* ''Linux kernel''<br/> http://www.kernel.org e ftp://ftp.kernel.org contiene tutte le versioni del sorgente del kernel. http://www.kernel.org/git/ contiene una lista di tutti i ''git trees'' utilizzati dai diversi sviluppatori del kernel.<br />
<br />
* ''gcc''<br>http://gcc.gnu.org/ sito principale per tutto ciò che concerne il compilatore GNU C. <br />
<br />
* ''binutils''<br/>http://www.gnu.org/software/binutils/ è il sito principale dove trovare tutte le informazioni su binutils.<br />
<br />
* ''make''<br/>http://www.gnu.org/software/make/ è il sito principale dove trovare tutte le informazioni su make.<br />
<br />
*''util-linux''<br/>http://www.kernel.org/pub/linux/utils/util-linux/ è la directory da dove possono essere scaricate tutte le versioni di util-linux.<br />
<br />
* ''module-init-tools''<br/>http://www.kernel.org/pub/linux/utils/kernel/module-init-tools/ è la directory da dove possono essere scaricate tutte le versioni di module-init-tools.<br />
<br />
* ''e2fsprogs''<br/>http://e2fsprogs.sourceforge.net/ è la pagina principale del progetto e2fsprogs.<br />
<br />
* ''jfsutils''<br/>http://jfs.sourceforge.net/ è la pagina principale del progetto jfsutils.<br />
<br />
* ''reiserfsprogs''<br/>http://www.namesys.com/download.html è la pagina principale del progetto reiserfsprogs.<br />
<br />
* ''xfsprogs''<br/>http://oss.sgi.com/projects/xfs/ è la pagina principale del progetto xfsprogs.<br />
<br />
* ''quota-tools''<br/>http://sourceforge.net/projects/linuxquota/ è la pagina principale del progetto quota-tools.<br />
<br />
* ''nfs-utils''<br/>http://nfs.sf.net/ è la pagina principale del progetto nfs-utils.<br />
<br />
* ''udev''<br/>http://www.kernel.org/pub/linux/utils/kernel/hotplug/udev.html è la directory da dove possono essere scaricate tutte le versioni di udev.<br />
<br />
* ''procfs''<br/>http://procps.sourceforge.net/ è la pagina principale del progetto procfs.<br />
<br />
* ''patchutils''<br/>http://cyberelk.net/tim/patchutils è la directory da dove possono essere scaricate tutte le versioni di patchutils.<br />
<br />
* ''git''<br/>http://git.or.cz/ è il sito principale del progetto git.<br />
<br />
* ''ketchup''<br/>http://www.selenic.com/ketchup/ è la pagina principale del progetto ketchup.<br />
<br />
* ''quilt''<br/>http://savannah.nongnu.org/projects/quilt è la pagina principale del progetto quilt.<br />
<br />
* ''distcc''<br/>http://distcc.samba.org/ è la pagina principale del progetto distcc.<br />
<br />
* ''ccache''<br/>http://ccache.samba.org/ è la pagina principale del progetto ccache.<br />
<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Bibliografia&diff=14813LKN: Bibliografia2007-06-15T09:42:44Z<p>TheNoise: piccola correzione</p>
<hr />
<div>__TOC__<br />
<br />
Molte delle informazioni contenute in questo libro sono state estratte dalla documentazione del kernel e dal codice sorgente. Questa [la documentazione inclusa nel kernel, NdT] è il miglior posto dove trovare informazioni e riferimenti su come compilare e installare il kernel ed è usualmente tenuta aggiornata a seguito di cambiamenti nella procedura di compilazione.<br />
<br />
== Libri ==<br />
Sono disponibili molti ottimi libri relativi alla programmazione del kernel di Linux, ma solo pochi di essi trattano la compilazione e installazione del kernel. Ecco una lista di libri che ho trovato utili.<br />
<br />
=== Libri generici su Linux ===<br />
<br />
* Ellen Siever,Aaron Weber,Stephen Figgins,Robert Love,and Arnold Robbins. ''Linux in a Nutshell'' (O’Reilly), 2005.<br/>Questo libro comprende una delle più complete e autorevoli guide ai comandi per Linux. Essa copre praticamente ogni singolo comando di cui potreste mai aver bisogno.<br />
<br />
* Yaghmour, Karim. ''Building Embedded Linux Systems'' (O’Reilly), 2003.<br/>Questo libro, sebben principalmente rivolto agli sviluppatori di sistemi Linx embedded, contiene un'ottima sezione relativa a come costruire una ''cross-compiler toolchain'' ed un kernel. Oltre a questa sezione del libro, è raccomandato anche in virtù di altre sezioni che forniscono interessanti informazioni per coloro che vogliono imparare come personalizzare il kernel e il resto del sistema.<br />
<br />
=== Libri inerenti il kernel di Linux ===<br />
<br />
Molti di questi libri sono indirizzati ai programmatori interessati ad apprendere come programmare all'interno del kernel. Sono generalmente molto tecnici rispetto a questo libro, ma sono un ottimo punto di partenza se desiderate imparare e capire il codice che controlla il kernel.<br />
<br />
*Jonathan Corbet,Alessandro Rubini,and Greg Kroah-Hartman. ''Linux Device Drivers'' (O’Reilly), 2005.<br/>Questo libro illustra come differenti ''device driver'' operano e fornisce parecchi esempi applicatici di driver funzionanti. &Egrave; raccomandato a chiunque vuole programmare driver per il kernel. &Egrave; disponibile in rete gratuitamente a questo indirizzo: http://lwn.net/Kernel/LDD3/<br />
<br />
* Love, Robert. ''Linux Kernel Development'' (Novell Press Publishing), 2005.<br/> Questo libro copre quasi tutti gli aspetti relativi al kernel di Linux, illustrando come tutto opera insieme. Ottimo punto di partenza per iniziare a capire e conoscere le diverse componenti del kernel.<br />
<br />
* Bovet,Daniel P. and Cesate,Marco. ''Understanding the Linux Kernel'' (O’Reilly), 2005.<br/> Questo libro si addentra negli aspetti relativi la progettazione e implementazione del nucleo del kernel di Linux. Un ottimo riferimento per apprendere e capire gli algoritmi utilizzati nelle diverse porzioni del kernel. Fortemente raccomandato a coloro che vogliono comprendere nel dettaglio come funziona il kernel.<br />
<br />
== Tool ==<br />
<br />
In questo libro sono stati menzionati molti utili strumenti. Di seguito, presento una lista dei siti dove è possibile reperire e scaricare tali strumenti.<br />
<br />
* ''Linux kernel''<br/> http://www.kernel.org e ftp://ftp.kernel.org contiene tutte le versioni del sorgente del kernel. http://www.kernel.org/git/ contiene una lista di tutti i ''git trees'' utilizzati dai diversi sviluppatori del kernel.<br />
<br />
* ''gcc''<br>http://gcc.gnu.org/ sito principale per tutto ciò che concerne il compilatore GNU C. <br />
<br />
* ''binutils''<br/>http://www.gnu.org/software/binutils/ è il sito principale dove trovare tutte le informazioni su binutils.<br />
<br />
* ''make''<br/>http://www.gnu.org/software/make/ è il sito principale dove trovare tutte le informazioni su make.<br />
<br />
*''util-linux''<br/>http://www.kernel.org/pub/linux/utils/util-linux/ è la directory da dove possono essere scaricate tutte le versioni di util-linux.<br />
<br />
* ''module-init-tools''<br/>http://www.kernel.org/pub/linux/utils/kernel/module-init-tools/ è la directory da dove possono essere scaricate tutte le versioni di module-init-tools.<br />
<br />
* ''e2fsprogs''<br/>http://e2fsprogs.sourceforge.net/ è la pagina principale del progetto e2fsprogs.<br />
<br />
* ''jfsutils''<br/>http://jfs.sourceforge.net/ è la pagina principale del progetto jfsutils.<br />
<br />
* ''reiserfsprogs''<br/>http://www.namesys.com/download.html è la pagina principale del progetto reiserfsprogs.<br />
<br />
* ''xfsprogs''<br/>http://oss.sgi.com/projects/xfs/ è la pagina principale del progetto xfsprogs.<br />
<br />
* ''quota-tools''<br/>http://sourceforge.net/projects/linuxquota/ è la pagina principale del progetto quota-tools.<br />
<br />
* ''nfs-utils''<br/>http://nfs.sf.net/ è la pagina principale del progetto nfs-utils.<br />
<br />
* ''udev''<br/>http://www.kernel.org/pub/linux/utils/kernel/hotplug/udev.html è la directory da dove possono essere scaricate tutte le versioni di udev.<br />
<br />
* ''procfs''<br/>http://procps.sourceforge.net/ è la pagina principale del progetto procfs.<br />
<br />
* ''patchutils''<br/>http://cyberelk.net/tim/patchutils è la directory da dove possono essere scaricate tutte le versioni di patchutils.<br />
<br />
* ''git''<br/>http://git.or.cz/ è il sito principale del progetto git.<br />
<br />
* ''ketchup''<br/>http://www.selenic.com/ketchup/ è la pagina principale del progetto ketchup.<br />
<br />
* ''quilt''<br/>http://savannah.nongnu.org/projects/quilt è la pagina principale del progetto quilt.<br />
<br />
* ''distcc''<br/>http://distcc.samba.org/ è la pagina principale del progetto distcc.<br />
<br />
* ''ccache''<br/>http://ccache.samba.org/ è la pagina principale del progetto ccache.<br />
<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Bibliografia&diff=14812LKN: Bibliografia2007-06-15T09:39:43Z<p>TheNoise: typos</p>
<hr />
<div>__TOC__<br />
<br />
Molte delle informazioni contenute in questo libro sono state estratte dalla documentazione del kernel e dal codice sorgente. Questo capitolo è il miglior posto dove trovare informazioni e riferimenti su come compilare e installare il kernel ed è usualmente tenuto aggiornato a seguito di cambiamenti nella procedura di compilazione.<br />
<br />
== Libri ==<br />
Sono disponibili molti ottimi libri relativi alla programmazione del kernel di Linux, ma solo pochi di essi trattano la compilazione e installazione del kernel. Ecco una lista di libri che ho trovato utili.<br />
<br />
=== Libri generici su Linux ===<br />
<br />
* Ellen Siever,Aaron Weber,Stephen Figgins,Robert Love,and Arnold Robbins. ''Linux in a Nutshell'' (O’Reilly), 2005.<br/>Questo libro comprende una delle più complete e autorevoli guide ai comandi per Linux. Essa copre praticamente ogni singolo comando di cui potreste mai aver bisogno.<br />
<br />
* Yaghmour, Karim. ''Building Embedded Linux Systems'' (O’Reilly), 2003.<br/>Questo libro, sebben principalmente rivolto agli sviluppatori di sistemi Linx embedded, contiene un'ottima sezione relativa a come costruire una ''cross-compiler toolchain'' ed un kernel. Oltre a questa sezione del libro, è raccomandato anche in virtù di altre sezioni che forniscono interessanti informazioni per coloro che vogliono imparare come personalizzare il kernel e il resto del sistema.<br />
<br />
=== Libri inerenti il kernel di Linux ===<br />
<br />
Molti di questi libri sono indirizzati ai programmatori interessati ad apprendere come programmare all'interno del kernel. Sono generalmente molto tecnici rispetto a questo libro, ma sono un ottimo punto di partenza se desiderate imparare e capire il codice che controlla il kernel.<br />
<br />
*Jonathan Corbet,Alessandro Rubini,and Greg Kroah-Hartman. ''Linux Device Drivers'' (O’Reilly), 2005.<br/>Questo libro illustra come differenti ''device driver'' operano e fornisce parecchi esempi applicatici di driver funzionanti. &Egrave; raccomandato a chiunque vuole programmare driver per il kernel. &Egrave; disponibile in rete gratuitamente a questo indirizzo: http://lwn.net/Kernel/LDD3/<br />
<br />
* Love, Robert. ''Linux Kernel Development'' (Novell Press Publishing), 2005.<br/> Questo libro copre quasi tutti gli aspetti relativi al kernel di Linux, illustrando come tutto opera insieme. Ottimo punto di partenza per iniziare a capire e conoscere le diverse componenti del kernel.<br />
<br />
* Bovet,Daniel P. and Cesate,Marco. ''Understanding the Linux Kernel'' (O’Reilly), 2005.<br/> Questo libro si addentra negli aspetti relativi la progettazione e implementazione del nucleo del kernel di Linux. Un ottimo riferimento per apprendere e capire gli algoritmi utilizzati nelle diverse porzioni del kernel. Fortemente raccomandato a coloro che vogliono comprendere nel dettaglio come funziona il kernel.<br />
<br />
== Tool ==<br />
<br />
In questo libro sono stati menzionati molti utili strumenti. Di seguito, presento una lista dei siti dove è possibile reperire e scaricare tali strumenti.<br />
<br />
* ''Linux kernel''<br/> http://www.kernel.org e ftp://ftp.kernel.org contiene tutte le versioni del sorgente del kernel. http://www.kernel.org/git/ contiene una lista di tutti i ''git trees'' utilizzati dai diversi sviluppatori del kernel.<br />
<br />
* ''gcc''<br>http://gcc.gnu.org/ sito principale per tutto ciò che concerne il compilatore GNU C. <br />
<br />
* ''binutils''<br/>http://www.gnu.org/software/binutils/ è il sito principale dove trovare tutte le informazioni su binutils.<br />
<br />
* ''make''<br/>http://www.gnu.org/software/make/ è il sito principale dove trovare tutte le informazioni su make.<br />
<br />
*''util-linux''<br/>http://www.kernel.org/pub/linux/utils/util-linux/ è la directory da dove possono essere scaricate tutte le versioni di util-linux.<br />
<br />
* ''module-init-tools''<br/>http://www.kernel.org/pub/linux/utils/kernel/module-init-tools/ è la directory da dove possono essere scaricate tutte le versioni di module-init-tools.<br />
<br />
* ''e2fsprogs''<br/>http://e2fsprogs.sourceforge.net/ è la pagina principale del progetto e2fsprogs.<br />
<br />
* ''jfsutils''<br/>http://jfs.sourceforge.net/ è la pagina principale del progetto jfsutils.<br />
<br />
* ''reiserfsprogs''<br/>http://www.namesys.com/download.html è la pagina principale del progetto reiserfsprogs.<br />
<br />
* ''xfsprogs''<br/>http://oss.sgi.com/projects/xfs/ è la pagina principale del progetto xfsprogs.<br />
<br />
* ''quota-tools''<br/>http://sourceforge.net/projects/linuxquota/ è la pagina principale del progetto quota-tools.<br />
<br />
* ''nfs-utils''<br/>http://nfs.sf.net/ è la pagina principale del progetto nfs-utils.<br />
<br />
* ''udev''<br/>http://www.kernel.org/pub/linux/utils/kernel/hotplug/udev.html è la directory da dove possono essere scaricate tutte le versioni di udev.<br />
<br />
* ''procfs''<br/>http://procps.sourceforge.net/ è la pagina principale del progetto procfs.<br />
<br />
* ''patchutils''<br/>http://cyberelk.net/tim/patchutils è la directory da dove possono essere scaricate tutte le versioni di patchutils.<br />
<br />
* ''git''<br/>http://git.or.cz/ è il sito principale del progetto git.<br />
<br />
* ''ketchup''<br/>http://www.selenic.com/ketchup/ è la pagina principale del progetto ketchup.<br />
<br />
* ''quilt''<br/>http://savannah.nongnu.org/projects/quilt è la pagina principale del progetto quilt.<br />
<br />
* ''distcc''<br/>http://distcc.samba.org/ è la pagina principale del progetto distcc.<br />
<br />
* ''ccache''<br/>http://ccache.samba.org/ è la pagina principale del progetto ccache.<br />
<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Indice_Guide&diff=14785Indice Guide2007-06-14T14:53:08Z<p>TheNoise: /* Modem Ethernet */ spostata descrizione in pagina separata</p>
<hr />
<div></div>TheNoisehttps://guide.debianizzati.org/index.php?title=Python_e_Vim&diff=14765Python e Vim2007-06-09T11:28:10Z<p>TheNoise: /* Tips and Tricks */</p>
<hr />
<div>Questa pagina raccoglie piccoli suggerimenti per sfruttare al meglio [http://www.vim.org/ Vim] e gVim con il linguaggio di programmazione [http://www.python.org/ Python].<br />
<br />
== Syntax Higlight ==<br />
La prima funzione che generalmente si abilita quando si usa un editor per programmazione è il ''syntax highlight''.<br />
<br />
Per abilitarlo in Vim per i vari linguaggi (incluso pyton) è sufficiente decommentare in<tt>/etc/vim/vimrc</tt> la riga:<br />
<br />
syntax on <br />
<br />
<br />
== Gestire l'indentazione: TAB, spazi e ''autoindent'' ==<br />
In python è di vitale importanza gestire correttamente l'indentazione dato che (a differenza dei linguaggi ''free-form'' come C) questa è parte integrante della sintassi.<br />
<br />
Il python di per se riconosce ogni tipo di indentazione (TAB, spazi, o un mix dei due). Nei moderni sistemi il TAB ha tuttavia una larghezza variabile ed impostabile a piacere. Per evitare dunque problemi di interoperabilità tra persone che usano convezione diverse è universalmente consigliato di usare nei file di codice python solamente spazi oppure solamente TAB. Anche l'uso esclusivo di TAB può talvolta creare dei problemi di visualizzazione (e quindi difficoltà di lettura) a causa di una diversa larghezza usata. Per tagliare la testa al toro, dunque, il modo più robusto e portabile di programmare in python è quello di usare soltanto spazi. &Egrave; possibile impostare qualsiasi editor per programmazione in modo da sostituire automaticamente al TAB un numero di spazi pari alla larghezza dell'indentazione, e ovviamente anche Vim non è da meno. La larghezza per una unità di indentazione usata quasi universalmente in python è pari ad una larghezza di 4 spazi. Per ricapitolare il nostro scopo è ottenere:<br />
<br />
* Sostituzione alla pressione del tasto TAB con un numero equivalente di spazi<br />
* Larghezza indentazione pari a 4 spazi.<br />
<br />
Per ottenere questo comportamento in Vim/gVim si può inserire il seguente codice nel file di configurazione <tt>/etc/vim/vimrc</tt>:<br />
<br />
filetype plugin indent on<br />
autocmd FileType python setlocal sw=4 sts=4 et tw=78 sta<br />
<br />
La prima riga abilita l'indentazione automatica per i vari linguaggi di programmazione. In particolare per il python, se ad esempio dichiariamo una funzione su una riga, andando a capo avremo già il cursore indentato per poter scrivere il corpo della funzione con la giusta indenzatione. Stessa cosa vale per i vari <tt>'''if'''</tt>, <tt>'''for'''</tt>, ecc... Questa funzione è utile anche per accorgersi di errori sintattici come la mancanza dei :, poichè la loro assenza fa si che il cursore non venga indentato.<br />
<br />
La seconda riga associa ai tipi di file python le seguenti impostazioni:<br />
<br />
;<tt>tabstop</tt> oppure <tt>ts</tt>: larghezza del ''carattere TAB'', quando incontrato nel file. Noi non useremo ''caratteri TAB'' quindi questa impostazione può essere ignorata (e non è riportata infatti nell'esempio precendente). Viene elencata qui solo per chiarezza e completezza.<br />
<br />
;<tt>expandtab</tt> oppure <tt>et</tt>: riempe con spazi le indentazioni generate dalla pressione del tasto TAB.<br />
<br />
;<tt>softtabstop</tt> oppure <tt>sts</tt>: larghezza di un rientro causato dalla pressione di un TAB. Il rientro è creato inserendo spazi se <tt>'''et'''</tt> è settato, altrimenti viene usata una combinazione di spazi e caratteri TAB (questi ultimi hanno larghezza <tt>'''ts'''</tt>).<br />
<br />
;<tt>shiftwidth</tt> oppure <tt>sw</tt>: larghezza di un rientro dell'indentazione automatica. &Egrave; usato anche per definire la larghezza del rientro che si aggiunge o toglie ad un blocco di testo quando si seleziona (con '''v''') e poi si indenta/deindenta con '''>''' o con '''<'''.<br />
<br />
;<tt>smarttab</tt> oppure <tt>sta</tt>: In combinazione con le opzioni precendenti questa impostazione permette di cancellare un rientro (4 spazi ''reali ''nel nostro caso) con una sola pressione del tasto '''BS''' (o '''BackSpace''').<br />
<br />
<br />
== Folding: le piegature nel codice ==<br />
Una funzione comoda durante la programmazione è la possibilità di ripiegare del codice (ad esempio una funzione o una classe) in modo di avere una visione più compatta del file e facilitare la navigazione.<br />
<br />
Questo è possibile in Vim tramite il ''folding'' (''piegature''). Esistono dei plugin per Vim che riconoscono le strutture sintattiche del python e creano automaticamente le piegature. Tuttavia il metodo illustrato di seguito è ancora più semplice: piegature automatiche in base all'indentazione. Nel caso del python questo semplice metodo è particolarmente efficace. <br />
<br />
Per abilitarlo basta inserire in <tt>/etc/vim/vimrc</tt>:<br />
<br />
set foldmethod=indent<br />
<br />
Di seguito sono elencati i principali comandi per gestire le piegature:<br />
<br />
;zo oppure Spazio: apre la piegature sotto il cursore (un solo livello)<br />
;zO: apre la piegature sotto il cursore e ricorsivamente tutte le piegature in essa contenute<br />
;zc: chiude la piegatura alla quale appartiene il blocco di codice indicato dal cursore (un solo livello)<br />
;zC: chiude la piegatura alla quale appartiene il blocco di codice indicato dal cursore e ricorsivamente tutte le piegature che la contengono<br />
;zr: apre tutte le piegature del file corrente di un livello<br />
;zR: apre completamente le piegature contenute nel file corrente (tutti i livelli)<br />
;zm: chiude tutte le piegature del file corrente di un livello<br />
;zM: chiude completamente le piegature contenute nel file corrente (tutti i livelli)<br />
<br />
<br />
== Eseguire python da Vim ==<br />
Vim possiede caratteristiche avanzate che permettono di impostare i compilatori da usare per ogni linguaggio e il metodo di esecuzione del <code>make</code>.<br />
<br />
Nel caso del python propongo una soluzione ''quick and dirty'' che associa ad un tasto l'esecuzione dello script.<br />
<br />
Aggiungendo nell'ormai famoso <tt>/etc/vim/vimrc</tt>:<br />
<br />
map <f5> :w<CR>:!python %<CR><br />
<br />
alla pressione del tasto F5 verrà eseguito <tt>python</tt> passando come paramentro il file corrente (indicato da '''%''').<br />
<br />
<br />
== Autocompletamento (aka omnicompletion) e documentazione integrata ==<br />
Dalla versione 7 in Vim è stata inserita una funzione di autocompletamento intelligente per i vari linguaggi simile a quella presente in alcuni degli IDE più avanzati.<br />
<br />
[[image: Python-gvim-7-omnicompletion.png|thumb|Screenshot della funzione di omnicompletion di Vim 7 con linguaggio di programmazione Python.]]<br />
<br />
Per il python questa funzione permette di completare i nomi delle classi dei metodi e degli attributi tramite un comodo menu contestuale. Inoltre viene anche visualizzata contemporaneamente la docstring del metodo o della classe che si stà completando.<br />
<br />
Una immagine vale più di mille parole. Potete notare la funzione di omnicompletion in funzione nello screenshot qui a fianco. Notare come sulla parte superiore della finestra sia apparsa automaticamente la documentazione della classe sulla quale si stà operando l'autocompletamento.<br />
<br />
Per effettuare l'autocompletamento basta premere "CTRL+x o", ma ricordate che è necessaria la versione 7 (o successive) di Vim. &Egrave; opportuno scaricare anche la versione aggiornata del file che gestisce l'autocompletamento in python. Ecco un link:<br />
<br />
* [http://www.vim.org/scripts/script.php?script_id=1542 pythoncomplete.vim]<br />
<br />
A volte è anche comodo effettuare un autocompletamento ''non intelligente'', basato sulle parole presenti nel file corrente. Questo autompletamento si ottiene premendo "CTRL+n". Quest'ultimo metodo può risultare utile per completare nomi di variabili o di funzioni.<br />
<br />
<br />
== Tips and Tricks ==<br />
Alcuni ulteriori consigli nell'uso di Vim:<br />
<br />
# '''Commentare un blocco di codice'''<br />
#* Premere CTRL+v e selezionare le righe di codice interessate<br />
#* premere <tt>'''I'''</tt> (i grande) e digitare il carattere interessato (solitamente #)<br />
#* premere ESC<br />
# '''Indentare e deindentare un blocco di codice'''<br />
#* Premere <tt>'''V</tt>''' (shift + v) ed entrare in Visual Mode<br />
#* Selezionare la parte di codice da in/deindentare<br />
#* Premere <tt>'''></tt>''' per indentare o <tt>'''<</tt>''' per deindentare di 1 TAB<br />
<br />
== Conclusioni ==<br />
Questi sono solo piccoli suggerimenti per programmare in python con Vim. Come al solito, ogni correzione, suggerimento o aggiunta è ben accetto e anzi incoraggiato.<br />
<br />
<br />
== Link ==<br />
* [http://www.vim.org/ Homepage di Vim]<br />
* [http://www.python.org/ Homepage di Python]<br />
* [http://mail.python.org/pipermail/python-list/2005-July/330551.html Folding in Vim (thread su python list)]<br />
<br />
<br />
----<br />
Autore iniziale: [[Utente:TheNoise|~ The Noise]]<br />
<br />
[[Categoria:Desktop]][[Categoria:Tips&Tricks]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Tabella_Software&diff=14756Tabella Software2007-06-02T10:57:16Z<p>TheNoise: /* Programmi Scientifici */ aggiunto matplotlib</p>
<hr />
<div>Questa tabella cerca di riassumere le alternative libere a diffusi programmi proprietari, a prescindere dal sistema operativo sul quale essi girano. <br />
<br />
Vale la pena di notare che moltissimi programmi liberi che funzionano su linux possono funzionare, previa ricompilazione, su MacOSX (che è un sistema unix, proprio come linux) e anche su Windows usando [http://www.cygwin.com Cygwin] (che riproduce un sistema unix), e che spesso è anche possibile trovarli in internet già ricompilati.<br />
<br />
Per rendere la pagina di una qualche utilità è necessario il contributo di molte persone, quindi tutti sono invitati a partecipare mettettendo link a nuove applicazioni oppure scrivendo una breve pagina riassuntiva dedicata ad una particolare programma libero.<br />
<br />
Inizialmente la priorità sarà popolare la tabella, quindi metteremo semplicemente un link alla home page dei progetti liberi. Si potrà poi affiancare al link della homepage un link '''scheda''' che punta all'eventuale pagina del wiki dedicata a quel programma.<br />
<br />
Per ogni proposta, suggerimento o critica usate la pagina di discussione o postate sul forum.<br />
<br />
=Tabella Software=<br />
{| {{Prettytable}} width="100%"<br />
| align="center" | '''Descrizione'''<br />
| align="center" | '''Closed Source'''<br />
| align="center" | '''Free Software'''<br />
<br />
|-<br />
| align="center" colspan="3" |<br />
===Network===<br />
|-<br />
| align="center" | <br />
====Browser Web====<br />
<br />
|[http://www.microsoft.com/ie/ Internet Explorer] {{windows}} {{mac}}<br />
<br />
[http://www.opera.com Opera] {{windows}} {{mac}} {{linux}}<br />
<br />
[http://www.apple.com/safari/ Safari] {{mac}}<br />
<br />
|[http://www.mozilla.org/products/firefox/ Firefox] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
[http://www.kde.org Konqueror] {{linux}} - {{deb}}<br />
<br />
[http://www.gnome.org/projects/epiphany/ Epiphany] {{linux}} - {{deb}}<br />
<br />
[http://www.mozilla.org/ Mozilla] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
[http://www.mozilla.org/products/camino/ Camino] {{mac}}<br />
<br />
[http://www.mozilla.org/projects/seamonkey/ Seamonkey (Suite)] {{windows}} {{mac}} {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
====Client Email====<br />
<br />
| [http://office.microsoft.com Outlook] {{windows}}<br />
<br />
[http://www.microsoft.com/ Outlook Express] {{windows}}<br />
<br />
[http://www.eudora.com/ Eudora] {{windows}}<br />
<br />
[http://www.ritlabs.com/en/products/thebat/ TheBat!] {{windows}}<br />
<br />
[http://www.pmail.com/ Pegasus Mail] {{windows}}<br />
<br />
| [http://www.gnome.org/projects/evolution/ Evolution] -- [[ Software:evolution | scheda ]] {{linux}} - {{deb}}<br />
<br />
[http://www.mozilla.org/projects/thunderbird/ Thunderbird] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
[http://kmail.kde.org/ Kmail] {{linux}} - {{deb}}<br />
<br />
[http://sylpheed.good-day.net/en/ Sylpheed ] {{linux}} {{windows}} - {{deb}}<br />
<br />
[http://www.mutt.org/ Mutt] {{linux}} {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
====Chat====<br />
<br />
| [http://www.mirc.com/ Mirc] {{windows}}<br />
<br />
[http://www.hydrairc.com/ HydraIRC] {{windows}} ''[http://www.hydrairc.com/index.php?page=developers non opensource!].''<br />
<br />
| [http://konversation.kde.org/ Konversation] -- [[Software:konversation | scheda]] {{linux}} - {{deb}}<br />
<br />
[http://www.xchat.org/ Xchat] {{linux}} {{windows}} - {{deb}}<br />
<br />
[http://gaim.sourceforge.net/ Gaim] {{linux}} {{windows}} - {{deb}}<br />
<br />
[http://packages.debian.org/stable/net/ksirc Ksirc] {{linux}} - {{deb}}<br />
<br />
[http://www.kvirc.net/ Kvirc] {{linux}} - {{deb}}<br />
<br />
[http://www.irssi.org/ Irssi] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
====Firewall====<br />
| [http://www.agnitum.com/products/outpost/index.php OutPost] {{windows}}<br />
<br />
[http://www.zonelabs.com ZoneAlarm] {{windows}}<br />
<br />
| [http://www.netfilter.org/ iptables] {{linux}} - {{deb}}<br />
<br />
Frontend per iptables:<br />
<br />
[http://www.simonzone.com/software/guarddog/ Guarddog] {{linux}} - {{deb}}<br />
<br />
[http://kmyfirewall.sourceforge.net/ kmyfirewall] {{linux}} - {{deb}}<br />
<br />
[http://venom.oltrelinux.com/ knetfilter] {{linux}} - {{deb}}<br />
<br />
[http://www.fs-security.com/ Firestarter] {{linux}} - {{deb}}<br />
<br />
[http://www.shorewall.net/ Shorewall] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
====Ftp Client====<br />
| [http://www.cuteftp.com/ CuteFTP] {{windows}}<br />
<br />
| [http://filezilla.sourceforge.net/ Filezilla] {{windows}} <br />
<br />
[http://gftp.seul.org/ gftp] {{linux}} - {{deb}}<br />
<br />
[http://kbear.sourceforge.net/ kbear] {{linux}} - {{deb}}<br />
<br />
[http://kftpgrabber.sourceforge.net/ kftpgrabber] {{linux}} - {{udeb|http://repos.knio.it}} <br />
<br />
<br />
|-<br />
| align="center" |<br />
<br />
====Instant Messaging====<br />
| [http://www.icq.com/ Icq] {{windows}} {{mac}}<br />
<br />
[http://www.msn.it Msn] {{windows}}<br />
<br />
[http://www.mercury.to Mercury] {{linux}} {{windows}} {{mac}}<br />
<br />
| [http://kopete.kde.org/ Kopete] {{linux}} - {{deb}}<br />
<br />
[http://gaim.sourceforge.net/ Gaim] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
[http://amsn.sourceforge.net/ Amsn] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
[http://sim-icq.sourceforge.net/ Sim] {{linux}} - {{deb}}<br />
<br />
[http://www.miranda-im.org/ Miranda] {{windows}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
====News Reader====<br />
<br />
| [http://www.microsoft.com Microsoft Outlook] {{windows}} {{mac}}<br />
<br />
| [http://pan.rebelbase.com/ Pan] {{linux}} {{mac}} {{windows}} - {{deb}}<br />
<br />
[http://knode.sourceforge.net/ Knode] {{linux}} - {{deb}}<br />
<br />
[http://sylpheed.good-day.net/en/ Sylpheed] {{linux}} {{windows}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
====Voip====<br />
<br />
|[http://www.skype.com/ Skype] {{linux}} {{Mac}} {{windows}} <br />
<br />
[http://www.gizmoproject.com/ Gizmo] {{linux}} {{mac}} {{windows}}<br />
<br />
|[http://www.openwengo.com/ OpenWengo] {{linux}} {{Mac}} {{windows}} - {{deb}}<br />
<br />
[http://www.gnomemeeting.org/ Ekiga (ex Gnomemeeting)] {{linux}} {{windows}} - {{deb}}<br />
<br />
[http://www.twinklephone.com/ Twinkle] {{linux}} - {{deb}}<br />
<br />
|- <br />
| align="center" colspan="3" |<br />
<br />
===Multimedia===<br />
<br />
|-<br />
| align="center" colspan="3" |<br />
====Audio====<br />
<br />
|-<br />
| align="center" |<br />
=====Player=====<br />
<br />
| [http://www.winamp.com/ Winamp] {{windows}}<br />
<br />
| [http://coolplayer.sourceforge.net/ CoolPlayer] {{windows}}<br />
<br />
[http://www.xmms.org/ Xmms] {{linux}} - {{deb}}<br />
<br />
[http://www.sosdg.org/~larne/w/BMP_Homepage Beep Media Player] {{linux}} - {{deb}}<br />
<br />
[http://www.zinf.org/ Zinf] {{linux}} - {{windows}} - {{deb}}<br />
<br />
[http://www.rhythmbox.org Rhythmbox] {{linux}} - {{deb}}<br />
<br />
[http://kaffeine.sourceforge.net/ Kaffeine] {{linux}} - {{deb}}<br />
<br />
[http://moc.daper.net/ MOC] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
=====Gestione Raccolte Musicali=====<br />
<br />
| [http://www.apple.com/itunes/ iTunes] {{mac}} {{windows}}<br />
<br />
[http://www.microsoft.com/windows/windowsmedia/ Windows Media Player] {{windows}}<br />
<br />
| [http://www.gnome.org/projects/rhythmbox/ Rhythmbox] (player di default di Gnome) {{linux}} - {{deb}}<br />
<br />
[http://amarok.kde.org/ Amarok] {{linux}} - {{deb}}<br />
<br />
[http://listengnome.free.fr/ Listen] {{linux}} - {{deb}}<br />
<br />
[http://www.sacredchao.net/quodlibet Quod Libet] {{linux}} - {{deb}}<br />
<br />
[http://muine.gooeylinux.org/ Muine] {{linux}} - {{deb}}<br />
<br />
[http://www.last.fm/tools/downloads/ Last FM] {{linux}} - {{windows}} - {{mac}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
=====Gestione dei Tag=====<br />
<br />
| [http://xdev.narod.ru/tagscan_e.htm Tag Scanner] {{windows}}<br />
<br />
| [http://www.sacredchao.net/quodlibet Ex Falso] (parte di Quod Libet) {{linux}} - {{deb}}<br />
<br />
[http://pwp.netcabo.pt/paol/tagtool/ Tagtool] {{linux}} - {{deb}}<br />
<br />
[http://easytag.sourceforge.net/ Easytag] {{linux}} {{windows}} - {{deb}}<br />
<br />
[http://kid3.sourceforge.net/ Kid3] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" colspan="3" |<br />
<br />
====Video====<br />
<br />
|-<br />
| align="center" |<br />
<br />
=====Player=====<br />
<br />
| [http://www.microsoft.com/windows/windowsmedia/ Windows Media Player] {{windows}}<br />
<br />
| [http://www.videolan.org/vlc/ VLC] {{linux}} {{mac}} {{windows}} ''(e molti altri)''<br />
<br />
[http://xinehq.de/ gXine] {{linux}} - {{deb}}<br />
<br />
[http://www.mplayerhq.hu/homepage/design7/news.html MPlayer] {{linux}} {{mac}} {{windows}} - {{udeb|http://debian.video.free.fr/}}<br />
<br />
[http://www.gnome.org/projects/totem/ Totem] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" colspan="3" |<br />
==== Produzione Audio/Musica ====<br />
<br />
|-<br />
| align="center" |<br />
===== Architettura =====<br />
<br />
| Non esiste niente del genere!<br />
<br />
| [http://jackit.sourceforge.net/ JACKit!] {{linux}} {{mac}} - {{deb}}<br />
<br />
[http://qjackctl.sourceforge.net/ qjackctl] (GUI per Jack) {{linux}} {{mac}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
===== Editor Audio =====<br />
<br />
| [http://www.sonymediasoftware.com/ Soundforge] {{windows}}<br />
<br />
[http://www.adobe.com/ Adobe Audition] {{windows}}<br />
<br />
| [http://audacity.sourceforge.net/ Audacity] {{linux}} {{mac}} {{windows}} - {{deb}}<br />
<br />
[http://rezound.sourceforge.net/ Rezound] {{linux}} - {{deb}}<br />
<br />
[http://www.metadecks.org/software/sweep/ Sweep] {{linux}} - {{deb}}<br />
<br />
<br />
|-<br />
| align="center" |<br />
===== Registratori Multitraccia =====<br />
<br />
| Protools {{mac}}<br />
<br />
| [http://ardour.org Ardour] {{linux}} {{mac}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
===== Editor Audio+Midi =====<br />
<br />
| [http://www.steinberg.net/ Cubase] {{Windows}} {{mac}}<br />
<br />
| [http://www.rosegardenmusic.com/ Rosegarden4] {{linux}} - {{deb}}<br />
<br />
[http://www.muse-sequencer.org/ Muse] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
===== Sequencer =====<br />
|<br />
<br />
| [http://www.filter24.org/seq24/ Seq24] {{linux}} - {{Deb}}<br />
<br />
|-<br />
| align="center" |<br />
===== Editor Loop-Based =====<br />
<br />
| [http://www.flstudio.com/ Friuty Loops] {{windows}}<br />
<br />
| [http://lmms.sourceforge.net/ Lmms] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
===== Framework Synth/Effetti =====<br />
<br />
| [http://www.steinberg.net/ VST] {{windows}} {{mac}}<br />
<br />
| [http://dssi.sourceforge.net/ DSSI] {{linux}} - {{deb}}<br />
<br />
[http://www.ladspa.org/ LADSPA] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
===== Synth =====<br />
|<br />
<br />
| [http://zynaddsubfx.sourceforge.net/ ZynAddSubFX] {{linux}} {{windows}} - {{deb}}<br />
<br />
[http://www.nongnu.org/om-synth/ Om] {{linux}}<br />
<br />
[http://home.jps.net/~musound/whysynth.html WhySynth] {{linux}}<br />
<br />
|-<br />
| align="center" |<br />
===== Notazione =====<br />
<br />
| [http://www.finalemusic.com/ Finale] {{windows}} {{mac}}<br />
<br />
| [http://lilypond.org/web/ Lilypond] {{linux}} - {{deb}}<br />
<br />
[http://denemo.sourceforge.net/ Denemo] {{linux}} - {{deb}}<br />
<br />
[http://noteedit.berlios.de/ NoteEdit] (interfaccia a Lilypond) {{linux}} - {{deb}}<br />
<br />
[http://www.rosegardenmusic.com/ Rosegarden4] (interfaccia a Lilypond) {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" colspan="3" |<br />
<br />
====Grafica====<br />
|-<br />
| align="center" |<br />
<br />
=====Fotoritocco=====<br />
<br />
| [http://www.it.corel.com/servlet/Satellite?pagename=Corel3It/Products/Display&pfid=1047024809736&pid=1047025538464 Paint Shop Pro] {{windows}}<br />
<br />
[http://www.adobe.it/products/photoshop/main.html Adobe PhotoShop] {{windows}} - {{mac}}<br />
<br />
| [http://www.gimp.org/ GIMP] {{windows}} - {{linux}} - {{mac}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
=====Gestione Foto=====<br />
<br />
| [http://picasa.google.com/index.html Picasa] {{windows}} {{linux}}<br />
<br />
[http://www.apple.com/ilife/iphoto/ iPhoto] {{mac}}<br />
<br />
| [http://gthumb.sourceforge.net/ Gthumb] {{linux}} - {{deb}}<br />
<br />
[http://www.digikam.org/ Digikam] {{linux}} - {{deb}}<br />
<br />
[http://gqview.sourceforge.net/ GQview] {{linux}} - {{deb}}<br />
<br />
[http://www.gnome.org/projects/f-spot/ F-Spot] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
=====Vettoriale=====<br />
<br />
| [http://www.it.corel.com/servlet/Satellite?pagename=Corel3It/Products/Display&pfid=1047024809679&pid=1047023175176 CorelDRAW] {{windows}}<br />
<br />
| [http://www.sodipodi.com/ Sodipodi] {{windows}} - {{linux}} - {{deb}}<br />
<br />
[http://www.inkscape.org/ InkScape] {{windows}} - {{linux}} - {{mac}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
=====Immagini RAW=====<br />
<br />
| ''Vari plugin commerciali''<br />
<br />
| [http://www.cybercom.net/~dcoffin/dcraw/ dcraw] {{linux}} - {{deb}}<br />
<br />
[http://ufraw.sourceforge.net/ UFRaw] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
=====Grafica Tridimensionale=====<br />
<br />
| [http://www.autodesk.com/maya Maya] {{windows}} - {{linux}} - {{mac}}<br />
<br />
[http://www.autodesk.com/3dsmax 3D Studio Max] {{windows}}<br />
<br />
[http://www.rhino3d.com/ Rhinoceros] {{windows}}<br />
<br />
[http://www.newtek.com/lightwave/ Lightwave 3D] {{windows}} - {{mac}}<br />
<br />
[http://www.povray.org/ POV-Ray] {{windows}} - {{linux}} - {{mac}} - {{deb}}<br />
<br />
[http://www.softimage.com/products/xsi/ Softimage XSI] {{windows}} - {{linux}}<br />
<br />
| [http://blender.org/cms/Home.2.0.html Blender] {{windows}} - {{linux}} - {{mac}} - Solaris - Irix - FreeBSD - {{deb}}<br />
<br />
[http://www.k-3d.org/ K-3D] {{windows}} - {{linux}} - {{deb}}<br />
<br />
[http://www.wings3d.com/ Wings 3D] {{windows}} - {{linux}} - {{mac}} - {{deb}}<br />
<br />
[http://www.artofillusion.org/ Art of Illusion] {{windows}} - {{linux}} - {{mac}} - Unix<br />
<br />
|-<br />
| align="center" |<br />
<br />
=====Rendering=====<br />
<br />
| [https://renderman.pixar.com/ RenderMan] {{windows}} - {{mac}}<br />
<br />
[http://www.3delight.com/en/index.php/home 3Delight] {{windows}} - {{linux}} - {{mac}}<br />
<br />
[http://www.autodesk.com/mentalray Mental Ray] {{windows}} - {{linux}} - {{mac}}<br />
<br />
[http://www.chaosgroup.com V-Ray] {{windows}}<br />
<br />
[http://www.finalrender.com/ finalRender] {{windows}}<br />
<br />
[http://www.povray.org/ POV-Ray] {{windows}} - {{linux}} - {{mac}} - {{deb}}<br />
<br />
[http://www.maxwellrender.com/ Maxwell Render] {{windows}} - {{linux}} - {{mac}}<br />
<br />
[http://www.indigorenderer.com/joomla/ Indigo] {{windows}} - con wine {{linux}} <br />
<br />
| [http://www.blender.org/ Blender interno] {{windows}} {{linux}} {{mac}} {{deb}}<br />
<br />
[http://www.yafray.org/ YafRay] {{windows}} {{linux}} {{mac}} {{deb}}<br />
<br />
[http://www.aqsis.org/xoops/ Aqsis] {{windows}} - {{linux}} - {{mac}}<br />
<br />
[http://www.cs.utexas.edu/~okan/Pixie/pixie.htm Pixie] {{windows}} - {{linux}} - {{mac}}<br />
<br />
[http://sunflow.sourceforge.net/ Sunflow] {{windows}} {{linux}} {{mac}}<br />
<br />
<br />
<br />
|-<br />
<br />
| align="center" colspan="3" |<br />
<br />
===Office===<br />
<br />
|-<br />
| align="center" |<br />
====Suite Office====<br />
<br />
| [http://office.microsoft.com/ Microsoft Office] {{windows}} {{mac}}<br />
<br />
[http://www.software602.com/ 602 PC Suite] {{windows}}<br />
<br />
[http://www.sun.com/software/star/staroffice/ StarOffice] {{linux}} {{windows}}<br />
<br />
|<br />
<br />
[http://www.openoffice.org OpenOffice.Org] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
[http://www.koffice.org Koffice] {{linux}} - {{deb}}<br />
<br />
[http://www.gnome.org/gnome-office/ GnomeOffice] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
====Editor di Testi [http://it.wikipedia.org/wiki/WYSIWYG WYSIWYG]====<br />
| [http://office.microsoft.com/ Microsoft Word] {{windows}} {{mac}}<br />
<br />
[http://www.microsoft.com/products/works/default.mspx Microsoft Works] {{windows}}<br />
<br />
| [http://www.abisource.com/ Abiword] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
[http://www.koffice.org Kword] (Parte di Koffice) {{linux}} - {{deb}}<br />
<br />
[http://www.openoffice.org OpenOfficeWriter] (Parte di OpenOffice.Org) {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
====Editor di Testi [http://it.wikipedia.org/wiki/Desktop_Publishing DTP]====<br />
| [http://www.adobe.com/products/pagemaker/main.html Adobe PageMaker] {{windows}} {{mac}}<br />
<br />
[http://www.quark.com/about/contact/international_web_sites.html QuarkXPress] {{windows}} {{mac}}<br />
<br />
| [http://www.lyx.org/ Lyx] {{linux}} {{mac}} {{windows}} - {{deb}}<br />
<br />
[http://www.scribus.org.uk/ Scribus] {{linux}} {{mac}} {{windows}} - {{deb}}<br />
<br />
[http://www.stacken.kth.se/project/pptout/ Passepartout] {{linux}} {{mac}} - {{deb}}<br />
<br />
TeX/LaTeX {{linux}} {{windows}} {{mac}} - {{deb}} [http://www.guit.sssup.it/ GUIT]<br />
<br />
|-<br />
| align="center" |<br />
<br />
====Editor di Testi orientati<br> alla programazione====<br />
|<br />
<br />
|[http://www.kde-apps.org/content/show.php?content=9901 KWrite] (default di KDE) {{linux}} - {{deb}}<br />
<br />
[http://www.gnu.org/software/emacs/emacs.html Emacs] {{linux}} {{windows}} {{mac}} e molti altri - {{deb}}<br />
<br />
[http://www.vim.org/ Vim] {{linux}} {{windows}} {{mac}} e molti altri - {{deb}}<br />
<br />
[http://kate.kde.org/ Kate] {{linux}} - {{deb}}<br />
<br />
[http://www.kdevelop.org/ KDevelop] {{linux}} - {{deb}}<br />
<br />
[http://kile.sourceforge.net/ Kile] {{linux}} - {{deb}}<br />
<br />
[http://www.gnome.org/projects/gedit/ Gedit] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
====Fogli di Calcolo====<br />
| [http://office.microsoft.com/ Microsoft Excel] {{windows}} {{mac}}<br />
<br />
[http://www.microsoft.com/products/works/default.mspx Microsoft Works] {{windows}}<br />
<br />
| [http://www.gnome.org/projects/gnumeric/ Gnumeric] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
[http://www.koffice.org Kspread] (Parte di Koffice) {{linux}} - {{deb}}<br />
<br />
[http://www.openoffice.org OpenOfficeCalc] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
|-<br />
| align="center" colspan="3" |<br />
===Programmi Scientifici===<br />
<br />
|-<br />
| align="center" |<br />
====Matlab====<br />
<br />
| [http://www.mathworks.com/ Matlab] {{linux}} {{windows}} {{mac}}<br />
<br />
| [http://www.octave.org/ Octave] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
[http://scilabsoft.inria.fr Scilab] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
[http://matplotlib.sourceforge.net/ Matplotlib] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
|-<br />
| align="center" colspan="3" |<br />
<br />
=== Utilita'===<br />
|-<br />
| align="center" |<br />
====Backup====<br />
| [http://www.microsoft.com Windows Backup] {{windows}}<br />
<br />
[http://www3.ca.com/solutions/Product.aspx?ID=4536 ARCserve Backup] {{windows}}<br />
<br />
| [http://www.bacula.org Bacula] {{linux}} {{windows}} {{mac}} - {{deb}}<br />
<br />
[http://jr.falleri.free.fr/keep Keep] {{linux}} - {{udeb|http://repos.knio.it}}<br />
<br />
|-<br />
| align="center" |<br />
====File Manager====<br />
| Explorer {{windows}}<br />
<br />
[http://www.ghisler.com/ Total Commander] {{windows}}<br />
<br />
| [http://www.gnome.org/projects/nautilus/ Nautilus] (default di Gnome) {{linux}} - {{deb}}<br />
<br />
[http://www.konqueror.org/ Konqueror] (default di KDE) {{linux}} - {{deb}}<br />
<br />
[http://rox.sourceforge.net/phpwiki/index.php/ROX-Filer ROX-filer] {{linux}} - {{deb}}<br />
<br />
[http://en.wikipedia.org/wiki/Gentoo_file_manager Gentoo] {{linux}} - {{deb}}<br />
<br />
[http://roland65.free.fr/xfe/ Xfe] {{linux}} - {{deb}}<br />
<br />
[http://krusader.sourceforge.net/ Krusader] {{linux}} - {{deb}}<br />
<br />
[http://tuxcmd.sourceforge.net/ Tux-commander] {{linux}}<br />
<br />
[http://www.nongnu.org/gcmd/ Gnome-commander] {{linux}} - {{deb}}<br />
<br />
[http://thunar.xfce.org/index.html Thunar] {{linux}} - {{deb}}<br />
|-<br />
<br />
| align="center" |<br />
====Gestione Filesystem====<br />
| [http://www.symantec.com/home_homeoffice/products/system_performance/pm80/index.html Partition Magic] {{windows}} <br />
<br />
| [ftp://ftp.kernel.org/pub/linux/utils/util-linux/ fdisk] {{linux}} - {{deb}}<br />
<br />
[ftp://ftp.kernel.org/pub/linux/utils/util-linux/ cfdisk] {{linux}} - {{deb}}<br />
<br />
[http://www.gnu.org/software/parted/ parted] {{linux}} - {{deb}}<br />
<br />
[http://qtparted.sourceforge.net/ qtparted] {{linux}} - {{deb}}<br />
<br />
[http://gparted.sourceforge.net/ gparted] {{linux}} - {{deb}}<br />
<br />
|-<br />
<br />
<br />
| align="center" |<br />
====Masterizzazione====<br />
| [http://www.nero.com/ita/index.html Nero Burning Room] {{windows}} {{linux}}<br />
<br />
| [http://www.k3b.org/ K3b] {{linux}} - {{deb}}<br />
<br />
[http://gnomebaker.sourceforge.net/v2/ Gnomebaker] {{linux}} - {{deb}}<br />
<br />
[http://graveman.tuxfamily.org/index.php?l=e Graveman] {{linux}} - {{deb}}<br />
<br />
[http://www.xcdroast.org/ X-CD-roast] {{linux}} - {{deb}}<br />
<br />
|-<br />
| align="center" |<br />
<br />
====Pulizia del Sistema====<br />
| [http://www.symantecstore.com/antivirus/norton-cleansweep-a.htm CleanSweep] {{windows}}<br />
<br />
| [http://www.kde-apps.org/content/show.php?content=28631 Kleansweep] {{linux}} {{udeb|http://repos.knio.it}}<br />
|}<br />
<br />
==Legenda==<br />
Nella tabella sono presenti alcuni simboli, per identificare quali sistemi operativi sono supportati dalle applicazioni:<br />
: {{linux}} Indica che il programma e' compatibile con Linux.<br />
: {{windows}} Indica che il programma e' compatibile con Windows.<br />
: {{mac}} Indica che il programma e' compatibile con MacOs.<br />
<br />
Sono, inoltre, presenti delle swirl, che indicano la presenza dei programmi in formato .deb.<br />
: {{deb}} Indica che il programma e' stato pacchettizzato ed e' presente nei repository ufficiale Debian.<br />
: http://guide.debianizzati.org/images/7/7b/Swirl_gray.png Indica che il programma e' stato pacchettizzato, ma e' presente in un repository non ufficiale. E' inoltre presente un link al repository in cui si trova il pacchetto.</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Old:Desktop_Search_su_Debian_Etch:_Installare_Tracker&diff=14746Old:Desktop Search su Debian Etch: Installare Tracker2007-05-27T20:42:03Z<p>TheNoise: /* Effettuare il Backport */ inserita lista pacchetti (thanks to Diego M.)</p>
<hr />
<div>== Introduzione ==<br />
'''[http://www.gnome.org/projects/tracker/ Tracker]''' (più correttamente '''Meta Tracker''') è una applicazione che consente di effettuare ricerche istantanee (''Desktop Search'') sul contenuto dei file e sui metadati (tag di file musicali o immagini, ecc...). Inoltre consente di aggiungere tag ai propri file in modo da migliorare le ricerche. Tracker è pienamente '''desktop neutrale''' aderendo strettamente a tutti gli standard [http://www.freedesktop.org/wiki/ FreedDesktop.org].<br />
<br />
Al contrario di [http://beagle-project.org/Main_Page Beagle] (che è scritto in [http://www.mono-project.com/Main_Page Mono / C#]), Tracker è scritto in C. Per questo motivo, oltre a richiedere solo pochi MB di ram per il suo funzionamento, Tracker è velocissimo nell'indicizzazione dei file e l'impatto sulle prestazioni desktop è dunque pressoché nullo.<br />
<br />
Tracker include una semplice interfaccia gtk per effettuare le ricerche. Si integra anche con la [http://raphael.slinckx.net/deskbar/ Deskbar Applet] di Gnome (funziona anche su Etch). &Egrave; inoltre possibile ricompilare Nautilus per abilitare il supporto a Tracker. &Egrave; anche possibile integrare Tracker con Konqueror tramite [http://demandiseineseite.gmxhome.de/find/ kio-find].<br />
<br />
Debian Etch non include il pacchetto per Tracker, tuttavia è abbastanza semplice effettuare un [[backport]] del pacchetto per [[testing]] (attualmente alla versione 0.5.4-5).<br />
<br />
== Effettuare il Backport ==<br />
<br />
Il backport di Tracker su Etch non presenta grosse difficoltà. Basta seguire le operazioni descritte in [[Backport da unstable in testing]] anche se in questo caso stiamo facendo un [[backport]] da [[testing]] ad [[unstable]].<br />
<br />
Scarichiamo i file '''DSC''', '''<tt>orig.tar.gz</tt>''', '''<tt>diff.gz</tt>''' dalla [http://packages.debian.org/testing/utils/tracker pagina del pacchetto] ed estraiamo i sorgenti:<br />
<br />
$ dpkg-source -x tracker_0.5.4-5.dsc<br />
<br />
Installiamo le dipendenze necessarie alla compilazione di tracker. In questo caso non possiamo usare <tt>apt-get build-dep</tt> perchè non c'è in etch un versione vecchia dello stesso pacchetto. Installiamo dunque manualmente con [[Aptitude]] le dipendenze. Dobbiamo praticamente installare tutti i rispettivi pacchetti di sviluppo delle dipendenze indicate nella [http://packages.debian.org/testing/utils/tracker pagina del pacchetto tracker].<br />
<br />
Fortunatamente un lettore è stato così gentile da eseguire <tt>apt-get build-dep</tt> su lenny in modo da avere la lista dei pacchetti da installare anche su etch. Ecco i pacchetti di sviluppo da installare:<br />
<br />
<pre><br />
build-essential cdbs g++ libart-2.0-dev libatk1.0-dev libaudiofile-dev libavahi-client-dev <br />
libavahi-common-dev libavahi-glib-dev libbonobo2-dev libbonoboui2-dev libbz2-dev libcairo2-dev <br />
libdbus-1-dev libdbus-glib-1-dev libesd0-dev libexif-dev libgconf2-dev libglade2-dev libglib2.0-dev <br />
libgmime-2.0-2 libgmime-2.0-2-dev libgnome-desktop-2 libgnome-desktop-dev libgnome-keyring-dev <br />
libgnome2-dev libgnomecanvas2-dev libgnomeui-dev libgnomevfs2-dev libgsf-1-dev libgstreamer0.10-dev <br />
libgtk2.0-dev libidl-dev libmagic-dev liborbit2-dev libpango1.0-dev libpoppler-dev libpoppler-glib-dev <br />
libpoppler0c2 libpoppler0c2-glib libsqlite3-dev libstartup-notification0-dev libxml-parser-perl libxml2-dev<br />
</pre><br />
<br />
Le dipendenze runtime da installare sono invece i seguenti pacchetti: <tt>o3read poppler-utils untex unzip w3m wv xsltproc</tt>.<br />
<br />
Per verificare di aver installato tutti i supporti (mp3, jpeg, ...) potete scompattare i sorgenti in una directory temporanea e da li eseguire il classico <tt>./configure</tt> che vi indicherà cosa manca. <br />
<br />
Finito di installare i pacchetti necessari, per creare i deb basta entrare nella dir dei sorgenti (<tt>tracker-0.5.4</tt>) ed eseguire:<br />
<br />
$ fakeroot dpkg-buildpackage<br />
<br />
Fatto ciò nella cartella superiore avremo tutti i pacchetti deb compilati e pronti per essere installati con il classico:<br />
<br />
# dpkg -i *.deb<br />
<br />
== Usare Tracker ==<br />
A questo punto abbiamo tutto installato. Possiamo fare partire Tracker semplicemente con il comando '''<tt>trackerd</tt>'''. Il file di configurazione <tt>~/.Tracker/tracker.cfg</tt> ci permette di selezionare cartelle aggiuntive oltre alla Home da tenere sott'occhio e cartelle da escludere. Assicuriamoci inoltre che il nostro Desktop Environment lanci <tt>trackerd</tt> ad ogni avvio (per Gnome dovrebbe essere automatico).<br />
<br />
{{Warningbox|Nella versione attuale l'indicizzazione delle mail non funziona ancora anche se sono presenti voci nel file di configurazione per attivarla.}}<br />
<br />
L'interfaccia gtk per la ricerca si chiama '''<tt>tracker-search-tool</tt>'''. C'è anche una comoda interfaccia testuale chiamata '''<tt>tracker-search</tt>'''.<br />
<br />
<br />
Buona ricerca ;-)<br />
<br />
<br />
== Riferimenti ==<br />
<br />
* [http://www.gnome.org/projects/tracker/documentation.html Meta Tracker Documentation]<br />
* [[Backport da unstable in testing]]<br />
* [http://www.freedesktop.org/wiki/ FreeDesktop.org]<br />
<br />
<br />
----<br />
<br />
Autore: [[Utente:TheNoise|~ The Noise]] 14:12, 9 Mag 2007 (CDT)<br />
<br />
[[Categoria:Desktop]][[Categoria:Tips&Tricks]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Old:Low-latency_2.6_kernel_per_applicazioni_audio_realtime&diff=14738Old:Low-latency 2.6 kernel per applicazioni audio realtime2007-05-23T12:10:20Z<p>TheNoise: typos</p>
<hr />
<div>== Introduzione ==<br />
Questa è una breve guida su come configurare il sistema per poter eseguire applicazioni audio realtime.<br />
<br />
Per chi non conoscesse il mondo dell'audio professionale su GNU/Linux consiglio questo magnifico sito introduttivo:<br />
<br />
* [http://www.emillo.net/audio_midi emillo.net]<br />
<br />
Ci sono '''due passi''' distinti illustrati nella guida: ''il primo'' è patchare un kernel 2.6 con la patch '''realtime-preemption''' di ''Ingo Molnar'' per ottenere un kernel con la più bassa latenza possibile; ''il secondo'' è invece permettere a normali utenti l'esecuzione di applicazioni in modalità realtime.<br />
<br />
Il kernel 2.6 ha raggiunto ormai delle prestazioni molto buone per quanto riguarda la latenza (anni luce avanti rispetto al 2.4). Normalmente è dunque sufficiente configurare il sistema per permettere ai normali utenti di eseguire applicazioni realtime (''secondo passo'').<br />
<br />
Se invece, si vuole non solo ridurre sotto la soglia (indicativa) dei ~ 5 ms la latenza minima ottenibile, ma soprattutto, aumentare notevolmente l'affidabilità del sistema nel rispettare le basse latenze bisogna usare la patch realtime-preemption (''primo passo''). E' questo il caso, ad esempio, se si vuole lavorare in full-duplex su diverse tracce in realtime, ''senza correre il rischio di xrun'' (ovvero interruzioni del flusso audio). Oppure se si vuole suonare un sintetizzatore software usando la minima latenza possibile.<br />
<br />
La patch realtime-preemption (per quanto perfettamente usabile) continua ad essere sviluppata incessantemente, e le release sono spesso giornaliere. Il kernel a cui si applica la patch è sempre l'ultimo kernel stabile o, spesso, l'ultimo RC. Nella guida, a puro titolo esemplificativo, mi riferirò ad un kernel e ad una versione di patch specifica, anche se queste versioni diventeranno presto obsolete. <br />
<br />
{{Warningbox|Se non siete a vostro completo agio a compilare e patchare il kernel questa non è la via che fa per voi. Consiglio, in tal caso, di usare un setup per l'audio professionale pronto per l'uso, come la distribuzione [http://64studio.com/ 64 Studio] (disponibile sia per processori 64 bit che per 32bit). Se volete invece informazioni dettagliate su come compilare il kernel alla ''debian-way'': [[Debian Kernel Howto]]. }}<br />
<br />
== Dal kernel stabile all'RC ==<br />
Consiglio di compilare l'ultima versione stabile del kernel, configurandola e testandola fino ad ottenere una configurazione ben funzionante. Come spunto potete usare [[Esempio configurazione kernel|questa configurazione]]. Nel mio caso ho usato il kernel 2.6.13.2 e la [[Debian Kernel Howto|debian-way]] di compilare il kernel. <br />
<br />
Una guida completa sulla configurazione e l'ottimizzazione di un [[kernel vanilla]] (e non solo) per applicazioni audio è la seguente: <br />
<br />
* [http://demudi.agnula.info/wiki/Low-latencyKernelBuildingHowto Low-latency Kernel Building Howto].<br />
<br />
La patch realtime-preemption più recente si applica solitamente ai kernel RC (Release Candidate). Questo perché Ingo Molnar segue sempre il kernel più recente (quindi usa le RC come base di partenza per la sua patch). Quando viene rilasciato un nuovo kernel stabile Ingo Molnar rilascia pach per il nuovo kernel stabile, ma dopo alcune settimane passa nuovamente a seguire l'ultima RC uscita nel frattempo. <br />
<br />
Quindi, si hanno due possibilità:<br />
# compilare l'ultimo kernel stabile con l'ultima patch rilasciata per quel kernel<br />
# compilare l'ultimo kernel rc e usare la versione corrente della pacth.<br />
<br />
Attualmente, ad esempio, l'ultimo kernel stabile, per il quale sia stata rilasciata la patch realtime preemption è il [ftp://ftp.it.kernel.org/pub/linux/kernel/v2.6/linux-2.6.14.tar.bz2 2.6.14] (non i successivi 2.6.14.x). Per tale kernel l'ultima patch disponibile è la [http://people.redhat.com/mingo/realtime-preempt/older/patch-2.6.14-rt22 2.6.14-rt22], come si può vedere [http://people.redhat.com/mingo/realtime-preempt/older/ qui].<br />
<br />
Se invece si vuole usare l'[http://people.redhat.com/mingo/realtime-preempt/ ultima patch] realtime-preemption (attualmente 2.6.15-rc5-rt2) bisogna usare anche l'[ftp://ftp.it.kernel.org/pub/linux/kernel/v2.6/testing/ ultimo kernel RC]. <br />
<br />
Per passare da un kernel stabile ad un RC basta fare un <tt>make oldconfig</tt> in modo da configurare solo le nuove voci. Questo metodo "a due passi" permette di separare i problemi dovuti ad un eventuale errore di configurazione del kernel stabile dai problemi potenzialmente introdotti dall'uso di un kernel RC non stabile.<br />
<br />
== La patch realtime-preemption ==<br />
L'archivio delle patch realtime-premption si trova a [http://people.redhat.com/mingo/realtime-preempt/ questo indirizzo]. La patch realtime-preemption usata di seguito (a puro titolo esemplificativo) è la 2.6.14-rc5-rt5, voi usate la versione più recente disponibile. La patch è un semplice file di testo. Il suo nome è del tipo <tt>patch-''<kernel version>''-''<patch version>''</tt>. Bisogna applicare la patch all'esatta versione del kernel indicata dal nome. Di seguito viene usata la [http://people.redhat.com/mingo/realtime-preempt/older/patch-2.6.14-rc5-rt5 versione rt5 applicata al kernel 2.6.14-rc5]. Tenete presente che nuove versioni della patch vengono rilasciate giornalmente.<br />
<br />
Per applicare la patch basta copiarla in <tt>/usr/src</tt>, entrare della dir del kernel e lanciare il comando, nel mio esempio:<br />
<br />
$ cat ../patch-2.6.14-rc3-rt2 | patch -p1 -t<br />
<br />
A questo punto nuovamente un <tt>make oldconfg</tt> ci permetterà di configurare le voci inserite dalla patch. Assicurarsi di scegliere '''Complete Preemption (Real-Time)''' in:<br />
<br />
<pre><br />
Processor type and features ---><br />
Preemption Mode (Complete Preemption (Real-Time))<br />
</pre><br />
<br />
per il resto ho lasciato tutte le altre nuove voci su NO (la maggior parte di esse serve, infatti, per attivare vari strumenti di debug).<br />
<br />
Non ci resta che compilare il kernel:<br />
<br />
$ fakeroot make-kpkg --append-to-version -realtime --revision 0.1 kernel_image<br />
<br />
ed installare il pacchetto, per ulteriori informazioni su questo passaggio: [[Debian Kernel Howto]].<br />
<br />
<br />
== Modalità realtime e realtime scheduling ==<br />
<br />
La modalità realtime è un particolare privilegio di esecuzione che un'applicazione può avere . Questa modalità permette ad una applicazione di avere accesso alla CPU con la massima priorità (rispetto ad ogni altra applicazione in attesa) ogni volta che venga richiesto, impedendo inoltre che un'altra applicazione possa a sua volta interrompere l'esecuzione (a meno che non sia anch'essa realtime). <br />
<br />
Questo permette di tenere in esecuzione applicazioni a bassa latenza, senza il rischio che altre applicazioni non-realtime possano disturbarle. Si capisce come questa modalità sia importantissima nelle applicazioni audio professionali (ad esempio una sessione di registrazione non verrà mai interrotta anche se molte applicazioni non realtime saturano la CPU!).<br />
<br />
D'altro canto, questa modalità, pone dei seri problemi di sicurezza dato che un'applicazione potrebbe (a causa di un errore o di un comportamento malevolo) occupare la CPU per un tempo indefinito, senza poter essere interrotta, impedendo dunque la normale applicazione degli altri programmi.<br />
<br />
Normalmente, quindi, solo root ha i privilegi per lanciare applicazioni in modalità realtime. Questo è un problema, dato che (ad esempio) Jack e tutte le applicazioni che vi si connettono dovrebbero essere lanciate da root per poter funzionare in modalità realtime, e questo costituirebbe un ancor più grosso problema di sicurezza.<br />
<br />
Per risolvere il problema bisogna consentire l'uso della modalità realtime anche a normali utenti ma in maniera "controllata".<br />
<br />
Il modo più semplice consiste nell'usare gli '''rlimits''', ovvero editare il file <tt>/etc/security/limits.conf</tt> per consentire ad un utente od ad un gruppo di eseguire applicazioni in modalità realtime. Questo metodo ormai è pienamente supportato da Debian Etch (''stabile'') in poi.<br />
<br />
Un secondo metodo ormai obsoleto consiste nell'usare un modulo del kernel chiamato <tt>realtime-lsm</tt>. Questa procedura è più lunga e può creare problemi di sicurezza.<br />
<br />
Entrambi gli approcci possono essere usati sia con kernel vanilla che con kernel realtime-preemption.<br />
<br />
=== Usare gli rlimits ===<br />
<br />
&Egrave; presente nel kernel un nuovo meccanismo più sicuro per concedere i privilegi di realtime chiamato rlimits che sostituisce completamente il vecchio e insicuro modulo <tt>realtime-lsm</tt>.<br />
<br />
Gli rlimits sono supportati da PAM dalla versione 0.80, le versioni precedenti richiedono una patch. <br />
Fortunatamente la versione di PAM in Debian Etch, pur essendo una 0.79, include la già questa patch. Per la [[oldstable]] Sarge la patch deve essere applicata manualmente (vedi dopo).<br />
<br />
Quindi l'unica cosa da in Debian fare per abilitare il gruppo '''<tt>audio</tt>''' all'esecuzione di processi in modalità realtime è aggiungere al file <tt>/etc/security/limits.con</tt> le seguenti righe:<br />
<br />
@audio - nice -10<br />
@audio - rtprio 99<br />
@audio - memlock 250000<br />
<br />
Ovviamente perché le modifiche abbiano effetto si deve rieseguire il login.<br />
<br />
Potete controllare che gli rlimits siano settati correttamente lanciando jack:<br />
<br />
$ jackd -R -d alsa -S<br />
<br />
In caso di problemi con la modalità realtime si vedranno messaggi del tipo:<br />
<br />
cannot use real-time scheduling (FIFO at priority 10) [...] <br />
(1: Operation not permitted)<br />
<br />
'''Nota''': Per la [[oldstable]] '''Debian Sarge''' si può installare il pacchetto PAM patchato installando <tt>libpam-modules</tt> da [http://techweb.rfa.org/debrfa/dists/sarge/main/binary-i386/ qui].<br />
<br />
=== Il modulo <tt>realtime-lsm</tt> ===<br />
{{Warningbox|Questa procedura è obsoleta e non è più stata verificata da quando Etch è diventata stabile ed ha incluso il supporto nativo per gli rlimits. E' lasciata solo per motivi storici e didattici.}}<br />
<br />
Il modulo <code>realtime-lsm</code> permette ad un normale utente inserito nel gruppo <code>audio</code> di eseguire applicazioni in modalità realtime. Questo è il vecchio approccio, che verrà man mano sostituito nelle varie distro dall'uso degli rlimits (vedi oltre). <br />
<br />
Su debian l'installazione del modulo è molto semplice: basta installare il pacchetto <code>realtime-lsm-source</code> ed usare <tt>[[Pagina di manuale di module-assistant|module-assistant]]</tt> per compilare e pacchettizzare il modulo. <br />
<br />
In pratica, dopo aver fatto il boot del kernel per il quale si vuole installare il modulo, (e aver installato <code>realtime-lsm-source</code>) basta il seguente comando:<br />
<br />
$ m-a build realtime-lsm<br />
<br />
per compilare e creare un pacchetto per il modulo. A questo punto non ci resta che installare il pacchetto <code>realtime-lsm</code> creato.<br />
<br />
Questo modulo non è stato accettato (ne lo sarà mai) nel tree ufficiale del kernel per i potenziali problemi di sicurezza legati al suo utilizzo. In particolare per il suo corretto funzionamento devono essere attivate le seguenti voci di configurazione del kernel:<br />
<br />
<pre><br />
Security options ---><br />
[*] Enable different security model<br />
<M> Default Linux Capabilities<br />
</pre><br />
<br />
''(l'ultima voce deve necessariamente essere un modulo!)''<br />
<br />
Nei recenti kernel binari di Etch le precendenti condizioni non sono soddisfatte, percui il modulo '''realtime-lsm''' non funzionerà con tali kernel. Inoltre il modulo realtime-lsm è ormai ufficialmente deprecato in debian Etch. <br />
<br />
In questi casi bisognerà ricompilare il kernel oppure usare l'approccio tramite rlimits.<br />
<br />
== Conclusioni ==<br />
Con un kernel così ottimizzato si raggiungono prestazioni realtime davvero spinte. Io ad esempio, con una modestissima SB Audigy 1 posso fare partire jack a 32 frame x 2 periodi @ 48000Hz (latenza 1.3 ms!) in modalità solo playback. Qualche xrun avviene ancora a latenze così basse se si eseguono altre operazioni sulla macchina. Per avere la massima affidabilità in full-duplex utilizzo usualmente jack a 128x2 @ 48000Hz.<br />
<br />
In bocca al lupo e...<br />
<br />
Happy Debian!<br />
<br />
== Links ==<br />
<br />
* http://www.emillo.net/home<br />
* http://www.djcj.org/LAU/guide/index.php<br />
* http://tapas.affenbande.org/?page_id=3<br />
* [http://demudi.agnula.org/wiki/Low-latencyKernelBuildingHowto Low-latency Kernel Building How-to]<br />
* [http://alsa.opensrc.org/RealtimeKernelAndPAM Alsa Wiki: Realtime Kernel And PAM]<br />
<br />
----<br />
<br />
Autore: [[Utente:TheNoise|~ The Noise]]<br />
<br />
[[Categoria:Kernel]]<br />
[[Categoria:Audio]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Old:Low-latency_2.6_kernel_per_applicazioni_audio_realtime&diff=14737Old:Low-latency 2.6 kernel per applicazioni audio realtime2007-05-23T12:08:08Z<p>TheNoise: /* Usare gli rlimits */ messaggio di errore</p>
<hr />
<div>== Introduzione ==<br />
Questa è una breve guida su come configurare il sistema per poter eseguire applicazioni audio realtime.<br />
<br />
Per chi non conoscesse il mondo dell'audio professionale su GNU/Linux consiglio questo magnifico sito introduttivo:<br />
<br />
* [http://www.emillo.net/audio_midi emillo.net]<br />
<br />
Ci sono '''due passi''' distinti illustrati nella guida: ''il primo'' è patchare un kernel 2.6 con la patch '''realtime-preemption''' di ''Ingo Molnar'' per ottenere un kernel con la più bassa latenza possibile; ''il secondo'' è invece permettere a normali utenti l'esecuzione di applicazioni in modalità realtime.<br />
<br />
Il kernel 2.6 ha raggiunto ormai delle prestazioni molto buone per quanto riguarda la latenza (anni luce avanti rispetto al 2.4). Normalmente è dunque sufficiente configurare il sistema per permettere ai normali utenti di eseguire applicazioni realtime (''secondo passo'').<br />
<br />
Se invece, si vuole non solo ridurre sotto la soglia (indicativa) dei ~ 5 ms la latenza minima ottenibile, ma soprattutto, aumentare notevolmente l'affidabilità del sistema nel rispettare le basse latenze bisogna usare la patch realtime-preemption (''primo passo''). E' questo il caso, ad esempio, se si vuole lavorare in full-duplex su diverse tracce in realtime, ''senza correre il rischio di xrun'' (ovvero interruzioni del flusso audio). Oppure se si vuole suonare un sintetizzatore software usando la minima latenza possibile.<br />
<br />
La patch realtime-preemption (per quanto perfettamente usabile) continua ad essere sviluppata incessantemente, e le release sono spesso giornaliere. Il kernel a cui si applica la patch è sempre l'ultimo kernel stabile o, spesso, l'ultimo RC. Nella guida, a puro titolo esemplificativo, mi riferirò ad un kernel e ad una versione di patch specifica, anche se queste versioni diventeranno presto obsolete. <br />
<br />
{{Warningbox|Se non siete a vostro completo agio a compilare e patchare il kernel questa non è la via che fa per voi. Consiglio, in tal caso, di usare un setup per l'audio professionale pronto per l'uso, come la distrubuzione [http://64studio.com/ 64 Studio] (disponibile sia per processori 64 bit che per 32bit). Se volete invece informazioni dettagliate su come compilare il kernel alla ''debian-way'': [[Debian Kernel Howto]]. }}<br />
<br />
== Dal kernel stabile all'RC ==<br />
Consiglio di compilare l'ultima versione stabile del kernel, configurandola e testandola fino ad ottenere una configurazione ben funzionante. Come spunto potete usare [[Esempio configurazione kernel|questa configurazione]]. Nel mio caso ho usato il kernel 2.6.13.2 e la [[Debian Kernel Howto|debian-way]] di compilare il kernel. <br />
<br />
Una guida completa sulla configurazione e l'ottimizzazione di un [[kernel vanilla]] (e non solo) per applicazioni audio è la seguente: <br />
<br />
* [http://demudi.agnula.info/wiki/Low-latencyKernelBuildingHowto Low-latency Kernel Building Howto].<br />
<br />
La patch realtime-preemption più recente si applica solitamente ai kernel RC (Release Candidate). Questo perchè Ingo Molnar segue sempre il kernel più recente (quindi usa le RC come base di partenza per la sua patch). Quando viene rilasciato un nuovo kernel stabile Ingo Molnar rilascia pach per il nuovo kernel stabile, ma dopo alcune settimane passa nuovamente a seguire l'ultima RC uscita nel frattempo. <br />
<br />
Quindi, si hanno due possibilità:<br />
# compilare l'ultimo kernel stabile con l'ultima patch rilasciata per quel kernel<br />
# compilare l'ultimo kernel rc e usare la versione corrente della pacth.<br />
<br />
Attualmente, ad esempio, l'ultimo kernel stabile, per il quale sia stata rilasciata la patch realtime preemption è il [ftp://ftp.it.kernel.org/pub/linux/kernel/v2.6/linux-2.6.14.tar.bz2 2.6.14] (non i successivi 2.6.14.x). Per tale kernel l'ultima patch disponibile è la [http://people.redhat.com/mingo/realtime-preempt/older/patch-2.6.14-rt22 2.6.14-rt22], come si può vedere [http://people.redhat.com/mingo/realtime-preempt/older/ qui].<br />
<br />
Se invece si vuole usare l'[http://people.redhat.com/mingo/realtime-preempt/ ultima patch] realtime-preemption (attualmente 2.6.15-rc5-rt2) bisogna usare anche l'[ftp://ftp.it.kernel.org/pub/linux/kernel/v2.6/testing/ ultimo kernel RC]. <br />
<br />
Per passare da un kernel stabile ad un RC basta fare un <tt>make oldconfig</tt> in modo da configurare solo le nuove voci. Questo metodo "a due passi" permette di separare i problemi dovuti ad un eventuale errore di configurazione del kernel stabile dai problemi potenzialmente introdotti dall'uso di un kernel RC non stabile.<br />
<br />
== La patch realtime-preemption ==<br />
L'archivio delle patch realtime-premption si trova a [http://people.redhat.com/mingo/realtime-preempt/ questo indirizzo]. La patch realtime-preemption usata di seguito (a puro titolo esemplificativo) è la 2.6.14-rc5-rt5, voi usate la versione più recente disponibile. La patch è un semplice file di testo. Il suo nome è del tipo <tt>patch-''<kernel version>''-''<patch version>''</tt>. Bisogna applicare la patch all'esatta versione del kernel indicata dal nome. Di seguito viene usata la [http://people.redhat.com/mingo/realtime-preempt/older/patch-2.6.14-rc5-rt5 versione rt5 applicata al kernel 2.6.14-rc5]. Tenete presente che nuove versioni della patch vengono rilasciate giornalmente.<br />
<br />
Per applicare la patch basta copiarla in <tt>/usr/src</tt>, entrare della dir del kernel e lanciare il comando, nel mio esempio:<br />
<br />
$ cat ../patch-2.6.14-rc3-rt2 | patch -p1 -t<br />
<br />
A questo punto nuovamente un <tt>make oldconfg</tt> ci permetterà di configurare le voci inserite dalla patch. Assicurarsi di scegliere '''Complete Preemption (Real-Time)''' in:<br />
<br />
<pre><br />
Processor type and features ---><br />
Preemption Mode (Complete Preemption (Real-Time))<br />
</pre><br />
<br />
per il resto ho lasciato tutte le altre nuove voci su NO (la maggior parte di esse serve, infatti, per attivare vari strumenti di debug).<br />
<br />
Non ci resta che compilare il kernel:<br />
<br />
$ fakeroot make-kpkg --append-to-version -realtime --revision 0.1 kernel_image<br />
<br />
ed installare il pacchetto, per ulteriori informazioni su questo passaggio: [[Debian Kernel Howto]].<br />
<br />
<br />
== Modalità realtime e realtime scheduling ==<br />
<br />
La modalità realtime è un particolare privileggio di esecuzione che un'applicazione può avere . Questa modalità permette ad una applicazione di avere accesso alla CPU con la massima priorita (rispetto ad ogni altra applicazione in attesa) ogni volta che venga richiesto, impedendo inoltre che un'altra applicazione possa a sua volta interrompere l'esecuzione (a meno che non sia anch'essa realtime). <br />
<br />
Questo permette di tenere in esecuzione applicazioni a bassa latenza, senza il rischio che altre applicazioni non-realtime possano disturbarle. Si capisce come questa modalità sia importantisissima nelle applicazioni audio professionali (ad esempio una sessione di registrazione non verrà mai interrotta anche se molte applicazioni non realtime saturano la CPU!).<br />
<br />
D'altro canto, questa modalità, pone dei seri problemi di sicurezza dato che un'applicazione potrebbe (a causa di un errore o di un comportamento malevolo) occupare la CPU per un tempo indefinito, senza poter essere interrotta, impedendo dunque la normale applicazione degli altri programmi.<br />
<br />
Normalmente, quindi, solo root ha i privilegi per lanciare applicazioni in modalità realtime. Questo è un problema, dato che (ad esempio) Jack e tutte le applicazioni che vi si connettono dovrebbero essere lanciate da root per poter funzionare in modalità realtime, e questo costituirebbe un ancor più grosso problema di sicurezza.<br />
<br />
Per risolvere il problema bisogna consentire l'uso della modalità realtime anche a normali utenti ma in maniera "controllata".<br />
<br />
Il modo più semplice consiste nell'usare gli '''rlimits''', ovvero editare il file <tt>/etc/security/limits.conf</tt> per consentire ad un utente od ad un gruppo di eseguire applicazioni in modalità realtime. Questo metodo ormai è pienamente supportato da Debian Etch (''stabile'') in poi.<br />
<br />
Un secondo metodo ormai obsoleto consiste nell'usare un modulo del kernel chiamato <tt>realtime-lsm</tt>. Questa procedura è più lunga e può creare problemi di sicurezza.<br />
<br />
Entrambi gli approcci possono essere usati sia con kernel vanilla che con kernel realtime-preemption.<br />
<br />
=== Usare gli rlimits ===<br />
<br />
&Egrave; presente nel kernel un nuovo meccanismo più sicuro per concedere i privilegi di realtime chiamato rlimits che sostituisce completamente il vecchio e insicuro modulo <tt>realtime-lsm</tt>.<br />
<br />
Gli rlimits sono supportati da PAM dalla versione 0.80, le versioni precedenti richiedono una patch. <br />
Fortunatamente la versione di PAM in Debian Etch, pur essendo una 0.79, include la già questa patch. Per la [[oldstable]] Sarge la patch deve essere applicata manualmente (vedi dopo).<br />
<br />
Quindi l'unica cosa da in Debian fare per abilitare il gruppo '''<tt>audio</tt>''' all'esecuzione di processi in modalità realtime è aggiungere al file <tt>/etc/security/limits.con</tt> le seguenti righe:<br />
<br />
@audio - nice -10<br />
@audio - rtprio 99<br />
@audio - memlock 250000<br />
<br />
Ovviamente perché le modifiche abbiano effetto si deve rieseguire il login.<br />
<br />
Potete controllare che gli rlimits siano settati correttamente lanciando jack:<br />
<br />
$ jackd -R -d alsa -S<br />
<br />
In caso di problemi con la modalità realtime si vedranno messaggi del tipo:<br />
<br />
cannot use real-time scheduling (FIFO at priority 10) [...] <br />
(1: Operation not permitted)<br />
<br />
'''Nota''': Per la [[oldstable]] '''Debian Sarge''' si può installare il pacchetto PAM patchato installando <tt>libpam-modules</tt> da [http://techweb.rfa.org/debrfa/dists/sarge/main/binary-i386/ qui].<br />
<br />
=== Il modulo <tt>realtime-lsm</tt> ===<br />
{{Warningbox|Questa procedura è obsoleta e non è più stata verificata da quando Etch è diventata stabile ed ha incluso il supporto nativo per gli rlimits. E' lasciata solo per motivi storici e didattici.}}<br />
<br />
Il modulo <code>realtime-lsm</code> permette ad un normale utente inserito nel gruppo <code>audio</code> di eseguire applicazioni in modalità realtime. Questo è il vecchio approccio, che verrà man mano sostituito nelle varie distro dall'uso degli rlimits (vedi oltre). <br />
<br />
Su debian l'installazione del modulo è molto semplice: basta installare il pacchetto <code>realtime-lsm-source</code> ed usare <tt>[[Pagina di manuale di module-assistant|module-assistant]]</tt> per compilare e pacchettizzare il modulo. <br />
<br />
In pratica, dopo aver fatto il boot del kernel per il quale si vuole installare il modulo, (e aver installato <code>realtime-lsm-source</code>) basta il seguente comando:<br />
<br />
$ m-a build realtime-lsm<br />
<br />
per compilare e creare un pacchetto per il modulo. A questo punto non ci resta che installare il pacchetto <code>realtime-lsm</code> creato.<br />
<br />
Questo modulo non è stato accettato (ne lo sarà mai) nel tree ufficiale del kernel per i potenziali problemi di sicurezza legati al suo utilizzo. In particolare per il suo corretto funzionamento devono essere attivate le seguenti voci di configurazione del kernel:<br />
<br />
<pre><br />
Security options ---><br />
[*] Enable different security model<br />
<M> Default Linux Capabilities<br />
</pre><br />
<br />
''(l'ultima voce deve necessariamente essere un modulo!)''<br />
<br />
Nei recenti kernel binari di Etch le precendenti condizioni non sono soddisfatte, percui il modulo '''realtime-lsm''' non funzionerà con tali kernel. Inoltre il modulo realtime-lsm è ormai ufficialmente deprecato in debian Etch. <br />
<br />
In questi casi bisognerà ricompilare il kernel oppure usare l'approccio tramite rlimits.<br />
<br />
== Conclusioni ==<br />
Con un kernel così ottimizzato si raggiungono prestazioni realtime davvero spinte. Io ad esempio, con una modestissima SB Audigy 1 posso fare partire jack a 32 frame x 2 periodi @ 48000Hz (latenza 1.3 ms!) in modalità solo playback. Qualche xrun avviene ancora a latenze così basse se si eseguono altre operazioni sulla macchina. Per avere la massima affidabilità in full-duplex utilizzo usualmente jack a 128x2 @ 48000Hz.<br />
<br />
In bocca al lupo e...<br />
<br />
Happy Debian!<br />
<br />
== Links ==<br />
<br />
* http://www.emillo.net/home<br />
* http://www.djcj.org/LAU/guide/index.php<br />
* http://tapas.affenbande.org/?page_id=3<br />
* [http://demudi.agnula.org/wiki/Low-latencyKernelBuildingHowto Low-latency Kernel Building How-to]<br />
* [http://alsa.opensrc.org/RealtimeKernelAndPAM Alsa Wiki: Realtime Kernel And PAM]<br />
<br />
----<br />
<br />
Autore: [[Utente:TheNoise|~ The Noise]]<br />
<br />
[[Categoria:Kernel]]<br />
[[Categoria:Audio]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Old:Low-latency_2.6_kernel_per_applicazioni_audio_realtime&diff=14736Old:Low-latency 2.6 kernel per applicazioni audio realtime2007-05-23T12:00:33Z<p>TheNoise: /* Modalità realtime e realtime scheduling */ aggiornamenti per Etch</p>
<hr />
<div>== Introduzione ==<br />
Questa è una breve guida su come configurare il sistema per poter eseguire applicazioni audio realtime.<br />
<br />
Per chi non conoscesse il mondo dell'audio professionale su GNU/Linux consiglio questo magnifico sito introduttivo:<br />
<br />
* [http://www.emillo.net/audio_midi emillo.net]<br />
<br />
Ci sono '''due passi''' distinti illustrati nella guida: ''il primo'' è patchare un kernel 2.6 con la patch '''realtime-preemption''' di ''Ingo Molnar'' per ottenere un kernel con la più bassa latenza possibile; ''il secondo'' è invece permettere a normali utenti l'esecuzione di applicazioni in modalità realtime.<br />
<br />
Il kernel 2.6 ha raggiunto ormai delle prestazioni molto buone per quanto riguarda la latenza (anni luce avanti rispetto al 2.4). Normalmente è dunque sufficiente configurare il sistema per permettere ai normali utenti di eseguire applicazioni realtime (''secondo passo'').<br />
<br />
Se invece, si vuole non solo ridurre sotto la soglia (indicativa) dei ~ 5 ms la latenza minima ottenibile, ma soprattutto, aumentare notevolmente l'affidabilità del sistema nel rispettare le basse latenze bisogna usare la patch realtime-preemption (''primo passo''). E' questo il caso, ad esempio, se si vuole lavorare in full-duplex su diverse tracce in realtime, ''senza correre il rischio di xrun'' (ovvero interruzioni del flusso audio). Oppure se si vuole suonare un sintetizzatore software usando la minima latenza possibile.<br />
<br />
La patch realtime-preemption (per quanto perfettamente usabile) continua ad essere sviluppata incessantemente, e le release sono spesso giornaliere. Il kernel a cui si applica la patch è sempre l'ultimo kernel stabile o, spesso, l'ultimo RC. Nella guida, a puro titolo esemplificativo, mi riferirò ad un kernel e ad una versione di patch specifica, anche se queste versioni diventeranno presto obsolete. <br />
<br />
{{Warningbox|Se non siete a vostro completo agio a compilare e patchare il kernel questa non è la via che fa per voi. Consiglio, in tal caso, di usare un setup per l'audio professionale pronto per l'uso, come la distrubuzione [http://64studio.com/ 64 Studio] (disponibile sia per processori 64 bit che per 32bit). Se volete invece informazioni dettagliate su come compilare il kernel alla ''debian-way'': [[Debian Kernel Howto]]. }}<br />
<br />
== Dal kernel stabile all'RC ==<br />
Consiglio di compilare l'ultima versione stabile del kernel, configurandola e testandola fino ad ottenere una configurazione ben funzionante. Come spunto potete usare [[Esempio configurazione kernel|questa configurazione]]. Nel mio caso ho usato il kernel 2.6.13.2 e la [[Debian Kernel Howto|debian-way]] di compilare il kernel. <br />
<br />
Una guida completa sulla configurazione e l'ottimizzazione di un [[kernel vanilla]] (e non solo) per applicazioni audio è la seguente: <br />
<br />
* [http://demudi.agnula.info/wiki/Low-latencyKernelBuildingHowto Low-latency Kernel Building Howto].<br />
<br />
La patch realtime-preemption più recente si applica solitamente ai kernel RC (Release Candidate). Questo perchè Ingo Molnar segue sempre il kernel più recente (quindi usa le RC come base di partenza per la sua patch). Quando viene rilasciato un nuovo kernel stabile Ingo Molnar rilascia pach per il nuovo kernel stabile, ma dopo alcune settimane passa nuovamente a seguire l'ultima RC uscita nel frattempo. <br />
<br />
Quindi, si hanno due possibilità:<br />
# compilare l'ultimo kernel stabile con l'ultima patch rilasciata per quel kernel<br />
# compilare l'ultimo kernel rc e usare la versione corrente della pacth.<br />
<br />
Attualmente, ad esempio, l'ultimo kernel stabile, per il quale sia stata rilasciata la patch realtime preemption è il [ftp://ftp.it.kernel.org/pub/linux/kernel/v2.6/linux-2.6.14.tar.bz2 2.6.14] (non i successivi 2.6.14.x). Per tale kernel l'ultima patch disponibile è la [http://people.redhat.com/mingo/realtime-preempt/older/patch-2.6.14-rt22 2.6.14-rt22], come si può vedere [http://people.redhat.com/mingo/realtime-preempt/older/ qui].<br />
<br />
Se invece si vuole usare l'[http://people.redhat.com/mingo/realtime-preempt/ ultima patch] realtime-preemption (attualmente 2.6.15-rc5-rt2) bisogna usare anche l'[ftp://ftp.it.kernel.org/pub/linux/kernel/v2.6/testing/ ultimo kernel RC]. <br />
<br />
Per passare da un kernel stabile ad un RC basta fare un <tt>make oldconfig</tt> in modo da configurare solo le nuove voci. Questo metodo "a due passi" permette di separare i problemi dovuti ad un eventuale errore di configurazione del kernel stabile dai problemi potenzialmente introdotti dall'uso di un kernel RC non stabile.<br />
<br />
== La patch realtime-preemption ==<br />
L'archivio delle patch realtime-premption si trova a [http://people.redhat.com/mingo/realtime-preempt/ questo indirizzo]. La patch realtime-preemption usata di seguito (a puro titolo esemplificativo) è la 2.6.14-rc5-rt5, voi usate la versione più recente disponibile. La patch è un semplice file di testo. Il suo nome è del tipo <tt>patch-''<kernel version>''-''<patch version>''</tt>. Bisogna applicare la patch all'esatta versione del kernel indicata dal nome. Di seguito viene usata la [http://people.redhat.com/mingo/realtime-preempt/older/patch-2.6.14-rc5-rt5 versione rt5 applicata al kernel 2.6.14-rc5]. Tenete presente che nuove versioni della patch vengono rilasciate giornalmente.<br />
<br />
Per applicare la patch basta copiarla in <tt>/usr/src</tt>, entrare della dir del kernel e lanciare il comando, nel mio esempio:<br />
<br />
$ cat ../patch-2.6.14-rc3-rt2 | patch -p1 -t<br />
<br />
A questo punto nuovamente un <tt>make oldconfg</tt> ci permetterà di configurare le voci inserite dalla patch. Assicurarsi di scegliere '''Complete Preemption (Real-Time)''' in:<br />
<br />
<pre><br />
Processor type and features ---><br />
Preemption Mode (Complete Preemption (Real-Time))<br />
</pre><br />
<br />
per il resto ho lasciato tutte le altre nuove voci su NO (la maggior parte di esse serve, infatti, per attivare vari strumenti di debug).<br />
<br />
Non ci resta che compilare il kernel:<br />
<br />
$ fakeroot make-kpkg --append-to-version -realtime --revision 0.1 kernel_image<br />
<br />
ed installare il pacchetto, per ulteriori informazioni su questo passaggio: [[Debian Kernel Howto]].<br />
<br />
<br />
== Modalità realtime e realtime scheduling ==<br />
<br />
La modalità realtime è un particolare privileggio di esecuzione che un'applicazione può avere . Questa modalità permette ad una applicazione di avere accesso alla CPU con la massima priorita (rispetto ad ogni altra applicazione in attesa) ogni volta che venga richiesto, impedendo inoltre che un'altra applicazione possa a sua volta interrompere l'esecuzione (a meno che non sia anch'essa realtime). <br />
<br />
Questo permette di tenere in esecuzione applicazioni a bassa latenza, senza il rischio che altre applicazioni non-realtime possano disturbarle. Si capisce come questa modalità sia importantisissima nelle applicazioni audio professionali (ad esempio una sessione di registrazione non verrà mai interrotta anche se molte applicazioni non realtime saturano la CPU!).<br />
<br />
D'altro canto, questa modalità, pone dei seri problemi di sicurezza dato che un'applicazione potrebbe (a causa di un errore o di un comportamento malevolo) occupare la CPU per un tempo indefinito, senza poter essere interrotta, impedendo dunque la normale applicazione degli altri programmi.<br />
<br />
Normalmente, quindi, solo root ha i privilegi per lanciare applicazioni in modalità realtime. Questo è un problema, dato che (ad esempio) Jack e tutte le applicazioni che vi si connettono dovrebbero essere lanciate da root per poter funzionare in modalità realtime, e questo costituirebbe un ancor più grosso problema di sicurezza.<br />
<br />
Per risolvere il problema bisogna consentire l'uso della modalità realtime anche a normali utenti ma in maniera "controllata".<br />
<br />
Il modo più semplice consiste nell'usare gli '''rlimits''', ovvero editare il file <tt>/etc/security/limits.conf</tt> per consentire ad un utente od ad un gruppo di eseguire applicazioni in modalità realtime. Questo metodo ormai è pienamente supportato da Debian Etch (''stabile'') in poi.<br />
<br />
Un secondo metodo ormai obsoleto consiste nell'usare un modulo del kernel chiamato <tt>realtime-lsm</tt>. Questa procedura è più lunga e può creare problemi di sicurezza.<br />
<br />
Entrambi gli approcci possono essere usati sia con kernel vanilla che con kernel realtime-preemption.<br />
<br />
=== Usare gli rlimits ===<br />
<br />
&Egrave; presente nel kernel un nuovo meccanismo più sicuro per concedere i privilegi di realtime chiamato rlimits che sostituisce completamente il vecchio e insicuro modulo <tt>realtime-lsm</tt>.<br />
<br />
Gli rlimits sono supportati da PAM dalla versione 0.80, le versioni precedenti richiedono una patch. <br />
Fortunatamente la versione di PAM in Debian Etch, pur essendo una 0.79, include la già questa patch. Per la [[oldstable]] Sarge la patch deve essere applicata manualmente (vedi dopo).<br />
<br />
Quindi l'unica cosa da in Debian fare per abilitare il gruppo '''<tt>audio</tt>''' all'esecuzione di processi in modalità realtime è aggiungere al file <tt>/etc/security/limits.con</tt> le seguenti righe:<br />
<br />
@audio - nice -10<br />
@audio - rtprio 99<br />
@audio - memlock 250000<br />
<br />
<br />
Ovviamente perché le modifiche abbiano effetto si deve rieseguire il login.<br />
<br />
'''Nota''': Per la [[oldstable]] '''Debian Sarge''' si può installare il pacchetto PAM patchato installando <tt>libpam-modules</tt> da [http://techweb.rfa.org/debrfa/dists/sarge/main/binary-i386/ qui].<br />
<br />
<br />
=== Il modulo <tt>realtime-lsm</tt> ===<br />
{{Warningbox|Questa procedura è obsoleta e non è più stata verificata da quando Etch è diventata stabile ed ha incluso il supporto nativo per gli rlimits. E' lasciata solo per motivi storici e didattici.}}<br />
<br />
Il modulo <code>realtime-lsm</code> permette ad un normale utente inserito nel gruppo <code>audio</code> di eseguire applicazioni in modalità realtime. Questo è il vecchio approccio, che verrà man mano sostituito nelle varie distro dall'uso degli rlimits (vedi oltre). <br />
<br />
Su debian l'installazione del modulo è molto semplice: basta installare il pacchetto <code>realtime-lsm-source</code> ed usare <tt>[[Pagina di manuale di module-assistant|module-assistant]]</tt> per compilare e pacchettizzare il modulo. <br />
<br />
In pratica, dopo aver fatto il boot del kernel per il quale si vuole installare il modulo, (e aver installato <code>realtime-lsm-source</code>) basta il seguente comando:<br />
<br />
$ m-a build realtime-lsm<br />
<br />
per compilare e creare un pacchetto per il modulo. A questo punto non ci resta che installare il pacchetto <code>realtime-lsm</code> creato.<br />
<br />
Questo modulo non è stato accettato (ne lo sarà mai) nel tree ufficiale del kernel per i potenziali problemi di sicurezza legati al suo utilizzo. In particolare per il suo corretto funzionamento devono essere attivate le seguenti voci di configurazione del kernel:<br />
<br />
<pre><br />
Security options ---><br />
[*] Enable different security model<br />
<M> Default Linux Capabilities<br />
</pre><br />
<br />
''(l'ultima voce deve necessariamente essere un modulo!)''<br />
<br />
Nei recenti kernel binari di Etch le precendenti condizioni non sono soddisfatte, percui il modulo '''realtime-lsm''' non funzionerà con tali kernel. Inoltre il modulo realtime-lsm è ormai ufficialmente deprecato in debian Etch. <br />
<br />
In questi casi bisognerà ricompilare il kernel oppure usare l'approccio tramite rlimits.<br />
<br />
== Conclusioni ==<br />
Con un kernel così ottimizzato si raggiungono prestazioni realtime davvero spinte. Io ad esempio, con una modestissima SB Audigy 1 posso fare partire jack a 32 frame x 2 periodi @ 48000Hz (latenza 1.3 ms!) in modalità solo playback. Qualche xrun avviene ancora a latenze così basse se si eseguono altre operazioni sulla macchina. Per avere la massima affidabilità in full-duplex utilizzo usualmente jack a 128x2 @ 48000Hz.<br />
<br />
In bocca al lupo e...<br />
<br />
Happy Debian!<br />
<br />
== Links ==<br />
<br />
* http://www.emillo.net/home<br />
* http://www.djcj.org/LAU/guide/index.php<br />
* http://tapas.affenbande.org/?page_id=3<br />
* [http://demudi.agnula.org/wiki/Low-latencyKernelBuildingHowto Low-latency Kernel Building How-to]<br />
* [http://alsa.opensrc.org/RealtimeKernelAndPAM Alsa Wiki: Realtime Kernel And PAM]<br />
<br />
----<br />
<br />
Autore: [[Utente:TheNoise|~ The Noise]]<br />
<br />
[[Categoria:Kernel]]<br />
[[Categoria:Audio]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Patch_Con_Kolivas:_incrementare_le_prestazioni_desktop&diff=14732Patch Con Kolivas: incrementare le prestazioni desktop2007-05-21T21:32:06Z<p>TheNoise: /* Staircase Scheduler */ Ora lo scheduler è Staircase Deadline</p>
<hr />
<div>Risultato della ricerca di USB_SERIAL_PL2303.</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Discussioni_old:Wireless_Support&diff=14728Discussioni old:Wireless Support2007-05-20T18:26:44Z<p>TheNoise: typo</p>
<hr />
<div>La guida di [[Utente:Pino11]] si trova qui: [[Scheda Wireless DLink DWL-520 e DWL-G520 con Driver ACX1xx]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=Discussioni_old:Wireless_Support&diff=14727Discussioni old:Wireless Support2007-05-20T18:09:03Z<p>TheNoise: cancellata guida erroneamente inserita qui</p>
<hr />
<div>La guida di [[PIno11]] si trova qui: [[Scheda Wireless DLink DWL-520 e DWL-G520 con Driver ACX1xx]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14724LKN: Personalizzare un Kernel2007-05-20T09:53:31Z<p>TheNoise: /* Determinare il Modulo Corretto Partendo da Zero */</p>
<hr />
<div>''Torna all'indice: [[Linux Kernel in a Nutshell]]''<br />
<br />
Uno dei punti più delicati e difficili nella creazione della propria versione del kernel Linux è quello di determinare esattamente quali driver e quali opzioni di configurazione sono richiesti per il corretto funzionamento dalla macchina su cui viene installato.<br />
Questo capitolo guiderà il lettore attraverso questo processo di selezione e scelta dei driver corretti.<br />
<br />
==Usare un Kernel di una Distribuzione==<br />
<br />
Uno dei metodi più semplici, per determinare quali moduli siano necessari, è quello di partire dalla configurazione che viene installata dal pacchetto del kernel della distribuzione che si sta usando. È infatti molto più semplice determinare di quali driver si ha bisogno basandosi su quelli installati in un sistema in funzione, in cui i driver corretti sono già associati all'hardware in utilizzo.<br />
<br />
Se invece si sta personalizzando un kernel per una macchina sulla quale non è installata una distribuzione Linux, allora conviene partire dalla versione LiveCD di una distribuzione. Questo consente all'utente di far partire Linux sulla macchina in oggetto e di determinare in maniera semplice le opzioni di configurazione del kernel e che consentono il funzionamento ottimale della macchina stessa.<br />
<br />
===Dove si Trova la Configurazione del Kernel?===<br />
<br />
Quasi tutte le distribuzioni forniscono il file di configurazione nello stesso pacchetto del kernel. Si consiglia di leggere la documentazione relativa alla Distribuzione stessa per sapere dove viene installato il file di configurazione. Solitamente si trova da qualche parte in una sotto-directory di <tt>/usr/src/linux/</tt>.<br />
<br />
{{Box|Nota per Debian (NdT)|In debian il file di configurazione di ogni kernel installato si trova in <tt>/boot/</tt> ed ha come nome <tt>config-''versione''</tt>.}}<br />
<br />
Se avete difficoltà a trovare la configurazione del kernel, allora guardate nel kernel stesso. I kernel di molte distribuzioni sono compilati in modo da includere il file di configurazione dentro il filesystem <tt>/proc</tt>. Per verificare se questo è il vostro caso, digitate:<br />
<br />
<pre><br />
$ ls /proc/config.gz<br />
/proc/config.gz<br />
</pre><br />
<br />
Se il file ''/proc/config.gz'' è presente, allora copiatelo nella directory del sorgente kernel ed estraetelo:<br />
<br />
<pre><br />
$ cp /proc/config.gz -/linux/<br />
$ cd -/linux<br />
$ gzip -dv config.gz<br />
config.gz: 74.9% - - replaced with config<br />
</pre><br />
<br />
Copiate questo file di configurazione nella vostra directory del kernel e rinominatelo in ''.config''.<br />
Ora potrete utilizzare questo file come base di partenza nella personalizzazione della configurazione del kernel così come descritto nel [[LKN:_Configurare_e_Compilare|Capitolo 4]].<br />
<br />
Usando questo file di configurazione si dovrebbe ottenere sempre un file immagine del kernel (un ''kernel ricompilato'', NdT) funzionante sulla propria macchina.<br />
Lo svantaggio di questa immagine è che verranno compilati quasi tutti i moduli e driver presenti nei sorgenti del kernel. Ciò non è quasi mai necessario per una singola macchina, quindi sarebbe meglio disabilitare tutti i driver e le opzioni non necessarie. Si raccomanda di disabilitare solo quelle opzioni che si è sicuri non serviranno, poiché ci sono parti del sistema che richiedono l'abilitazione di certe opzioni.<br />
<br />
===Determinare quali moduli siano necessari===<br />
Usando il file di configurazione fornito dalla vostra distribuzione il tempo richiesto per la compilazione del kernel è molto lungo poiché tutti i possibili driver vengono abilitati. Si dovrebbe cercare di abilitare solo i driver per l'hardware presente nel sistema, così da ridurre i tempi di compilazione del kernel. Inoltre, compilando ''staticamente'' (invece che come moduli) alcuni o tutti i driver necessari, si riduce la memoria utilizzata ed in alcune architetture si velocizza il funzionamento del sistema. Per escludere i driver dal kernel è necessario però determinare quali moduli sono indispensabili per il funzionamento dell'hardware installato. Attraverso l'utilizzo di due esempi, cercheremo di spiegare come determinare quali driver siano indispensabili al controllo dell'hardware.<br />
<br />
Le informazioni che mettono in relazione i dispositivi ai driver presenti nel kernel sono conservate in varie parti del sistema. Uno dei posti più importanti dove sono salvate queste informazioni è il filesystem virtuale ''sysfs''. All'avvio di Linux, ''sysfs'', dovrebbe essere montato dagli script di inizializzazione della vostra distribuzione nella directory ''/sys''. ''sysfs'' consente di dare un'occhiata a come le varie parti del kernel sono legate l'una a l'altra, questo lo si deduce grazie ai vari link simbolici (''symlink'' NdT) che puntano all'interno dell'intero filesystem.<br />
<br />
In tutti gli esempi di seguito, saranno riportati i veri percorsi (''path'' NdT) di ''sysfs'' corrispondenti ad hardware specifico. La vostra macchina sarà certamente diversa, ma la posizione relativa delle informazioni sarà la stessa. Non ci si deve allarmare se i nomi di file nel ''sysfs'' non sono i medesimi, ciò è normale e prevedibile.<br />
<br />
Inoltre, la struttura interna del file di sistema ''sysfs'' subisce modifiche, a causa sia della riorganizzazione dei driver sia del fatto che gli sviluppatori del kernel trovano nuovi modi per meglio presentare in ''user space'' le strutture interne del kernel. A causa di questo, col tempo, alcuni dei ''symlink'', precedentemente menzionati in questo capitolo, possono non essere presenti. Tuttavia, le informazioni sono ancora tutte presenti, al massimo sono state un po' spostate.<br />
<br />
====Esempio: Come determinare il driver di rete====<br />
<br />
Uno degli elementi più comuni ed importanti in un sistema è la scheda di rete. È essenziale capire quale driver la controlla ed attivarlo nella configurazione in maniera da consentire un corretto funzionamento delle connessioni di rete.<br />
<br />
Primo: partendo dalle connessioni di rete si risale al device PCI <br />
<pre>$ ls /sys/class/net/<br />
eth0 eth1 eth2 lo</pre><br />
<br />
La directory ''lo'' rappresenta il dispositivo di rete loopback, ed non è dipendente da nessun dispositivo di rete realmente installato. Invece si dovrebbe riservare particolare attenzione alle directory ''eth0'', ''eth1'' e ''eth2'', dato che si riferiscono a dispositivi realmente esistenti<br />
<br />
Per determinare di quali dispositivi ci si deve occupare, si utilizza il comando ''ifconfig'':<br />
<br />
<pre>$ /sbin/ifconfig -a<br />
eth0 Link encap:Ethernet HWaddr 00:12:3F:65:7D:C2<br />
inet addr:192.168.0.13 Bcast:192.168.0.255 Mask:255.255.255.0<br />
UP BROADCAST NOTRAILERS RUNNING MULTICAST MTU:1500 Metric:1<br />
RX packets:2720792 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:1815488 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:100<br />
RX bytes:3103826486 (2960.0 Mb) TX bytes:371424066 (354.2 Mb)<br />
Base address:0xdcc0 Memory:dfee0000-dff00000<br />
eth1 Link encap:UNSPEC HWaddr 80-65-00-12-7D-C2-3F-00-00-00-00-00-00-00-00<br />
BROADCAST MULTICAST MTU:1500 Metric:1<br />
RX packets:0 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)<br />
eth2 Link encap:UNSPEC HWaddr 00-02-3C-04-11-09-D2-BA-00-00-00-00-00-00-00<br />
BROADCAST MULTICAST MTU:1500 Metric:1<br />
RX packets:0 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)<br />
lo Link encap:Local Lookback<br />
inet addr:127.0.0.1 Mask:255.0.0.0<br />
UP LOOPBACK RUNNING MTU:16436 Metric:1<br />
RX packets:60 errors:0 dropped:0 overruns:0 frame:0<br />
TX packets:60 errors:0 dropped:0 overruns:0 carrier:0<br />
collisions:0 txqueuelen:1000<br />
RX bytes:13409 (13.0 Kb) TX bytes:13409 (13.0 Kb)</pre><br />
<br />
Da questo listato si può riconoscere nel dispositivo di rete <tt>eth0</tt>, quello attivo e funzionante, infatti nelle righe;<br />
<br />
<pre>eth0 Link encap:Ethernet HWaddr 00:12:3F:65:7D:C2<br />
inet addr:192.168.0.13 Bcast:192.168.0.255 Mask:255.255.255.0</pre><br />
<br />
Questo risultato dimostra che il dispositivo Ethernet si vede assegnato un indirizzo IP valido (<tt>inet</tt>).<br />
<br />
Ora, dopo che abbiamo individuato il dispositivo <tt>eth0</tt> e ci siamo accertati di volerlo abilitare nel nostro nuovo kernel, dobbiamo individuare quale driver lo controlla. Ciò si realizza con una semplice procedura, che è quella si seguire i link nel filesystem sysfs, basta digitare un comando di una sola riga:<br />
<br />
<pre>$ basename `readlink /sys/class/net/eth0/device/driver/module`<br />
e1000</pre><br />
<br />
Il risultato mostra che il modulo <tt>e1000</tt> controlla il dispositivo di rete <tt>eth0</tt>. Il comando ''basename'' racchiude in un'unica linea di comando i seguenti passaggi:<br />
<br />
: 1. Individua il symlink ''/sys/class/net/eth0/device'' contenuto all'interno della directory ''/sys/device/'', la quale contiene le informazioni relative al dispositivo che controlla ''eth0''. Fate attenzione al fatto che nelle nuove versioni del kernel la directory ''/sys/class/net/eth0'' potrebbe essere un symlink. <br />
<br />
: 2. All'interno della directory che descrive il dispositivo in sysfs, c'è un symlink che punta al driver relativo a questo dispositivo. Questo symlink è nominato ''driver'', pertanto si segue questo collegamento.<br />
<br />
: 3. All'interno della directory che descrive il driver in sysfs, c'è un symlink che punta al modulo che si trova all'interno del driver in oggetto. Questo symlink è chiamato <tt>module</tt>. Noi cerchiamo l'oggetto a cui punta questo symlink, per ottenerlo ci serviamo del comando ''readlink'', il quale produce un risultato simile a questo:<br />
:<pre>$ readlink /sys/class/net/eth0/device/driver/module </pre><br />
:<pre> ../../../../module/e1000</pre><br />
<br />
: 4. Dato che a noi interessa solo il nome del modulo e ci disinteressiamo del resto del risultato ottenuto con il comando ''readlink'', tenendo solo la parte più a destra del risultato. Questo è appunto ciò che il comando ''basename'' realizza. Applicandolo direttamente all'intero percorso, questo comando ci ritorna quanto segue: <br />
: <pre>$ basename ../../../../module/e1000</pre><br />
: <pre>e1000</pre><br />
<br />
Così abbiamo inserito il lungo risultato del symlink, ottenuto da ''readlink'', quale parametro nel programma ''basemane'', permettendo così l'intero processo di essere realizzato in una sola riga.<br />
<br />
Ora che abbiamo identificato il nome del modulo, si dovrebbe trovare l'opzione della configurazione del kernel che lo controlla. Si può cercare nei vari menu di configurazione dei dispositivi di rete oppure cercare nel codice sorgente del kernel stesso per essere sicuri di avere l'opzione giusta.<br />
<br />
<pre><br />
$ cd ~/linux/linux-2.6.17.8<br />
$ find -type f -name Makefile | xargs grep e1000<br />
./drivers/net/Makefile:obj-$(CONFIG_E1000) += e1000/<br />
./drivers/net/e1000/Makefile:obj-$(CONFIG_E1000) += e1000.o<br />
./drivers/net/e1000/Makefile:e1000-objs := e1000_main.o e1000_hw.o e1000_ethtool.o e1000_param.o<br />
</pre><br />
<br />
Si precisa che "e1000'', usato in questo esempio, deve essere sostituito con il nome del modulo che state analizzando.<br />
<br />
La cosa che ci interessa nel risultato del precedente comando ''find'' sono le righe dove compaia il termine <tt>'''CONFIG_'''</tt>. Questa è l'opzione di configurazione che il kernel deve aver attivato per poter compilare il modulo. Nell'esempio precedente l'opzione di configurazione che c'interessa è pertanto <tt>CONFIG_E1000</tt>.<br />
<br />
Adesso si dispone dell'informazione necessaria per poter configurare il kernel. Si esegue lo strumento menu di configurazione:<br />
<br />
<pre>$ make menuconfig</pre><br />
<br />
Dopodiché si prema il tasto / (slash) (che ha il compito di far partire una ricerca), e si digita l'opzione di configurazione, senza la parte di testo <tt>CONFIG_</tt>. Questo processo è mostrato nella [[:Immagine:Config_search.png|figura 7-1]].<br />
<br />
[[Immagine:Config_search.png|center|frame|''Figura 7-1. Ricerca in menuconfig.'']]<br />
<br />
Il sistema di configurazione del kernel vi dirà ora esattamente dove selezionare l'opzione per abilitare questo modulo. Vedi [[:Immagine:Config_search_found.png|figura 7-2]].<br />
<br />
[[Immagine:Config_search_found.png|center|frame|''Figura 7-2. Risultato della ricerca in menuconfig.'']]<br />
<br />
Il primo elemento nella schermata mostra l'opzione che stavate cercando. Le informazioni mostrate dalla schermata vi dicono che, per attivare il modulo <tt>E1000</tt> nel kernel, la seguente opzione di configurazione deve essere abilitata:<br />
<br />
Device Drivers<br />
Network device support<br />
[*] Network device support<br />
Ethernet (1000 Mbit)<br />
[*] Intel(R) PRO/1000 Gigabit Ethernet support<br />
<br />
Questo modo di procedere funziona per ogni tipo di dispositivo attivo nel kernel.<br />
<br />
====Esempio: Un Dispositivo USB====<br />
<br />
Come secondo esempio, esaminiamo ora un convertitore USB-seriale che è presente nel nostro sistema preso ad esempio. Attualmente il convertitore è collegato alla porta ''/dev/ttyUSB0'', pertanto si deve prendere in esame la sezione tty del ''sysfs''.<br />
<pre>$ ls /sys/class/tty/ | grep USB<br />
ttyUSB0</pre><br />
Potete ora eseguire una ricerca di questo dispositivo nel ''sysfs'' allo scopo di trovare il modulo che lo gestisce, utilizzando la stessa procedura mostrata nella sezione precedente:<br />
<br />
<pre>$ basename `readlink /sys/class/tty/ttyUSB0/device/driver/module`<br />
pl2303</pre><br />
Dopodiché, per poter individuare l'opzione di configurazione che si deve abilitare, si cerca nell'albero del codice sorgente del kernel:<br />
<pre>$ cd ~/linux/linux-2.6.17.8<br />
$ find -type f -name Makefile | xargs grep pl2303<br />
./drivers/usb/serial/Makefile:obj-$(CONFIG_USB_SERIAL_PL2303) += pl2303.o</pre><br />
<br />
Si utilizzi lo strumento di configurazione del kernel, come indicato in [[:Immagine:Config_search_pl2303.png|figura 7-3]], per trovare l'opzione adeguata da abilitare relativa al settaggio dell'opzione CONFIG_USB_SERIAL_PL2303.<br />
<br />
[[Immagine:Config_search_pl2303.png|center|frame|''Figura 7-3. Ricerca di USB_SERIAL_PL2303''.]]<br />
<br />
Nel nostro caso il risultato è mostrato nella [[:Immagine:Config_search_pl2303_found.png|figura 7-4]].<br />
<br />
[[Immagine:Config_search_pl2303_found.png|center|frame|''Figura 7-4. Risultato della ricerca di USB_SERIAL_PL2303'']]<br />
<br />
Ciò mostra esattamente dove trovare l'opzione <tt>USB Profilic 2303 Single Port Serial Driver</tt> che è necessaria alla corretta gestione di questo dispositivo.<br />
<br />
====Riassunto: Alla scoperta del dispositivo====<br />
<br />
Riassumendo, ecco i vari passaggi che servono per identificare il driver funzionante di un dispositivo ad esso collegato:<br />
: 1. Trovate la corretta classe di dispositivi in ''sysfs'' relativa al dispositivo che ci interessa. I dispositivi di rete sono elencati in ''/sys/class/net'', mentre i dispositivi tty sono elencati in ''/sys/class/tty''. Gli altri vari dispositivi si trovano in altre sotto-directory di ''/sys/class'', a seconda del tipo.<br />
: 2. Ricercate nell'albero di ''sysfs'' il nome del modulo che controlla il dispositivo in oggetto. Lo si trova in ''/sys/class/class_name/device_name/device/driver/module'', la ricerca è agevolata se si utilizzano i comandi ''readlink'' e ''basename''.<br />
:<pre>$ basename `readlink /sys/class/class_name/device_name/device/driver/module`</pre><br />
: 3. Ricercate nei file Makefile con ''find'' e ''grep'' le opzioni <tt>CONFIG_</tt> che abilitano il modulo<br />
:<pre>$ find -type f -name Makefile | xargs grep ''module_name''</pre><br />
: 4. Ricercate l'opzione trovata nel sistema di configurazione del kernel, dopodiché andate dove indicato dal menu per attivare il driver in oggetto.<br />
<br />
====Lasciate che il kernel ci dica ciò di cui abbiamo bisogno====<br />
Dopo esserci infilati nel ''sysfs'' e aver seguito i sui symlinks per ricercare passo passo i nomi dei moduli, presentiamo un semplice script che farà per noi tutto il lavoro in un modo leggermente diverso:<br />
<br />
<pre><br />
#!/bin/bash<br />
#<br />
# find_all_modules.sh<br />
#<br />
for i in `find /sys/ -name modalias -exec cat {} \;`; do<br />
/sbin/modprobe --config /dev/null --show-depends $1 ;<br />
done | rev | cut -f i -d '/' | rev | sort -u<br />
</pre><br />
<br />
Si può scaricare un file d'esempio, contenente questo script, dal web site del libro, riportato nella sezione ''Come contattarci'' che si trova nella prefazione.<br />
<br />
Questo script cerca nel ''sysfs'' tutti file chiamati ''modalias''. Il file ''modalias'' contiene gli alias dei moduli e comunica al comando ''modprobe'' quali moduli debbano essere caricati per ogni dispositivo. L'alias del modulo è composto da una combinazione di: produttore del dispositivo, ID, tipo di classe ed altri identificativi univoci per il tipo di dispositivo in questione. Tutti i moduli del driver del kernel hanno una lista interna dei dispositivi che supportano, che è generata automaticamente dalla lista dei dispositivi che il driver comunica al kernel di poter supportare. Il comando ''modprobe'' ricerca tutti i dispositivi nella lista di tutti i driver e cerca di trovare una corrispondenza confrontando l'alias. Se trova una corrispondenza, allora provvede al caricamento del modulo (questa procedura è la stessa seguita dal caricamento automatico dei driver in Linux).<br />
<br />
Lo script prevede l'arresto del programma ''modprobe'' prima di caricare il modulo, e riporta in display solo le azioni che eseguirebbe. Questo ci da una lista di tutti i moduli che sono necessari al controllo di tutti i dispositivi del sistema. Eseguendo una piccola pulizia della lista, ordinandola e selezionando i campi adeguati, <br />
otteniamo il seguente risultato:<br />
<br />
<pre><br />
$ find_all_modules.sh<br />
8139cp.ko<br />
8139too.koo<br />
ehci-hcd.ko<br />
fimware_vlass.ko<br />
i2c-i801.ko<br />
ieee80211.ko<br />
ieee80211_crypt.ko<br />
ipw2200.ko<br />
mii.ko<br />
mmc_core.ko<br />
pcmcia_core.ko<br />
rsrc_nonstatic.ko<br />
sdhci.ko<br />
snd-hda-codec.ko<br />
snd-hda-intel.ko<br />
snd-page-alloc.ko<br />
snd-pmc.ko<br />
snd-timer.ko<br />
snd.ko<br />
soundcore.ko<br />
uhci-hcd.ko<br />
usbcore.ko<br />
yenta_socket.ko<br />
</pre><br />
<br />
Questa è la lista di tutti i moduli che sono necessari alla gestione dell'hardware della macchina.<br />
<br />
Lo script mostrerà probabilmente alcuni messaggi di errore che possono essere del tipo:<br />
<br />
<pre>FATAL: Module pci:v00008086d00002592sv000010CFsd000012E0bc03sc00i00 not found.<br />
FATAL: Module serio:ty01pr00id00ex00 not found.</pre><br />
<br />
Questo ci dice che non si trova un modulo che gestisce quel dispositivo. Questo non deve comunque interessare più di tanto, poiché alcuni dispositivi non hanno driver nel kernel che lavorino per loro.<br />
<br />
==Determinare il Modulo Corretto Partendo da Zero==<br />
Talvolta non si la possibilità di avere un kernel funzionante su una macchina in modo da determinare quali moduli del kernel siano necessari per gestire l'hardware. Oppure si è aggiunto del nuovo hardware al sistema e bisogna trovare le opzioni della configurazione necessarie a farlo funzionare correttamente. Questa sezione illustrerà come determinare le opzioni della configurazione necessarie ad far funzionare l'hardware.<br />
<br />
Il modo più semplice per capire quale driver controlla un nuovo dispositivo è quello di compilare come moduli tutti i driver di quel tipo disponibili nei sorgenti del kernel, e lasciare che il processo di avvio tramite ''udev'' associ il driver al dispositivo. Una volta fatto ciò, si dovrebbe essere in grado di risalire al driver necessario seguendo i passi descritti precedentemente, ed infine ricompilare il kernel abilitando il solo driver necessario.<br />
<br />
===Dispositivi PCI===<br />
<br />
<br />
===Dispositivi USB===<br />
<br />
===Root Filesystem===<br />
<br />
<br />
====Controller di Disco====<br />
<br />
===Un Aiuto dallo Script===<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14721LKN: Personalizzare un Kernel2007-05-19T14:57:08Z<p>TheNoise: /* Lasciate che il Kernel ci Dica di Cui Abbiamo Bisogno */ corretto</p>
<hr />
<div></div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14720LKN: Personalizzare un Kernel2007-05-19T14:43:30Z<p>TheNoise: /* Riassunto: Alla scoperta del dispositivo */ corretto</p>
<hr />
<div></div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14719LKN: Personalizzare un Kernel2007-05-19T14:36:03Z<p>TheNoise: /* Esempio: Un Dispositivo USB */ immagini</p>
<hr />
<div></div>TheNoisehttps://guide.debianizzati.org/index.php?title=File:Config_search_pl2303_found.png&diff=14718File:Config search pl2303 found.png2007-05-19T14:34:24Z<p>TheNoise: Risultato della ricerca di USB_SERIAL_PL2303.</p>
<hr />
<div>Risultato della ricerca di USB_SERIAL_PL2303.</div>TheNoisehttps://guide.debianizzati.org/index.php?title=File:Config_search_pl2303.png&diff=14717File:Config search pl2303.png2007-05-19T14:32:21Z<p>TheNoise: Ricerca di USB_SERIAL_PL2303.</p>
<hr />
<div>Ricerca di USB_SERIAL_PL2303.</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14716LKN: Personalizzare un Kernel2007-05-19T08:39:02Z<p>TheNoise: /* Determinare quali Moduli Siano Necessari */ correzioni e immagini fino a "Come determinare il driver di rete"</p>
<hr />
<div></div>TheNoisehttps://guide.debianizzati.org/index.php?title=File:Config_search.png&diff=14715File:Config search.png2007-05-19T08:28:43Z<p>TheNoise: Ricerca in menuconfig.</p>
<hr />
<div>Ricerca in menuconfig.</div>TheNoisehttps://guide.debianizzati.org/index.php?title=File:Config_search_found.png&diff=14714File:Config search found.png2007-05-19T08:27:23Z<p>TheNoise: Risultato della ricerca in menuconfig</p>
<hr />
<div>Risultato della ricerca in menuconfig</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14713LKN: Personalizzare un Kernel2007-05-19T08:08:27Z<p>TheNoise: /* Dove si Trova la Configurazione del Kernel? */ correzioni</p>
<hr />
<div></div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14707LKN: Personalizzare un Kernel2007-05-17T10:36:47Z<p>TheNoise: /* Determinare quali Moduli Siano Necessari */</p>
<hr />
<div></div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14706LKN: Personalizzare un Kernel2007-05-17T10:26:47Z<p>TheNoise: /* Determinare quali Moduli Siano Necessari */ altre correzioni concettuali</p>
<hr />
<div></div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14705LKN: Personalizzare un Kernel2007-05-17T10:03:20Z<p>TheNoise: /* Determinare quali Moduli Siano Necessari */ varie correzioni</p>
<hr />
<div>''Inserire qui la traduzione...''<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[[Categoria:Kernel]]</div>TheNoisehttps://guide.debianizzati.org/index.php?title=LKN:_Personalizzare_un_Kernel&diff=14704LKN: Personalizzare un Kernel2007-05-17T09:42:46Z<p>TheNoise: /* Determinare quali Moduli Siano Necessari */ corretto comando</p>
<hr />
<div>''Inserire qui la traduzione...''<br />
<br />
<br />
----<br />
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].<br />
----<br />
<br />
[[Categoria:Kernel]]</div>TheNoise