Compilare un modulo senza ricompilare l'intero kernel Linux

Esiste una procedura molto semplice per compilare un modulo nativo non presente nel kernel della nostra distro; per far questo non è necessario ricompilare l'intero kernel, è possibile compilare direttamente il modulo o i moduli che ci interessano, tramite gli strumenti che gli sviluppatori ci mettono a disposizione.
In questa guida farò riferimento a Fedora 18, distro che ho utilizzato nei mie test; tuttavia la procedura, con l'eccezione della "preparazione" dei sorgenti, è in linea di massima valida per ogni altra distribuzione GNU/Linux.

Iniziamo verificando se il modulo che ci serve è stato effettivamente escluso dal kernel che stiamo utilizzando, onde evitarci un lavoro inutile; per far questo è sufficiente interrogare il file di configurazione del kernel, generalmente installato all'intero di /boot.
Se ad esempio volessimo controllare la presenza del modulo ntfs, ci basterebbe dare:

 $ grep -i ntfs /boot/config-$(uname -r)

Se l'output di risposta al nostro comando è questo:

# CONFIG_NTFS_FS is not set

è evidente che i package maintainer del kernel hanno effettuato la compilazione escludendo il supporto a tale modulo.

Procediamo quindi con l'installare i pacchetti necessari a compilare il modulo mancante:

$ sudo yum install yum-utils kernel-devel

Recuperiamo i sorgenti del kernel (nel momento in cui scrivo l'ultima release disponibile è la 3.8.2-206)

$ yumdownloader --source kernel

Scompattiamo il pacchetto con:

 $ rpm -ihv kernel-3.8.2-206.fc18.src.rpm

Installiamo le dipendenze di compilazione:

 $ sudo yum-builddep kernel-3.8.2-206.fc18.src.rpm

Scompattiamo i sorgenti e applichiamo le patch di Fedora, in modo da essere allineati con la versione fornita dalla distro:

 $ rpmbuild -bp --target=$(uname -m) ~/rpmbuild/SPECS/kernel.spec

Fatto questo all'interno della directory ~/rpmbuild/BUILD troveremo una sottodirectory contenente i sorgenti del kernel; spostiamoci al suo interno (nel mio caso, sistema 64bit e kernel 3.8.2-206):

$ cd ~/rpmbuild/BUILD/kernel-3.8.fc18/linux-3.8.2-206.fc18.x86_64/

Ipotizziamo di volere compilare il modulo ntfs visto prima; posizioniamoci nella relativa directory:

 $ cd fs/ntfs

Oltre ai sorgenti, nella directory troviamo un file Kconfig fondamentale per il nostro scopo; al suo interno sono specificate i parametri da passare a make per la compilazione. Apriamo Kconfig con un qualunque editor di testo facendo particolare attenzione alle voci "config" presenti nel file; troveremo:

config NTFS_FS
           tristate "NTFS file system support"
           [...]
 config NTFS_DEBUG
           bool "NTFS debugging support"
           [...]
config NTFS_RW
           bool "NTFS write support"
           [...]

"config NTS_FS" abilita la compilazione del modulo ntfs, "config NTFS_DEBUG" e "config NTFS_RW" sono invece parametri facoltativi che permettono di attivare funzionalità aggiunte ( rispettivamente l'abilitazione del debug e il montaggio dei filesystem NTFS in scrittura ).
Ora che abbiamo ottenuto tutte le informazioni che ci servivano, possiamo passare finalmente alla
compilazione del nostro modulo; per una compilazione "standard" senza opzioni aggiuntive è sufficiente dare:

 $ make -C /lib/modules/$(uname -r)/build M=$(pwd) CONFIG_NTFS_FS=m modules

 Invece se volessimo attivare tutte le opzioni di compilazione possibili daremo:

 $ make -C /lib/modules/$(uname -r)/build M=$(pwd) CONFIG_NTFS_FS=m CONFIG_NTFS_DEBUG=y CONFIG_NTFS_RW=y modules

Terminata la compilazione, possiamo installare il modulo con:

 $ sudo make -C /lib/modules/$(uname -r)/build M=$(pwd) modules_install

Per pulire la directory dai risultati delle nostre compilazioni scriviamo:

$ make -C /lib/modules/$(uname -r)/build M=$(pwd) clean

Proviamo a caricare il modulo per verificarne il corretto funzionamento:

$ sudo modprobe --verbose ntfs

Se ci viene restituito l'errore:

   modprobe: FATAL: Module ntfs not found.

eseguiamo:

$ sudo depmode -a

quindi proviamo a ripetere il caricamento del modulo con modprobe.
E' tutto! Come avete potuto notare, in pochi minuti e in maniera tutt'altro che complicata, siamo riusciti a compilare e installare un modulo nativo del kernel risparmiando un enorme quantità di tempo rispetto ad un completa ricompilazione.