Spiegazione del Makefile del kernel Linux

Nello sviluppo del software, il processo di creazione e gestione di repository di codice di grandi dimensioni può diventare molto complesso facilmente.

Per gestire e ridurre questa complessità, gli sviluppatori di software organizzano il codice in piccoli file che si collegano a moduli specifici. Gli sviluppatori possono compilare ciascuno di questi file separatamente e quindi collegarli insieme per creare un eseguibile software finale.

Un esempio di ciò sono i progetti C costituiti da file di codice sorgente in .c estensioni e interfacce software in .estensioni h. Ogni file sorgente viene compilato insieme ai file di intestazione da creare. o oggetti collegati tra loro tramite librerie, creando così file eseguibili.

Per eseguire questo processo, gli sviluppatori di software utilizzano strumenti, come Make, per automatizzare il processo di compilazione e le dipendenze dei file richieste. Make utilizza i Makefile per gestire il comportamento del processo di compilazione.

Gli strumenti GNU Make forniscono un insieme di regole e convenzioni utilizzate per creare Makefile e ridurre la complessità nel migliorare l'efficienza.

In questo tutorial, discuteremo i Makefile del kernel Linux, in particolare Kconfig e Kbuild.

Prima di iniziare, è bene notare che questo articolo non pretende di insegnare tutto sul sistema Kernel Build. Tuttavia, forniamo una panoramica di alto livello sulla creazione di un'immagine e dei moduli vmlinux.

Se desideri informazioni oltre lo scopo di questo tutorial, ti consigliamo la seguente risorsa per maggiori informazioni:

https://linkfy.to/goMakefilesDocs

https://linkfy.a/gnuMake

Makefile del kernel: una panoramica

Il Kernel Build System, chiamato anche sistema di configurazione, è uno strumento essenziale, per chi ne ha bisogno, che esiste da un po' di tempo. Tuttavia, non tutti utilizzeranno questo sistema; anche i driver e altri sviluppatori di software di basso livello lo usano raramente. Dal momento che stai leggendo questo, significa che vuoi saperne di più sul Kernel Build System.

Quindi, discuteremo come viene compilato il kernel e discuteremo il sistema Kbuild e Kconfig in modo che tu possa capirli meglio.

Il Kernel Makefile ha cinque componenti principali:

Makefile: Questo è il file make superiore che si trova nella radice dei sorgenti.
arch/$(ARCH) Makefile: Questo è l'arco Makefile; funge da supplemento al Makefile superiore.
.configurazione: Questo è il file di configurazione del kernel.
Script/Makefile.*: Questo definisce le regole impostate per tutti i Makefile kbuild.
Makefile Kbuild: Ci sono circa 500 Makefile kbuild e non sono molto facili da leggere. Considera un file come:

https://elixir.bootlin.com/linux/latest/source/scripts/Kbuild.includere

Kconfig

Il file Kconfig contiene moduli che aiutano quando si usa make *config. Aiuta il kernel a effettuare configurazioni selettive, creando modularità e personalizzazione per il processo di costruzione del kernel.

Ci sono vari obiettivi di configurazione specificati dal sistema Kconfig. Puoi usare l'aiuto di make per visualizzare i target disponibili. Questi target vengono elaborati da vari programmi forniti dal kernel durante il processo di compilazione.

Alcuni dei target di Kconfig includono:

Configurazione: Questo è usato per aggiornare il file di configurazione del kernel usando il programma di linea.
Configurazione menu: Questa è una funzionalità o un meccanismo di Kconfig che offre accesso basato su menu alle opzioni del kernel. Per avviare menuconfig e altre funzionalità di Kconfig, dovresti trovarti nella directory del progetto della piattaforma. Puoi usare quanto segue per avviare la funzione menuconfig di Kconfig. Tuttavia, puoi anche avviare menuconfig con altre funzionalità di configurazione del kernel Linux della GUI come xconfig e gconfig.
gconfig e xconfig: Gconfig attiva le funzionalità del kernel Linux basate su GUI. Gconfig utilizza l'interfaccia utente basata su GTK o (basata su X). D'altra parte, Xconfig utilizza un'interfaccia utente basata su Qt. Usa i seguenti comandi per avviare rispettivamente gconfig e xconfig:

fare linux-windriver.gconfig
fare linux-windriver.xconfig

NOTA: Per usare gconfig e xconfig, dovresti avere gli strumenti di sviluppo QT installati sul sistema host.

Nconfig: La funzione Nconfig esegue la configurazione corrente (Buildtools) e si applica al programma guidato da menu di Ncurses. Ciò consente di selezionare i pacchetti da compilare, come CPU, driver e filesystem durante la compilazione del kernel. Usa il comando: make nconfig.
Vecchia configurazione: La funzione oldconfig ti consente di applicare più recente .file di configurazione in file di configurazione del kernel precedenti. Per esempio, un vecchio .config e uno più recente .Il file di configurazione (versione del kernel più recente) avrà delle differenze, il che significa che è necessario aggiornare la configurazione corrente prima della compilazione del kernel. Puoi usare make oldconfig per aggiornare la vecchia configurazione in modo interattivo applicando le opzioni mancanti nel vecchio file di configurazione.
Configurazione def: Questa funzionalità consente al sistema di compilazione del kernel di aggiungere una nuova configurazione fornita da defconfig al .file di configurazione. Più precisamente, il sistema Kbuild controlla tutti i file Kconfig. Se defconfig specifica un'opzione nel file, il sistema Kbuild usa il valore specificato per aggiungere l'opzione a .config. Se il defconfig non menziona l'opzione, Kbuild usa i valori predefiniti nel in .config.

Considera quanto segue:

Snapshot del codice Defconfig dalla seguente risorsa:

https://elixir.bootlin.com/linux/v5.9/source/scripts/kconfig/Makefile#L98

1. defconfig: $(obj)/conf
2. ifneq ($(carattere jolly $(srctree)/arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG)),)
3. @$(kecho) "*** La configurazione predefinita è basata su '$(KBUILD_DEFCONFIG)'"
4. $(Q)$< $(silent) --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
5. altro
6. @$(kecho) "*** La configurazione predefinita è basata sul target '$(KBUILD_DEFCONFIG)'"
7. $(Q)$(MAKE) -f $(srctree)/Makefile $(KBUILD_DEFCONFIG)
8. finisci se
9.
10. %_defconfig: $(obj)/conf
11. $(Q)$< $(silent) --defconfig=arch/$(SRCARCH)/configs/$@ $(Kconfig)
12.
13. configfiles=$(carattere jolly $(srctree)/kernel/configs/$@ $(srctree)/arch/$(SRCARCH)/configs/$@)
14.
15. %.config: $(obj)/conf
16. $(if $(call configfiles),, $(error Nessuna configurazione esistente per questo target su questa architettura))
17. $(Q)$(CONFIG_SHELL) $(srctree)/scripts/kconfig/merge_config.sh -m .config $(file di configurazione)
18. $(Q)$(MAKE) -f $(srctree)/Makefile olddefconfig

Snapshot del codice Oldconfig dalla seguente risorsa:

https://elixir.bootlin.com/linux/v5.9/source/scripts/kconfig/conf.c#L694

1. caso olddefconfig:
2. predefinito:
3. rompere;
4.
5.
6. if (input_mode == saveefconfig)
7. if (conf_write_defconfig(defconfig_file))
8. fprintf(stderr, "n*** Errore durante il salvataggio di defconfig in: %s\n\n",
9. defconfig_file);
10. ritorno 1;
11.
12. else if (input_mode != listnewconfig && input_mode != helpnewconfig)
13. Se (!no_conf_write && conf_write(NULL))
14. fprintf(stderr, "\n*** Errore durante la scrittura della configurazione.\n\n");
15. uscita(1);
16.
17.
18. /*
19. * Crea auto.conf se non esiste.
20. * Questo impedisce a GNU Make 4.1 o più dall'emissione
21. * "include/config/auto.conf: nessun file o directory di questo tipo"
22. * nel Makefile di primo livello
23. *
24. * syncconfig crea o aggiorna sempre automaticamente.conf perché lo è
25. * utilizzato durante la compilazione.
26. */
27. if (conf_write_autoconf(sync_kconfig) && sync_kconfig)
28. fprintf(stderr,
29. "\n*** Errore durante la sincronizzazione della configurazione.\n\n");
30. ritorno 1;
31.
32.
33. restituisce 0;
34.

Savedefconfig: Questa regola salva la corrente .config sotto forma di ./defconfig, che è considerato un file di configurazione minimo. Usa il comando: make saveefconfig
Listnewconfig: Questo è usato per elencare nuove opzioni.
Kvmconfig: Ciò abilita le opzioni per il supporto KVM. Usa il comando: make kvm_guest.config
Allyesconfig: Questo crea un nuovo file di configurazione del kernel con tutte le opzioni impostate su yes. È l'opposto di allnoconfig.
Allmodconfig: Questo crea una nuova configurazione del kernel con cui i moduli sono abilitati per impostazione predefinita.
Randconfig: Questo crea un nuovo file di configurazione del kernel con risposte casuali a tutte le opzioni.
Tinyconfig: Questo rende possibile il kernel più piccolo.

Ci sono molti obiettivi nel sistema Kconfig. Alcuni comuni includono config e menuconfig.

Come accennato, i target vengono elaborati da vari programmi nei sistemi host, fornendo una GUI o una riga di comando. Puoi trovare gli strumenti di Kconfig in /scripts/Kconfig nei sorgenti del kernel.

https://elixir.bootlin.com/linux/latest/source/scripts/kconfig

https://elixir.bootlin.com/linux/latest/source/scripts/kconfig/Makefile

Il primo processo è di solito leggere il file Kconfig nella directory principale, che viene utilizzato per creare un database di configurazione iniziale. Man mano che il processo continua, il database viene aggiornato durante la lettura dei file nel seguente ordine:

.config
/lib/modules/$(shell,uname-r)/.config
/etc/kernel-config
/boot/config-$(shell,uname-r)
ARCH_DEFCONFIG
arch/$(ARCH)/defconfig

.config viene quindi rilasciato in syncconfig, che accetta il .file di configurazione come input. Elabora il file e genera file, che vengono quindi classificati in varie categorie come:

autoconf.h: Questo è usato per i file sorgente del linguaggio C.
auto.conf e tristate.conf: Questi sono usati per l'elaborazione del testo Makefile.
/include/config: Questi sono file di intestazione vuoti utilizzati nel monitoraggio delle dipendenze.

File Kbuild

Quasi tutti i file del kernel sono Kbuild Makefile che utilizzano l'infrastruttura Kbuild, che è una funzionalità di creazione ricorsiva. Recursive Make è un modo di usare lo strumento Make come comando in un Makefile. La ricorsione è molto utile quando si compila un progetto di grandi dimensioni.

Kbuild funziona facendo riferimento a tutti i file che abbiamo menzionato nella sezione precedente.

Il sistema Kbuild costruisce i suoi componenti usando il Makefile superiore che include i Makefile arch con il nome arch/$(ARCH)/Makefile nei file di configurazione. Scende ricorsivamente nelle sottodirectory invocando Make sui componenti usando le routine in scripts/Makefile.*. Kbuild quindi si basa sull'oggetto adiacente e li collega in oggetti, creando vmlinux.

Per saperne di più sulla sintassi usata in Kbuild Makefile, fai riferimento alla documentazione.

Considera il seguente script.

https://github.com/torvalds/linux/blob/master/scripts/link-vmlinux.sh

I file oggetto o usati per creare il vmlinux vengono compilati per primi nei rispettivi built-in .un file come var KBUILD_VMLINUX_INIT,MAIN,LIBS. Questi sono composti in vmlinux.

https://github.com/torvalds/linux/blob/master/scripts/Makefile.costruire

Conclusione

In questa guida, abbiamo dato un'occhiata ai sistemi Kbuild e Kconfig nel sistema di build del kernel e come funziona. Come accennato all'inizio del tutorial, gli argomenti discussi sono ampi e non possono essere trattati in un singolo tutorial.