Linux kernel makefile explicado

Para gerenciar e reduzir essa complexidade, os desenvolvedores de software organizam código em arquivos pequenos que vinculam a módulos específicos. Os desenvolvedores podem compilar cada um desses arquivos separadamente e depois vinculá -los para criar um software final executável.

Um exemplo disso são os projetos C compostos de arquivos de código -fonte em .c extensões e interfaces de software em .H extensões. Cada arquivo de origem é compilado junto com os arquivos de cabeçalho para criar. o Objetos ligados usando bibliotecas, criando assim arquivos executáveis.

Para executar esse processo, os desenvolvedores de software usam ferramentas, como fazer, para automatizar o processo de construção e dependências de arquivo necessárias. Faça usos makefiles para gerenciar o comportamento do processo de compilação.

O GNU Make Tools fornece um conjunto de regras e convenções usadas para criar arquivos make e reduzir a complexidade na melhoria da eficiência.

Neste tutorial, discutiremos o kernel Linux Makefiles, especificamente Kconfig e Kbuild.

Antes de começarmos, é bom observar que este artigo não finge ensinar tudo sobre o sistema de construção do kernel. No entanto, fornecemos uma visão geral de alto nível da construção de uma imagem e módulos VMLINUX.

Se você deseja obter informações além do escopo deste tutorial, recomendamos o seguinte recurso para obter melhores informações:

https: // linkfy.para/gomakefilesdocs

https: // linkfy.para/gnumake

Kernel Makefiles: uma visão geral

O sistema de construção do kernel, também chamado de sistema de configuração, é uma ferramenta essencial para aqueles que precisam-isso já existe há algum tempo. No entanto, nem todos usarão este sistema; Até os motoristas e outros desenvolvedores de software de baixo nível raramente o usam. Como você está lendo isso, significa que você quer saber mais sobre o sistema de construção do kernel.

Assim, discutiremos como o kernel é compilado e discutir o sistema Kbuild e Kconfig para que você possa entendê -los melhor.

O kernel makefile tem cinco componentes principais:

1. Makefile: Este é o arquivo de maquiagem superior localizado na raiz de origem.
2. arch/$ (arch) makefile: Este é o arco makefile; Atua como um suplemento ao topo makefile.
3. .Config: Este é o arquivo de configuração do kernel.
4. Scripts/makefile.*: Isso define regras definidas para todos os kbuild makefiles.
5. Kbuild makefiles: Existem cerca de 500 kbuild makefiles, e eles não são muito fáceis de ler. Considere um arquivo como:

https: // elixir.Bootlin.com/linux/mais recente/fonte/scripts/kbuild.incluir

Kconfig

O arquivo kconfig contém módulos que auxiliam ao usar a configuração de make *. Ajuda o kernel a fazer configurações seletivas, criando modularidade e personalização para o processo de construção do kernel.

Existem vários alvos de configuração especificados pelo sistema kconfig. Você pode usar a ajuda para visualizar os alvos disponíveis. Essas metas são processadas por vários programas fornecidos pelo kernel durante o processo de construção.

Alguns dos alvos kconfig incluem:

• Config: Isso é usado para atualizar o arquivo de configuração do kernel usando o programa de linha.
• Menuconfig: Este é um recurso ou mecanismo kconfig que oferece acesso baseado em menu às opções de kernel. Para lançar Menuconfig e outros recursos do KConfig, você deve estar dentro do diretório do projeto da plataforma. Você pode usar o seguinte para iniciar o recurso Kconfig Menuconfig. No entanto, você também pode lançar Menuconfig com outros recursos de configuração do kernel da GUI Linux, como Xconfig e Gconfig.

Faça Linux-Windriver.Menuconfig - Executa Menuconfig em uma sessão de terminal separada.

• gconfig e xconfig: GCONFIG ativa os recursos do kernel Linux baseados em GUI. O GConfig emprega a interface do usuário GTK ou baseada em (X). Por outro lado, o Xconfig utiliza a interface do usuário baseada em QT. Use os seguintes comandos para iniciar o GConfig e o XConfig, respectivamente:

Faça Linux-Windriver.gconfig
Faça Linux-Windriver.xconfig

OBSERVAÇÃO: Para usar GConfig e Xconfig, você deve ter as ferramentas de desenvolvimento QT instaladas no sistema host.

• NCONFIG: O recurso NCONFIG executa a configuração atual (BuildTools) e se aplica ao programa de menu Ncurses. Isso permite que você selecione os pacotes para construir, como CPU, drivers e sistema de arquivos ao criar o kernel. Use o comando: Make Nconfig.
• OldConfig: O recurso OldConfig permite que você aplique mais recente .arquivos de configuração para arquivos de configuração do kernel mais antigos. Por exemplo, um velho .arquivo de configuração e um mais recente .O arquivo de configuração (versão mais recente do kernel) terá diferenças, o que significa que você precisa atualizar a configuração atual antes da compilação do kernel. Você pode usar o Make OldConfig para atualizar a configuração antiga interativamente, aplicando opções ausentes no arquivo de configuração antigo.
• DefConfig: Esse recurso permite que o sistema de compilação do kernel adicione uma nova configuração fornecida por defconfig ao .arquivo de configuração. Mais precisamente, o sistema Kbuild verifica todos os arquivos KConfig. Se o DEFCONFIG especificar uma opção no arquivo, o sistema kbuild usa o valor especificado para adicionar a opção ao .Config. Se o DEFCONFIG não mencionar a opção, o kbuild usa valores padrão no .Config.

Considere o seguinte:

Instantâneo do código DEFCONFIG do seguinte recurso:

https: // elixir.Bootlin.com/linux/v5.9/fonte/scripts/kconfig/makefile#l98

1. Defconfig: $ (obj)/conf
2. ifneq ($ (selvagem $ (srctree)/arch/$ (srcarch)/configs/$ (kbuild_defconfig)),)
3. @$ (kecho) "*** A configuração padrão é baseada em '$ (kbuild_defconfig)'" "
4. $ (Q) $< $(silent) --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
5. outro
6. @$ (kecho) "*** A configuração padrão é baseada no Target '$ (kbuild_defconfig)'"
7. $ (Q) $ (make) -f $ (srctree)/makefile $ (kbuild_defconfig)
8. fim se
9.
10. %_defconfig: $ (obj)/conf
11. $ (Q) $< $(silent) --defconfig=arch/$(SRCARCH)/configs/$@ $(Kconfig)
12.
13. configfiles = $ (Wildcard $ (srctree)/kernel/configs/$@ $ (srctree)/arch/$ (srcarch)/configs/$@)
14.
15. %.Config: $ (obj)/conf
16. $ (se $ (ligue para o configfiles) ,, $ (erro não existe uma configuração para esse alvo nessa arquitetura))
17. $ (Q) $ (config_shell) $ (srctree)/scripts/kconfig/merge_config.sh -m .Config $ (configfiles)
18. $ (Q) $ (make) -f $ (srctree)/makefile OldDefconfig

Instantânea de código antigo do Código do Recurso a seguir:

https: // elixir.Bootlin.com/linux/v5.9/fonte/scripts/kconfig/conf.C#L694

1. Case OldDefconfig:
2. padrão:
3. quebrar;
4.
5.
6. if (input_mode == savedefconfig)
7. if (conf_write_defconfig (DEFCONFIG_FILE))
8. fprintf (stderr, "n *** erro ao salvar o DEFCONFIG para: %s \ n \ n",
9. DEFCONFIG_FILE);
10. retornar 1;
11.
12. else if (input_mode != ListNewConfig && input_mode != helpNewConfig)
13. se (!no_conf_write && conf_write (null))
14. fprintf (stderr, "\ n *** Erro durante a escrita da configuração.\ n \ n ");
15. saída (1);
16.
17.
18. /*
19. * Crie automático.confis se não existir.
20. * Isso impede o GNU fazer 4.1 ou mais de emitir
21. * "Incluir/config/auto.conf: nenhum arquivo ou diretório "
22. * no Makefile de nível superior
23. *
24. * SyncConfig sempre cria ou atualiza automaticamente.Conf porque é
25. * usado durante a construção.
26. */
27. if (conf_write_autoconf (sync_kconfig) && sync_kconfig)
28. fprintf (stderr,
29. "\ n *** erro durante a sincronização da configuração.\ n \ n ");
30. retornar 1;
31.
32.
33. retornar 0;
34.

• Savedefconfig: Esta regra salva o atual .configurar na forma de ./Defconfig, que é considerado um arquivo de configuração mínimo. Use o comando: Make SaveDefconfig
• ListNewConfig: Isso é usado para listar novas opções.
• Kvmconfig: Isso permite opções para suporte KVM. Use o comando: faça kvm_guest.Config
• AllyesConfig: Isso constrói um novo arquivo de configuração do kernel com todas as opções definidas como sim. É o oposto de Allnoconfig.
• AllmodConfig: Isso constrói uma nova configuração de kernel com a qual os módulos são ativados por padrão.
• RandConfig: Isso cria um novo arquivo de configuração do kernel com respostas aleatórias para todas as opções.
• Tinyconfig: Isso torna o menor kernel possível.

Existem muitos alvos no sistema Kconfig. Alguns comuns incluem Config e Menuconfig.

Como mencionado, os alvos são processados ​​por vários programas nos sistemas host, fornecendo uma GUI ou linha de comando. Você pode encontrar ferramentas kconfig em /scripts /kconfig na fonte do kernel.

https: // elixir.Bootlin.com/linux/mais recente/fonte/scripts/kconfig

https: // elixir.Bootlin.com/linux/mais recente/fonte/scripts/kconfig/makefile

O primeiro processo é geralmente ler o arquivo kconfig no diretório raiz, que é usado para criar um banco de dados de configuração inicial. À medida que o processo continua, o banco de dados é atualizado ao ler os arquivos na seguinte ordem:

.Config
/lib/módulos/$ (shell, uname-r)/.Config
/etc/kernel-config
/boot/config-$ (shell, uname-r)
Arch_defconfig
arch/$ (arch)/DefConfig

.O arquivo de configuração é então descartado para o SyncConfig, que aceita o .arquivo de configuração como entrada. Ele processa os arquivos e sai arquivos, que são classificados em várias categorias, como:

• Autoconf.H: Isso é usado para arquivos de fonte de idioma C.
• auto.conf e Tristate.conf: Estes são usados ​​para processamento de texto makefile.
• /inclui/config: Estes são arquivos de cabeçalho vazios usados ​​no rastreamento de dependência.

Arquivos kbuild

Quase todos os arquivos do kernel são kbuild makefiles que usam a infraestrutura Kbuild, que é um recurso de fabricação recursiva. A marca recursiva é uma maneira de usar a ferramenta Make como um comando em um makefile. A recursão é muito útil ao compilar um grande projeto.

Kbuild funciona referindo -se a todos os arquivos que mencionamos na seção acima.

O sistema Kbuild constrói seus componentes usando o topo makefile que inclui os arqui -makefiles com o nome arch/$ (arch)/makefile nos arquivos de configuração. Ele desce recursivamente para os subdiretos que invocam make nos componentes usando as rotinas em scripts/makefile.*. Kbuild então se baseia no objeto adjacente e os vincula aos objetos, criando vmllinux.

Para saber mais sobre a sintaxe usada em kbuild makefiles, consulte a documentação.

Considere o seguinte script.

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

Os arquivos de objeto O usados ​​para criar o vmllux são compilados primeiro em seus respectivos internos .a arquivos como o var kbuild_vmlinux_init, main, libs. Estes são compostos em vmlluxux.

https: // github.com/torvalds/linux/blob/master/scripts/makefile.construir

Conclusão

Neste guia, demos uma olhada nos sistemas Kbuild e Kconfig no sistema de construção do kernel e como ele funciona. Como mencionamos no início do tutorial, os tópicos discutidos são amplos e não podem ser abordados em um único tutorial.