Linux kernel versione 4.x http://kernel.org/

Queste sono le note di rilascio per Linux versione 4. Leggile con attenzione, poiché ti spiegano di cosa si tratta, come installare il kernel e cosa fare se qualcosa va storto.

COS'È LINUX?

Linux è un clone del sistema operativo Unix, scritto da zero da Linus Torvalds con l'assistenza di un team informale di hacker sparsi su Internet. Mira alla conformità con POSIX e con la Single UNIX Specification.

Ha tutte le funzionalità che ci si aspetterebbe da uno Unix moderno e completo, incluso il vero multitasking, la memoria virtuale, le librerie condivise, il caricamento on-demand, gli eseguibili condivisi copy-on-write, una corretta gestione della memoria e il networking multistack, inclusi IPv4 e IPv6.

È distribuito sotto la GNU General Public License - consulta il file COPYING allegato per maggiori dettagli.

SU QUALE HARDWARE GIRA?

Sebbene originariamente sviluppato per PC basati su x86 a 32 bit (386 o superiori), oggi Linux gira anche (almeno) sulle architetture Compaq Alpha AXP, Sun SPARC e UltraSPARC, Motorola 68000, PowerPC, PowerPC64, ARM, Hitachi SuperH, Cell, IBM S/390, MIPS, HP PA-RISC, Intel IA-64, DEC VAX, AMD x86-64, AXIS CRIS, Xtensa, Tilera TILE, AVR32 e Renesas M32R.

Linux è facilmente portabile sulla maggior parte delle architetture general-purpose a 32 o 64 bit, purché abbiano una unità di gestione della memoria a pagine (PMMU) e un porting del compilatore GNU C (gcc) (parte della GNU Compiler Collection, GCC). Linux è stato anche portato su alcune architetture senza PMMU, sebbene in tal caso la funzionalità sia ovviamente alquanto limitata. Linux è stato inoltre portato a sé stesso: ora puoi eseguire il kernel come applicazione in spazio utente, chiamata UserMode Linux (UML).

DOCUMENTAZIONE:

C'è molta documentazione disponibile sia in formato elettronico su Internet sia in libri, sia specifica per Linux sia relativa a questioni UNIX generali. Consiglio di consultare le sottodirectory di documentazione su qualsiasi sito FTP Linux per i libri del LDP (Linux Documentation Project). Questo README non vuole essere una documentazione sul sistema: ci sono fonti molto migliori disponibili.
Nella sottodirectory Documentation/ ci sono vari file README: in genere contengono note di installazione specifiche del kernel per alcuni driver, per esempio. Consulta Documentation/00-INDEX per un elenco di ciò che è contenuto in ogni file. Leggi anche il file Changes, poiché contiene informazioni sui problemi che potrebbero derivare dall'aggiornamento del kernel.
La sottodirectory Documentation/DocBook/ contiene diverse guide per sviluppatori e utenti del kernel. Queste guide possono essere generate in diversi formati: PostScript (.ps), PDF, HTML e pagine man, tra gli altri. Dopo l'installazione, "make psdocs", "make pdfdocs", "make htmldocs" o "make mandocs" genereranno la documentazione nel formato richiesto.

INSTALLAZIONE dei sorgenti del kernel:

Se installi i sorgenti completi, metti il tarball del kernel in una directory su cui hai i permessi (ad es. la tua home directory) ed estrailo:

xz -cd linux-4.X.tar.xz | tar xvf -

Sostituisci "X" con il numero di versione dell'ultimo kernel.

NON usare l'area /usr/src/linux! Quest'area contiene un set (di solito incompleto) di header del kernel usati dai file header delle librerie. Devono corrispondere alla libreria e non devono essere rovinati da qualunque kernel-del-giorno ci sia in circolazione.
Puoi anche passare da una release 4.x all'altra tramite patch. Le patch sono distribuite nel formato xz. Per installare tramite patch, procurati tutti i file di patch più recenti, entra nella directory di livello superiore dei sorgenti del kernel (linux-4.X) ed esegui:

xz -cd ../patch-4.x.xz | patch -p1

Sostituisci "x" per tutte le versioni successive alla versione "X" del tuo albero dei sorgenti attuale, in ordine, e dovresti essere a posto. Potresti voler rimuovere i file di backup (some-file-name~ o some-file-name.orig) e assicurarti che non ci siano patch fallite (some-file-name# o some-file-name.rej). Se ce ne sono, o tu o io abbiamo commesso un errore.

A differenza delle patch per i kernel 4.x, le patch per i kernel 4.x.y (noti anche come kernel -stable) non sono incrementali, ma si applicano direttamente al kernel base 4.x. Per esempio, se il tuo kernel di base è 4.0 e vuoi applicare la patch 4.0.3, non devi applicare prima le patch 4.0.1 e 4.0.2. Allo stesso modo, se stai usando la versione del kernel 4.0.2 e vuoi passare alla 4.0.3, devi prima annullare la patch 4.0.2 (cioè patch -R) prima di applicare la patch 4.0.3. Puoi leggere ulteriori informazioni in Documentation/applying-patches.txt

In alternativa, lo script patch-kernel può essere usato per automatizzare questo processo. Determina la versione corrente del kernel e applica tutte le patch trovate.

linux/scripts/patch-kernel linux

Il primo argomento del comando sopra è la posizione dei sorgenti del kernel. Le patch vengono applicate dalla directory corrente, ma è possibile specificare una directory alternativa come secondo argomento.
Assicurati di non avere file .o obsoleti e dipendenze in giro:

cd linux make mrproper

A questo punto dovresti avere i sorgenti installati correttamente.

REQUISITI SOFTWARE

La compilazione e l'esecuzione dei kernel 4.x richiedono versioni aggiornate di vari pacchetti software. Consulta Documentation/Changes per i numeri di versione minimi richiesti e per sapere come ottenere gli aggiornamenti per questi pacchetti. Attenzione: l'uso di versioni eccessivamente vecchie di questi pacchetti può causare errori indiretti molto difficili da rintracciare, quindi non dare per scontato di poter semplicemente aggiornare i pacchetti quando si presentano problemi evidenti durante la compilazione o il funzionamento.

DIRECTORY di build per il kernel:

Quando si compila il kernel, tutti i file di output saranno per impostazione predefinita memorizzati insieme al codice sorgente del kernel. L'uso dell'opzione "make O=output/dir" consente di specificare una posizione alternativa per i file di output (incluso .config). Esempio:

 kernel source code: /usr/src/linux-4.X
 build directory:    /home/name/build/kernel

Per configurare e compilare il kernel, usa:

 cd /usr/src/linux-4.X
 make O=/home/name/build/kernel menuconfig
 make O=/home/name/build/kernel
 sudo make O=/home/name/build/kernel modules_install install

Nota: se si usa l'opzione 'O=output/dir', essa deve essere usata per tutte le invocazioni di make.

CONFIGURAZIONE del kernel:

Non saltare questo passaggio anche se stai solo aggiornando una versione minore. In ogni release vengono aggiunte nuove opzioni di configurazione e si presenteranno problemi strani se i file di configurazione non sono impostati come previsto. Se vuoi portare la tua configurazione esistente a una nuova versione con il minimo sforzo, usa "make oldconfig", che ti chiederà solo le risposte alle nuove domande.

I comandi di configurazione alternativi sono:

"make config" Interfaccia a testo semplice.

"make menuconfig" Menù colorati basati su testo, elenchi radio e finestre di dialogo.

"make nconfig" Menù colorati basati su testo migliorati.

"make xconfig" Strumento di configurazione basato su X windows (Qt).

"make gconfig" Strumento di configurazione basato su X windows (Gtk).

"make oldconfig" Assegna un valore predefinito a tutte le domande in base al contenuto del tuo file ./.config esistente e chiede informazioni sui nuovi simboli di configurazione.

"make silentoldconfig" Come sopra, ma evita di riempire lo schermo con domande a cui è già stato risposto. Aggiorna inoltre le dipendenze.

"make olddefconfig" Come sopra, ma imposta i nuovi simboli ai loro valori predefiniti senza chiedere conferma.

"make defconfig" Crea un file ./.config usando i valori predefiniti dei simboli da arch/$ARCH/defconfig o da arch/$ARCH/configs/${PLATFORM}_defconfig, a seconda dell'architettura.

"make ${PLATFORM}_defconfig" Crea un file ./.config usando i valori predefiniti dei simboli da arch/$ARCH/configs/${PLATFORM}_defconfig. Usa "make help" per ottenere un elenco di tutte le piattaforme disponibili per la tua architettura.

"make allyesconfig" Crea un file ./.config impostando i valori dei simboli a 'y' il più possibile.

"make allmodconfig" Crea un file ./.config impostando i valori dei simboli a 'm' il più possibile.

"make allnoconfig" Crea un file ./.config impostando i valori dei simboli a 'n' il più possibile.

"make randconfig" Crea un file ./.config impostando i valori dei simboli a valori casuali.

"make localmodconfig" Crea una configurazione basata sulla configurazione corrente e sui moduli caricati (lsmod). Disabilita qualsiasi opzione di modulo non necessaria per i moduli caricati.
```
                    Per creare una localmodconfig per un'altra macchina,
                    salva l'lsmod di quella macchina in un file
                    e passalo come parametro LSMOD.

            target$ lsmod > /tmp/mylsmod
            target$ scp /tmp/mylsmod host:/tmp

            host$ make LSMOD=/tmp/mylsmod localmodconfig

                    Quanto sopra funziona anche durante la compilazione incrociata.
```
"make localyesconfig" Simile a localmodconfig, tranne per il fatto che convertirà tutte le opzioni dei moduli in opzioni integrate (=y).

Puoi trovare ulteriori informazioni sull'uso degli strumenti di configurazione del kernel Linux in Documentation/kbuild/kconfig.txt.
NOTE su "make config":
- Avere driver non necessari rende il kernel più grande e può, in alcune circostanze, causare problemi: il rilevamento di una scheda controller inesistente può confondere gli altri controller
- Compilare il kernel con "Processor type" impostato su un valore superiore a 386 produrrà un kernel che NON funziona su un 386. Il kernel lo rileverà all'avvio e si fermerà.
- Un kernel con l'emulazione matematica compilata userà comunque il coprocessore, se presente: in quel caso l'emulazione matematica non verrà mai usata. Il kernel sarà leggermente più grande, ma funzionerà su macchine diverse, indipendentemente dal fatto che abbiano o meno un coprocessore matematico.
- I dettagli di configurazione "kernel hacking" di solito producono un kernel più grande o più lento (o entrambi) e possono persino rendere il kernel meno stabile configurando alcune routine per tentare attivamente di rompere il codice difettoso per individuare problemi del kernel (kmalloc()). Pertanto, dovresti probabilmente rispondere 'n' alle domande relative alle funzionalità "development", "experimental" o "debugging".

COMPILAZIONE del kernel:

Assicurati di avere almeno gcc 3.2 disponibile. Per maggiori informazioni, consulta Documentation/Changes.

Nota che puoi ancora eseguire programmi utente a.out con questo kernel.
Esegui un "make" per creare un'immagine compressa del kernel. È anche possibile eseguire "make install" se hai lilo installato in modo compatibile con i makefile del kernel, ma potresti voler verificare prima la tua specifica configurazione di lilo.

Per eseguire l'installazione vera e propria, devi essere root, ma nessuna delle normali operazioni di build dovrebbe richiederlo. Non nominare root invano.
Se hai configurato alcune parti del kernel come `modules', dovrai anche eseguire "make modules_install".
Output verboso di compilazione/build del kernel:

Normalmente, il sistema di build del kernel opera in modalità abbastanza silenziosa (ma non del tutto). Tuttavia, a volte tu o altri sviluppatori del kernel avete bisogno di vedere i comandi di compilazione, collegamento o altri comandi esattamente come vengono eseguiti. Per questo, usa la modalità di build "verbose". Ciò si ottiene inserendo "V=1" nel comando "make". Ad es.:

make V=1 all

Per fare in modo che il sistema di build indichi anche il motivo della ricompilazione di ogni target, usa "V=2". Il valore predefinito è "V=0".
Tieni a portata di mano un kernel di backup nel caso qualcosa vada storto. Questo vale soprattutto per le release di sviluppo, poiché ogni nuova release contiene codice nuovo che non è stato ancora sottoposto a debug. Assicurati di conservare anche un backup dei moduli corrispondenti a quel kernel. Se stai installando un nuovo kernel con lo stesso numero di versione del kernel funzionante, fai un backup della directory dei moduli prima di eseguire "make modules_install".

In alternativa, prima di compilare, usa l'opzione di configurazione del kernel "LOCALVERSION" per aggiungere un suffisso univoco alla versione normale del kernel. LOCALVERSION può essere impostata nel menù "General Setup".
Per avviare il tuo nuovo kernel, dovrai copiare l'immagine del kernel (ad es. .../linux/arch/i386/boot/bzImage dopo la compilazione) nel punto in cui si trova il tuo kernel avviabile normale.
L'avvio di un kernel direttamente da floppy senza l'assistenza di un bootloader come LILO non è più supportato.

Se avvii Linux dal disco fisso, è probabile che tu usi LILO, che usa l'immagine del kernel specificata nel file /etc/lilo.conf. Il file dell'immagine del kernel è di solito /vmlinuz, /boot/vmlinuz, /bzImage o /boot/bzImage. Per usare il nuovo kernel, salva una copia della vecchia immagine e copia la nuova immagine sopra quella vecchia. Poi, DEVI RIESEGUIRE LILO per aggiornare la mappa di caricamento!! Se non lo fai, non sarai in grado di avviare la nuova immagine del kernel.

Reinstallare LILO di solito significa eseguire /sbin/lilo. Potresti voler modificare /etc/lilo.conf per specificare una voce per la tua vecchia immagine del kernel (ad esempio /vmlinux.old) nel caso quella nuova non funzioni. Consulta la documentazione di LILO per maggiori informazioni.

Dopo aver reinstallato LILO, dovresti essere a posto. Spegni il sistema, riavvia e goditelo!

Se mai avessi bisogno di cambiare il device root predefinito, la modalità video, la dimensione del ramdisk, ecc. nell'immagine del kernel, usa il programma 'rdev' (o, quando appropriato, le opzioni di avvio di LILO). Non è necessario ricompilare il kernel per cambiare questi parametri.
Riavvia con il nuovo kernel e goditelo.

SE QUALCOSA VA STORTO:

Se hai problemi che sembrano dovuti a bug del kernel, controlla il file MAINTAINERS per vedere se c'è una persona specifica associata alla parte del kernel con cui hai problemi. Se non c'è nessuno elencato lì, la seconda cosa migliore è inviarli a me ([email protected]) e possibilmente a qualsiasi altra mailing-list o newsgroup pertinente.
In tutte le segnalazioni di bug, per favore indica di quale kernel stai parlando, come riprodurre il problema e qual è la tua configurazione (usa il buon senso). Se il problema è nuovo, dillo, e se il problema è vecchio, cerca di indicare quando lo hai notato per la prima volta.
Se il bug produce un messaggio come

unable to handle kernel paging request at address C0000010 Oops: 0002 EIP: 0010:XXXXXXXX eax: xxxxxxxx ebx: xxxxxxxx ecx: xxxxxxxx edx: xxxxxxxx esi: xxxxxxxx edi: xxxxxxxx ebp: xxxxxxxx ds: xxxx es: xxxx fs: xxxx gs: xxxx Pid: xx, process nr: xx xx xx xx xx xx xx xx xx xx xx

o informazioni di debug del kernel simili sullo schermo o nel log di sistema, per favore riportalo esattamente. Il dump può sembrarti incomprensibile, ma contiene informazioni che possono aiutare a fare debug del problema. Anche il testo sopra il dump è importante: dice qualcosa sul motivo per cui il kernel ha eseguito il dump del codice (nell'esempio sopra, è dovuto a un puntatore del kernel non valido). Ulteriori informazioni su come interpretare il dump si trovano in Documentation/oops-tracing.txt
Se hai compilato il kernel con CONFIG_KALLSYMS puoi inviare il dump così com'è, altrimenti dovrai usare il programma "ksymoops" per interpretare il dump (ma compilare con CONFIG_KALLSYMS è di solito preferibile). Questa utility può essere scaricata da ftp://ftp..kernel.org/pub/linux/utils/kernel/ksymoops/ . In alternativa, puoi fare la ricerca nel dump a mano:
Nel fare debug di dump come quello sopra, aiuta enormemente se riesci a capire cosa significa il valore EIP. Il valore esadecimale in sé non aiuta molto me o chiunque altro: dipende dalla tua particolare configurazione del kernel. Quello che dovresti fare è prendere il valore esadecimale dalla riga EIP (ignora "0010:") e cercarlo nella namelist del kernel per vedere quale funzione del kernel contiene l'indirizzo incriminato.

Per scoprire il nome della funzione del kernel, dovrai trovare il binario di sistema associato al kernel che ha mostrato il sintomo. Questo è il file 'linux/vmlinux'. Per estrarre la namelist e confrontarla con l'EIP del crash del kernel, esegui:

nm vmlinux | sort | less

Questo ti darà un elenco di indirizzi del kernel ordinati in ordine crescente, dal quale è semplice trovare la funzione che contiene l'indirizzo incriminato. Nota che l'indirizzo fornito dai messaggi di debug del kernel non corrisponderà necessariamente in modo esatto agli indirizzi delle funzioni (in effetti, è molto improbabile), quindi non puoi semplicemente fare 'grep' sull'elenco: l'elenco ti fornirà comunque il punto di partenza di ogni funzione del kernel, quindi cercando la funzione che ha un indirizzo iniziale inferiore a quello che stai cercando ma è seguita da una funzione con un indirizzo superiore, troverai quella che vuoi. In effetti, può essere una buona idea includere un po' di "contesto" nella tua segnalazione di problema, aggiungendo alcune righe attorno a quella interessante.

Se per qualche motivo non puoi fare quanto sopra (hai un'immagine del kernel precompilata o simili), dirmi il più possibile sulla tua configurazione aiuterà. Leggi il documento REPORTING-BUGS per i dettagli.
In alternativa, puoi usare gdb su un kernel in esecuzione (in sola lettura; cioè non puoi modificare i valori o impostare breakpoint). Per fare questo, prima compila il kernel con -g; modifica arch/i386/Makefile in modo appropriato, poi esegui "make clean". Dovrai anche abilitare CONFIG_PROC_FS (tramite "make config").

Dopo aver riavviato con il nuovo kernel, esegui "gdb vmlinux /proc/kcore". Ora puoi usare tutti i soliti comandi di gdb. Il comando per cercare il punto in cui il tuo sistema è andato in crash è "l *0xXXXXXXXX" (sostituisci le XXX con il valore EIP).

Fare gdb su un kernel non in esecuzione attualmente fallisce perché gdb (erroneamente) ignora l'offset iniziale per cui il kernel è compilato.