[>a2379.html>] [<a2377.html<] [^a2.html^]
Come faccio a sapere quale è l'ultima versione del kernel?
---------
Con finger:
[root@fokhouse /root]# finger @linux.kernel.org[Invio]
[linux.kernel.org]
The latest stable version of the Linux kernel is: 2.2.12
The latest beta version of the Linux kernel is: 2.3.18
The latest prepatch (alpha) version *appears* to be: none
comunque si consiglia di utilizzare:
[root@fokhouse /root]# finger @finger.kernel.org[Invio]
Quale è il comando per visualizzare la versione del kernel?
---------
$ uname -r[Invio]
Come faccio a sapere il nome dell'immagine del kernel caricata?
---------
Per fare ciò, esiste la variabile BOOT_IMAGE di LILO. Ma la variabile BOOT_IMAGE creata da LILO viene azzerata da qualche processo, per cui dopo il login non esiste più. Bisogna usarla prima di depmod in rc.sysinit per ottenerla.
Con:
# uname -a[Invio]
mi viene restituita una riga di questo tipo:
Linux server 2.2.13 #4 Sun Nov 21 14:13:37 CET 1999 i586 unknown
Da cui posso capire almeno la versione del kernel caricata.
Vorrei sostituire il mio kernel. Quali sono tutte le operazioni necessarie?
---------
Non è una cosa molto difficile:
Nella directory /usr/src è generalmente presente un link chiamato linux che punta alla directory che contiene tutti i sorgenti del kernel installato sulla macchina. Altre volte non è presente tale link ma c'è la semplice directory linux o linux-x.y.z che contiene la versione precedente del kernel.
Se c'è il link cancellalo. Se c'è la directory linux rinominala in linux.old:
# mv /usr/src/linux /usr/src/linux.old[Invio]
se c'è la directory linux-x.y.z lasciala così.
Copia il file linux-ver.del.nuovo.kernel.tar.gz in /usr/src
A questo punto scompatta il file linux-ver_del_nuovo_kernel.tar.gz nella directory /usr/src con:
# tar -zxvf linux-ver_del_nuovo_kernel.tar.gz[Invio]
A questo punto è stata creata una nuova directory chiamata linux dove sono stati messi i sorgenti del nuovo kernel ancora da compilare. Ora puoi andare direttamente nella directory appena creata con:
# cd linux[Invio]
oppure spostare la directory da linux a linux-ver_del_nuovo_kernel (linux-2.2.2):
# mv linux linux-ver_del_nuovo_kernel[Invio]
e creare un nuovo link linux che punti direttamente alla nuova directory appena fatta:
# ln -s linux-ver_del_nuovo_kernel linux[Invio]
Ora entri nella directory /usr/src/linux (link o directory che sia).
Vanno eseguite queste azioni passo dopo passo:
# make mrproper[Invio]
(che cancella il file .config riazzerando tutte le opzioni selezionate nell'ultimo tentativo di ricompilazione)
È un comando 'facoltativo'. (perché se voglio ricompilare il kernel una seconda volta modificando pochissimi valori dall'ultima ricompilazione, se reimpartisco 'make mrproper' devo ricominciare e selezionare le opzioni da capo. Se invece non faccio make mrproper ritroverò tutte le opzioni selezionate in precedenza).
# make menuconfig[Invio]
(se lo vuoi testuale da console) oppure:
# make xconfig[Invio]
Scegli tutte le opzioni aiutandoti con l'help o con Appuntilinux
Alla fine salva la configurazione (che verrà salvata nel file .config) e fai:
# make dep[Invio]
# make clean[Invio]
# make bzImage[Invio]
può anche essere tutto ridotto in
# make dep clean bzImage[Invio]
Conviene fare make bzImage e non make zImage perché la seconda crea un kernel più grande che il LILO può non accettare; per cui conviene subito compilare con bzImage.
Se sono stati inseriti i moduli va fatto:
# make modules[Invio]
# make modules_install.[Invio]
A questo punto l'immagine del kernel la dovresti trovare nella directory /usr/src/linux-2.2.2/arch/i386/boot con il nome bzImage.
Ora copia il file bzImage nella directory /boot:
# cp bzImage /boot[Invio]
Modifica il file /etc/lilo.conf cambiando il nome dell'immagine. C'è scritto image=vmlinuz che tu cambierai in image=bzImage (oppure rinomina bzImage in vmlinuz o in quello che vuoi).
A questo punto esegui LILO:
# /sbin/lilo[Invio]
e se tutto è andato bene dovrebbe scrivere:
Added Linux Added Dos o W95 ecc.
secondo le etichette dei sistemi operativi che hai specificato. Il sistema operativo predefinito è indicato da un asterisco.
A questo punto fai il reboot e partirà la nuova versione del Kernel compilata di fresco.
Come si ricompila il kernel in Debian GNU/Linux?
---------
Installate il pacchetto kernel-package (e libncurses4-dev se usate 'make menuconfig'). Poi:
scaricate il sorgente del kernel;
spostatelo nella directory /usr/src;
decompattatelo;
entrate nella directory linux (o se viene creata la directory linux_x_x_x rinominatela in linux semplicemente);
date un bel make menuconfig;
configurate le opzioni che vi servono;
uscite dal menu.
Non servono i seguenti comandi:
make dep
make clean
make zlilo
make modules
make modules install
Dopo il 'make menuconfig', fate:
# make-kpkg kernel_image[Invio]
per installarlo:
# dpkg -i /usr/src/kernel-image[Invio]
# shutdown -r now[Invio]
Nella directory esterna ai sorgenti del kernel vi trovate un bel pacchetto .deb con il kernel compilato e tutti i moduli necessari. Copiatelo e installatelo su tutti i computer che volete e riavviate.
Non è necessario compilare il kernel sulla stessa macchina su cui dovrà essere usato, andate su quella che lo compila più velocemente.
Il pacchetto kernel-package contiene il comando make-kpkg, che permette di compilare automaticamente un kernel e generare i pacchetti Debian GNU/Linux corrispondenti a:
kernel-image (pacchetto binario del kernel)
kernel-headers (.h per compilare programmi dipendenti dal kernel)
kernel-source (crea un pacchetto con i sorgenti del kernel)
kernel-doc (documentazione del kernel)
Può essere usato sia partendo dai sorgenti Debian GNU/Linux del kernel come anche da un kernel ufficiale eventualmente corretto con una patch. make-kpkg sostituisce il processo di compilazione e installazione del kernel.
I file .deb generati possono essere tranquillamente copiati in giro, ed installati con un semplice 'dpkg -i'.
State attenti a dselect, che potrebbe andare a sovrascrivere il vostro kernel (con una versione presumibilmente nuova, secondo lui). Se entrate in select premete il tasto '=' sul kernel-image installato, così non verrà più toccato da dselect/dpkg.
Ho ricompilato il kernel ed ottenuto il mio file bzImage. L'ho rinominato in vmlinuz e ora cerco di copiarlo nella dir /boot/ ma qui trovo una sfilza di vmlinuz-2.2.5-15...
Cosa dovrei fare a questo punto?
---------
Dipende dal boot manager che usi. Se adoperi LILO, puoi immettere il tuo nuovo kernel nella dir /boot con il nome che più ti piace; poi, inserisci il nome in /etc/lilo.conf come immagine predefinita. Infine, dai il comando:
# /sbin/lilo[Invio]
Ho ricompilato svariate volte il kernel e mi è sorto il seguente dubbio: serve molto spazio libero sul disco? Se si quanto?
circa 65 Mb per i sorgenti decompressi poi qualche centinaio di Kbyte per il binario.
Come si applica una patch al kernel?
---------
# cd /usr/src[Invio]
# bzip2 -dc nomefile |patch -p1[Invio]
o:
# gzip -dc patch.gz |patch -p0[Invio]
se è in .gz
oppure:
si copiano le patch nella directory /usr/src e si entra nella stessa.
Dopo essersi posizionati in tale directory si impartisce il comando:
# linux/scripts/patch-kernel[Invio]
lo script provvede a cercarsi le patch nella dir /usr/src/ e ad applicarle.
Sono abituato ad installare pacchetti in formato tar.gz, ora vado nel sito <www.it.kernel.org> e trovo che le ultime patch del kernel sono in formato .tar.bz2. Come si decompattano tali file?
---------
$ bzip2[Invio]
avendocelo installato puoi decomprimere un file con:
$ bunzip2 nomefile[Invio]
Per i tar.bz2 conviene usare l'opzione I di:
$ tar tIf pacchetto.tar.bz2[Invio]
per listare e:
$ tar xIf pacchetto.tar.bz2[Invio]
per estrarre.
Ma dopo avere applicato la patch, devo ricompilare il kernel come al solito?
---------
Sì, a quel punto tutti i file modificati tra le due versioni sono stati aggiornati ed hai la tua /usr/src/linux esattamente uguale a come l'avresti avuta se avessi scaricato il kernel completo di quella versione.
Dopo aver applicato la patch è bene aggiornare la configurazione con il comando:
# make oldconfig[Invio]
e, cosa molto importante, ricordarsi prima di passare alla compilazione vera e propria di dare il comando:
# make dep[Invio]
Non riesco a fare
# make xconfig
perché mi dice che manca il programma wish. Chi mi sa dire in che pacchetto é contenuto?
---------
wish non è altro che l'interprete per il tcl/tk (estensioni grafiche della shell tclsh).
Quindi devi installare il Toolkit Tk e per farlo devi prima installare TCL (Tool Command Language).
Il pacchetto viene di solito fornito con qualunque distribuzione.
Creata l'immagine del nuovo kernel come posso verificarne la funzionalità in tutta sicurezza? Come posso creare una scelta multipla tra i kernel presenti?
---------
Do per scontato che tu abbia il tuo nuovo file bzImage nella directory /boot e che tu abbia già verificato che questo funzioni, tramite dischetto di avvio. A questo punto il tuo file /etc/lilo.conf dovrebbe risultare circa così:
boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
image=/boot/vmlinuz-2.0.36-3
label=linux
root=/dev/hda3
read-only
(eventuale altro sistema operativo)
dove vmlinuz-2.0.36-3 è il vecchio kernel e /dev/hda3 è la partizione root. Se invece di vmlinuz-2.0.36-3 si chiama semplicemente vmlinuz è meglio rinominarlo in questo modo:
# mv /boot/vmlinuz /boot/vmlinuz-2.0.36[Invio]
(al posto di 2.0.36 utilizza il numero della versione del vecchio kernel)
Ora, dovresti ad esempio chiamare l'immagine del kernel che vuoi provare 'vmlinuz-2.2.2':
# mv /boot/bzImage /boot/vmlinuz-2.2.2[Invio]
A questo punto non devi fare altro che duplicare una parte del tuo lilo.conf, così:
boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
image=/boot/vmlinuz-2.0.36-3 (o il nome del vecchio kernel)
label=linux
root=/dev/hda3
read-only
image=/boot/vmlinuz-2.2.2
label=prova
root=/dev/hda3
read-only
(eventuale altro sistema operativo)
Per installare LILO, devi dare il comando:
# lilo -v[Invio]
(-v ti dice ciò che sta facendo).
Quindi, riavvia il sistema e quando compare il prompt di LILO digitando prova entri con il nuovo kernel. Se qualcosa andasse storto, l'etichetta linux ti permette sempre di utilizzare il vecchio kernel.
Prima di eliminare del tutto il vecchio kernel, io proverei il nuovo per un certo periodo. Quando sei proprio soddisfatto, puoi modificare di nuovo il lilo.conf e cancellare la sezione del vecchio kernel e cambiare «prova» in «linux»:
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
image=/boot/vmlinuz-2.2.2
label=linux
root=/dev/hda3
read-only
(eventuale altro sistema operativo)
ridai il comando:
# lilo -v[Invio]
per rendere effettive le modifiche.
Voglio installare di nuovo la Suse 6, ma voglio portarmi dietro il kernel che ho ricompilato a fatica. Cosa devo copiare? Solo vmlinuz oppure anche la directory include? Cos'altro?
---------
Per poter 'esportare' il kernel sono necessari il file bzImage (zImage oppure vmlinuz o come avete chiamato l'immagine del kernel) presente generalmente in /boot, la directory /usr/src/linux/include e la dir /lib/modules/x.x.xx relativa alla versione del kernel.
Qualcuno sa che cos'è il file initrd-2.2.12-20.img che c'è in boot? L'ho riscontrato in RH 6.0.
---------
Cito da:
The Official Red Hat Linux Reference Guide
trovato sul sito di Red Hat:
An initrd image is needed for loading your SCSI module at boot time. The shell script /sbin/mkinitrd can build a proper initrd image for your machine if the following conditions are met:
The loopback block device is available.
The /etc/conf.modules file has a line for your SCSI adapter; for example: alias scsi_hostadapter BusLogic
Viene richiesta un'immagine initrd per caricare il vostro modulo SCSI all'avvio. Lo script shell /sbin/mkinitrd può costruire un'immagine initrd corretta per la vostra macchina se si presentano le seguenti condizioni:
È disponibile il dispositivo di blocco del loopback
Il file /etc/conf.modules presenta una riga per l'adattatore SCSI; ad esempio: alias scsi_hostadapter BusLogic
Quindi in pratica è un'immagine utilizzata per caricare il modulo SCSI all'avvio. La si può creare con il comando /sbin/mkinitrd.
C'è un modo per ricompilare il kernel ottimizzandolo per processori Pentium?
---------
Lo si può fare modificando il makefile che si trova in /usr/src/linux. In pratica bisogna cercare le voci:
HOSTCFLAGS
MAKE
CFLAGS
e modificare il loro contenuto nel seguente modo:
HOSTCFLAGS =-Wall -Wstrict-prototypes -O3 -march=pentium -mcpu=pentium -ffa st-math -funroll-loops -fomit-frame-pointer -fforce-mem -fforce-addr -malign-dou ble -fno-exceptions MAKE =make -j 4 CFLAGS := $(CPPFLAGS) -Wall -Wstrict-prototypes -O3 -march=pentium -mcpu=pentium -ffast-math -funroll-loops -fomit-frame-pointer -fforce-mem -fforce-addr -malig n-double -fno-exceptions
(nella versione 2.3.47 si trova CFLAGS := $(CPPFLAGS) mentre fino alla 2.2.14 c'è solo CFLAGS =).
È da notare che ho utilizzato come compilatore il pgcc (un compilatore gcc ottimizzato per processori pentium) che si trova nei contributi della Red Hat (sono naturalmente disponibili i pacchetti nei vari formati).
In pratica basta non installare o disinstallare l'egcs fornito dalla Red Hat e installare il pgcc.
Ho un problema con il kernel: sono nella directory /usr/src/linux e se da lì impartisco il comando make xconfig, la risposta è:
---------
make** no rule to make "xconfig"
nella directory di interesse c'è un file READ-ME dove dice che è necessario installare kernel-source binary RPM. Secondo il manuale si dovrebbe installare l'albero gerarchico dei file sorgente del kernel; che cosa devo fare?
Immagino che tu abbia una distribuzione Red Hat (ma il concetto è valido anche per altre distribuzioni); se è così monta il CD-ROM di installazione, vai nella directory dove ci sono tutti i pacchetti RPM:
# cd /mnt/cdrom/RedHat/RPMS[Invio]
e installa il pacchetto con i sorgenti del kernel:
# rpm -i kernel-source-XXXXX.i386.rpm[Invio]
(al posto delle X ci sarà la versione del kernel della tua distribuzione)
Ora nella directory /usr/src/linux troverai tutti i sorgenti del kernel e puoi riprovare con make xconfig.
Dove trovo nella compilazione del kernel l'opzione: IP: forwarding/gatewaying? L'ho cercata dappertutto (nella parte relativa alla rete, s'intende), ma non sono stato capace di trovarla.
---------
Non si tratta di un'opzione da compilare nel kernel ma di un parametro da impostare nel filesystem /proc. Il file in questione è /proc/sys/net/ipv4/ip_forward.
Se infatti esegui il comando 'cat' su questo file:
# cat /proc/sys/net/ipv4/ip_forward[Invio]
otterrai uno zero.
Quindi devi eseguire il seguente comando per portarlo al valore di uno:
# echo 1 > /proc/sys/net/ipv4/ip_forward[Invio]
poi ricontrolla con cat.
Ovviamente questa operazione va ripetuta ogni volta che esegui l'avvio (quindi va automatizzata). Se usi Red Hat è sufficiente portare a 'vero' «FORWARD_IPV4» presente nel file /etc/sysconfig/network.
Penso che anche altre distribuzioni offrano qualcosa di simile. Altrimenti inserisci il comando nel file /etc/rc.d/rc.local.
Dopo aver ricompilato il kernel 2.2.6 per configurare la mia macchina come firewall tramite ipfwadm, mi sono accorto che questa versione del kernel, a differenza di quanto accadeva con il kernel 2.0.32, non colloca il parametro 'ip_forward' in /proc/net (cioè quello che si aspetta ipfwadm), ma sotto: /proc/net/ipv4/
Qualcuno ha qualche idea del perché tutto ciò si verifica?
---------
Perché dai kernel della serie 2.2.X non si usa più ipfwadm ma ipchains.
Nel ricompilare il kernel 2.2.5 ho notato l'assenza dell'opzione drop source-routed frames mi è forse sfuggita?
---------
da /usr/src/linux/Documentation/Changes:
In 2.0.x the kernel could be configured to drop source routed IP packets via a compile time configuration option. In 2.2.x, this has been replaced by a sysctl.
Nei kernel della serie 2.0.x ci potrebbe essere la configurazione che (ri)lasci i pacchetti IP sorgenti (originali??) instradati mediante un'opzione di configurazione del tempo di compilazione. Nella serie 2.2.x, questa caratteristica è stata sostituita da un 'sysctl'.
Come faccio a controllare quali pacchetti del kernel ho installato? Utilizzo una distribuzione basata su rpm.
---------
Ecco come:
# rpm -qa | grep kernel | sort[Invio]
kernel - pacchetti rpm
Ci sono delle piccole precisazioni da fare sulla ricompilazione del kernel sulla Red Hat. Applicando le patch ufficiali al kernel fornito con la Red Hat (proveniente da rpm) ottengo una serie di errori (di solito non trova il file cui applicare la patch).
Provo ad installare un kernel 'ufficiale' e il medesimo file di patch non restituisce nessun messaggio di errore.
Ricompilo il kernel senza controllare i link /usr/include/[asm linux scsi] confidando nella Red Hat (a dire il vero senza pensarci sù) e con stupore mi accorgo di una serie di messaggi di avvertimento e di errori di compilazione legati ai file che gestiscono le periferiche SCSI.
Verifico l'esattezza dei link per prima cosa e mi accordo che Red Hat mette in /usr/include una directory SCSI e non un link simbolico.
Rinomino la directory, creo il link e ricompilo. Tutto torna a posto.
Red Hat inserisce una directory al posto del link simbolico e quindi si possono avere errori nella ricompilazione del kernel 'ufficiale' (intendendo quello scaricato da <www.kernel.org>).
In definitiva occorre verificare le seguenti predisposizioni:
/usr/include/linux -> ../src/linux/include/linux/ /usr/include/scsi -> ../src/linux/include/scsi/ /usr/include/asm -> ../src/linux/include/asm
e che ci sia in /usr/src/linux/include: asm -> asm-i386
Leggendo i messaggi sulle liste di discussione e nei gruppi di discussione, consiglierei di utilizzare una riga del genere per ricompilare il kernel:
# make dep;make clean;make bzImage > LOG-k 2> ERR-k;make modules > LOG-m 2> ERR-m[Invio]
in questo modo in una sola volta si ottengono i file di log (si reindirizza lo standard output su LOG-? con >)
e i file contententi gli avvertimenti e gli errori di compilazione (si reindirizza lo standard error su ERR-? con 2>).
Risulta quindi più facile individuare i problemi.
Ho ricompilato il kernel, ma rilevo 25 Mb in meno. Devo forse cancellare il vecchio kernel?
---------
Non il kernel, basta dare:
# make clean[Invio]
da /usr/src/linux.
Come si fa a dire al sistema di caricare all'avvio i file /boot/System.map corretti, a seconda dell'immagine del kernel che si è scelto di caricare?
---------
Devi fare una piccola modifica al file:
/etc/rc.d/init.d/syslog
Cerca la riga:
daemon klogd -k /boot/System.map
e modificala in:
daemon klogd -k /boot/System.map-`uname -r`
Copia in /boot il file System.map e rinominalo nel seguente modo:
# mv System.map System.map-`uname -r`[Invio]
installa i moduli fai un:
# depmod -a `uname -r`[Invio]
modifica il LILO e riavvialo.
Ho da poco installato e compilato il nuovo kernel stabile 2.2.12. Tutto bene nella fase di compilazione, il sistema parte regolarmente ma nella fase in cui carica i vari servizi (sendmail, gpm, atm, ecc.) appare un messaggio di avvertimento: /boot/Sistem.map... e mi dice che questo file punta ad una versione sbagliata del kernel; in effetti guardando in /boot ho:
lrwxrwxrwx 1 root root 19 Jun 5 14:38 System.map -> System.map-2.2.5-15 -rw-r--r-- 1 root root 186846 Apr 20 1999 System.map-2.2.5-15
Ora mi chiedo come posso generare il file Sistem.map-2.2.12 e se è un'operazione corretta. Posso anche spostare momentaneamente il file System.map affinché in avvio non venga letto?
---------
Quando ricompili il kernel devi copiare (una volta finita la compilazione) i seguenti file:
# cp /usr/src/linux/arch/i386/boot/bzImage /boot/vmlinuz-2.x.x[Invio]
e:
# cp /usr/src/linux/System.map /boot/System.map-2.x.x[Invio]
ed eventualmente se è necessario, aggiornare i collegamenti simbolici della directory /boot (a seconda della distribuzione).
Nella mia macchina ho da tempo installato la distribuzione Debian GNU/Linux 2.1 (che fornisce in maniera predefinita il kernel 2.0.36) ma ora volevo installare il kernel 2.2.10. Ho seguito i passi indicati negli HOWTO e va tutto bene fino a quando, lanciato il comando make zImage, ad un certo punto la creazione dell' immagine del kernel si ferma a causa del seguente errore:
make[1]: Entering directory '/prova/linux/arch/i386/boot'
as -0 -a -o bootsect.o bootsect.s
make[1]: as86: command not found
make[1]: *** [bootsect.o] Error 127
make[1]: Leaving directory '/prova/linux/arch/i386/boot'
make: *** [zImage] Error 2
Come faccio a risolvere il problema?
---------
Ti manca il pacchetto bin86 perché as86 fa parte di bin86.
Che vuol dire unresolved symbol? Ogni volta che si fa make modules e make modules_install bisogna rinominare la directory dei moduli (presente in /lib/modules)?
---------
Non tutti sanno che molti messaggi di 'unresolved symbol' dipendono dal fatto che il kernel nella parte monolitica è legato ai suoi moduli, per cui ogni volta prima di dare i comandi:
# make modules; make modules_install[Invio]
è necessario rinominare la vecchia directory.
Uso la Red Hat 6.0 che fornisce il kernel 2.2.5; ultimamente ho compilato ed installato il 2.2.9, solo che all'avvio del sistema mi appaiono tutta una serie di avvertimenti che mi fanno notare che la versione del kernel è sbagliata. Il sistema si avvia poi normalmente, c'è un modo per eliminare tutti quei fastidiosi messaggi o comunque comportano niente all'integrità del sistema?
---------
Probabilmente si tratta del file System.map che appartiene alla versione precedente del kernel. Io ho risolto il problema in modo pratico, trasformando /boot/System.map in un link simbolico a /usr/src/linux/System.map; in questo modo ogni volta che aggiornerai il kernel il collegamento farà sempre riferimento alla versione di System.map appena generata in fase di compilazione che si troverà sempre in /usr/src/linux/
Sono in possesso di una stampante HP LaserJet 5P che con il kernel 2.0.36 non mi ha mai dato nessun problema. Da quando ho aggiornato il kernel alla versione 2.2.3 (utilizzando i pacchetti rpm della Mandrake 5.3, che è la distribuzione che uso) non ne ha voluto più sapere di funzionare, anzi, mentre prima con il kernel 2.0.36 il printtool mi vedeva tranquillamente le porte parallele, ora mi comunica:
/dev/lp0 :not detected
/dev/lp1: not detected
/dev/lp2: not detected
---------
Inserisci in /etc/conf.modules le seguenti righe:
alias parport_lowlevel parport_pc options parport_pc io=0x378,0x278 irq=7,auto
Se provo ad inserire il modulo lp, non mi viene riconosciuta la porta parallela... Perché?
---------
Se non viene riconosciuta la porta parallela può dipendere dal fatto che in `/etc/conf.modules' manca la riga riguardante il modulo `parport_pc.o'. Basta aggiungere:
alias parport_lowlevel parport_pc
Se insomma si inserisce il modulo lp (mediante 'insmod lp') potrebbe non esserci la chiamata a lp0, per cui la riga 'modprobe lp' funziona se in /etc/conf.modules vi sono le dipendenze sopra descritte.
Uso Linux da parecchio tempo e su diverse macchine; su una mi capita sempre, quando provo a compilare il kernel, di riscontrare un errore particolare che penso sia dovuto a qualche problema nell'hardware, anche se non sono in grado di capire dove. Infatti, dopo un tempo casuale dall'inizio del make bzImage, viene visualizzato questo messaggio:
---------
Internal compiler error: program cc1 got fatal signal 11
e la compilazione si arresta. La compilazione dell'ultimo sorgente crea un file .o troncato (poche centinaia di byte) e ovviamente, prima di ripetere l'operazione, devo cancellarlo.
A cosa può essere dovuto? E in più, stranamente (visto che ovviamente ho messo anche una partizione di swap), certe volte capita che la compilazione si arresta col messaggio:
Memory exhausted
È un sintomo di malfunzionamento della RAM. Potrebbe essere difettosa.
Durante l'avvio ottengo il seguente messaggio:
LILO boot: , Loading linux ; No setup signature found.
E si ferma tutto. Cosa succede?
---------
Hai impartito il comando rdev per la nuova immagine del kernel?
# rdev /vmlinuz /dev/nome_della_partizione[Invio]
sostituisci /vmlinuz con la posizione esatta nel tuo filesystem dell'immagine del kernel (es. /boot/vmlinuz, /boot/vmlinuz-2.2.9, /boot/bzImage, ecc.)