Introduzione

I miei setup si basano su un sistema composto dai seguenti componenti:

• Distro:  Gentoo Linux
• Kernel Compression:  LZ4 per l'initramfs, zstd per zswap
• Initramfs:  Dracut
• Bootloader:  GRUB
• Init:  OpenRC
• Filesystem:  FAT32 per l' ESP, XFS per il RootFS, ext4 per varie.
• Logind:  elogind

Vi sono tre configurazioni di default:

1. config:  ThinkPad T470p, con CPU i7-7820HQ (Kaby Lake, 4C8T), Nvidia GeForce 940MX dGPU + Intel HD 630 iGPU, SATAIII/NVMe SSD, 2560x1440 display.
2. config.t440p:  ThinkPad T440p, con CPU i7-4700MQ (Haswell, 4C8T), Intel HD4600 iGPU, SATAIII SSD, 1366x768 display.
3. config.pc:  PC personalizzato, con CPU i5-11400 (Rocket Lake, 6C12T), Intel UHD 730 iGPU, NVMe SSD.

Verificate che i componenti desiderati siano abilitati nel Kernel, qualora venga usata la mia configurazione come punto di partenza. Ad esempio, componenti relativi ad AMD, Nvidia (non su T470p), NUMA, ecc. sono stati disabilitati.

Se non sapete da dove partire, usate una configurazione già esistente che sapete funzioni sul vostro hardware, se disponibile, altrimenti usate la configurazione di default di un qualsiasi Kernel, come quella fornita dalla vostra distro, o la configurazione di default del Kernel.

Setup

Assicuratevi di avere tutti gli strumenti necessari per poter proseguire. Verificate di avere git, gcc, make, ecc. Tipicamente, la maggior parte di strumenti per la compilazione viene fornita da pacchetti come base-devel. Consiglio di verificare anche la presenza di linux-firmware, in modo tale da avere i necessari firmware per eventuali componentistiche nonfree. Non dimenticate di scaricare il microcode adatto, che sia Intel, AMD, o altro. Infine, verificate la presenza di lz4 e zstd, per la compressione di vari componenti del Kernel., 

Utenti Gentoo: è altamente consigliato l'uso di sys-kernel/installkernel per creare automaticamente l'initramfs ed aggiornare la configurazione del bootloader, rispettando le vostre preferenze di sistema (e.g. initramfs->dracut, bootloader->GRUB)., 

1. Ottenimento repository

Useremo la directory /usr/src/usr-kernel per salvare questo progetto, e tutte le eventuali modifiche.
Assicuratevi di avere permessi di lettura e scrittura, in modo tale da poter creare la directory.

git clone --recurse-submodules \
https://github.com/saloniamatteo/kernel /usr/src/usr-kernel

cd /usr/src/usr-kernel

2. Selezione versione

Una volta scaricata la repository, scegliete una versione disponibile. Per vedere le versioni disponibili, basta vedere i contenuti della directory con ls:

$ ls
6.12.8-gentoo # <-- Kernel config
bore-scheduler
clear-patches
kernel_compiler_patch
patches
v4l2loopback
build.sh
README.md

In questo esempio, utilizzeremo Linux 6.12.8-gentoo.

3. Modifica script

A questo punto, non ci resta che verificare il contenuto di build.sh. Modifichiamo il file con qualsiasi editor di testo, e osserviamo le seguenti variabili:

• CUSTDIR:  cartella che contiene questo progetto. Default: /usr/src/usr-kernel
• KVER:  versione primaria Kernel.
• PVER:  versione secondaria/personalizzata Kernel.
• KERNELDIR:  directory che contiene i vari Kernel. Default: /usr/src
• JOBS:  quanti thread usare per la compilazione. Valore consigliato: numero di core fisici.
• CONFIGFILE:  il nome del file di configurazione, che verrà copiato dalla directory al Kernel. Default: config

4. Selezione flag

Dopo aver modificato build.sh, bisogna selezionare i necessari parametri per poter stabilire quali azioni intraprendere.
Segue ora una tabella con tutti i vari parametri (flag).

5. Configurazione Kernel

Tipicamente, sarà necessario andare a configurare il Kernel, partendo da un file di configurazione. Per fare ciò, basterà eseguire il seguente comando come utente root:

./build.sh -l -m -p

Questo ci permetterà di:

• -l:  Applicare le patch di Clear Linux
• -m:  Configurare il Kernel con make menuconfig
• -p:  Applicare le patch incluse

Una volta terminato il processo di configurazione del Kernel, il nuovo file di configurazione sarà disponibile presso /usr/src/linux/.config (oppure sotto $KERNELDIR/.config qualora KERNELDIR fosse stato impostato).

A questo punto bisognerà copiare il file .config dalla directory del Kernel alla directory del Kernel scelto (in questo caso 6.12.8-gentoo), per poi confrontare i due file e controllare eventuali cambiamenti:

cp /usr/src/linux/.config 6.12.8-gentoo/config.new
diff -u 6.12.8-gentoo/config{,.new} | vim

L'ultimo comando esegue il comando diff, mostrando le differenze tra il nostro file di partenza config ed il nuovo file config.new, per poi mostrare il tutto con l'editor Vim. Ovviamente, bisogna modificare il nome del file config nel comando sopra qualora fosse necessario (esempio: si usa una config personalizzata)

Notate il 6.12.8-gentoo in entrambi i comandi: modificatelo quando usate una versione del Kernel diversa.

Dopo aver verificato le eventuali differenze, sostituiamo il nostro file config con il file config.new, e passiamo alla vera e propria compilazione del Kernel:

mv 6.12.8-gentoo/config{.new,}

6. Compilazione Kernel

Dopo essere sicuri di avere tutto il necessario, è possibile compilare il Kernel con il seguente comando, eseguendolo come utente root:

./build.sh -f -l -p

Notate la presenza ripetuta delle opzioni di patch (-l, -p). Questo perchè lo script, in automatico, ripristina tutti i cambiamenti effettuati dalle patch presenti nella directory del Kernel, ove possibile, e rimuove gli eventuali file patch. È un comportamento voluto, in quanto ci aiuta a ridurre gli errori causati da patch malformate, non applicate correttamente, non volute, e/o errori vari.

Al termine dell'esecuzione, grazie ad installkernel, verrà generato l'initramfs, ed aggiornerà il bootloader. Con la mia configurazione questi corrispondono a dracut e grub. Ovviamente spetterà a voi configurare installkernel prima di installare il Kernel.

Extra

Questa sezione specifica gli eventuali passaggi da effettuare dopo aver terminato la compilazione del Kernel, che non dipendono dallo script. Usando lo script, non sarà necessario aggiornare manualmente nè l'initramfs, nè il bootloader, perchè verranno aggiornati in automatico (vedi sopra).

V4L2loopback

Lo script installerà questo modulo per la versione del Kernel compilata. L'unico passaggio da effettuare è aggiungere le impostazioni del modulo, in quanto lo script non controlla se sono già presenti o meno.

Modificate il file /etc/modprobe.d/v4l2loopback.conf, ed inserite il seguente contenuto:

options v4l2loopback exclusive_caps=1 card_label="Camera2"

Qui potete modificare card_label per impostare il nome del dispositivo, qualora fosse necessario, ad esempio se si volesse mascherare il fatto che questo è un dispositivo virtuale, o se semplicemente volete un nome migliore.

Initramfs

Per avviare il Kernel è necessario un initramfs. Per generarlo, userò dracut.

Prima di tutto, accertatevi di aver configurato dracut. Ad esempio, ecco il mio /etc/dracut.conf:

# Equivalent to -H
hostonly="yes"

# Add various modules
# Module: description
# ==================================
# base: include basic utilities
# dash: include /bin/dash as /bin/sh
# fs-lib: include filesystem tools like mount
# kernel-modules: include kernel modules
# rescue: include various utils for rescue mode
# resume: allow initramfs to resume from low-power state
# rootfs-block: mount block device that contains rootfs
# shutdown: set up hooks to run on shutdown
# udev-rules: include udev and some basic rules
# usrmount: mount /usr
dracutmodules+=" base dash fs-lib kernel-modules rescue resume rootfs-block shutdown udev-rules usrmount "

# Do not include bash (we use dash)
omit_dracutmodules="bash"

# Include elogind
install_items="/lib64/elogind/elogind-uaccess-command"

# Use lz4 to compress the initramfs
compress="lz4"

# Add early microcode loading
early_microcode="yes"

È sufficiente eseguire il seguente comando:

dracut --kver 6.8.2-gentoo -f

Modificate 6.8.2-gentoo con la versione del vostro Kernel. Attenzione al flag -f: forza la generazione dell'initramfs, anche se già esiste per la versione del Kernel interessata.

Fatto ciò, l'initramfs sarà disponibile sotto /boot, insieme ai file del Kernel precedentemente compilato.

Bootloader

Per avviare il nostro nuovo Kernel, sarà necessario configurare il bootloader. In questa sezione vedremo solo GRUB2.

La maggior parte degli utenti, arrivati a questo punto, sicuramente avranno già un sistema funzionante, ed un bootloader configurato. Questo quindi ci richiede semplicemente un aggiornamento della configurazione, senza modificare ulteriori file.

Perciò, è necessario eseguire come utente root:

grub-mkconfig -o /boot/grub/grub.cfg

Il comando ci comunicherà i Kernel (ed eventuali altri sistemi operativi) trovati, che saranno disponibili al riavvio del nostro sistema, oltre a comunicarci i microcode trovati.