Phenquestions
Para gerenciar e reduzir essa complexidade, os desenvolvedores de software organizam o código em pequenos arquivos vinculados a módulos específicos. Os desenvolvedores podem compilar cada um desses arquivos separadamente e, em seguida, vinculá-los para criar um executável de software final.
Um exemplo disso são os projetos C compostos de arquivos de código-fonte em .extensões c e interfaces de software em .extensões h. Cada arquivo de origem é compilado junto com os arquivos de cabeçalho para criar. o objetos ligados entre si usando bibliotecas, criando assim arquivos executáveis.
Para executar esse processo, os desenvolvedores de software usam ferramentas, como Make, para automatizar o processo de construção e as dependências de arquivo necessárias. O Make usa Makefiles para gerir o comportamento do processo de compilação.
As ferramentas GNU Make fornecem um conjunto de regras e convenções usadas para criar Makefiles e reduzir a complexidade na melhoria da eficiência.
Neste tutorial, discutiremos os Makefiles do kernel do Linux, especificamente Kconfig e Kbuild.
Antes de começar, é bom notar que este artigo não pretende ensinar tudo sobre o sistema Kernel Build. No entanto, fornecemos uma visão geral de alto nível da construção de uma imagem vmlinux e módulos.
Se desejar 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 Kernel Build System, também chamado de sistema de configuração, é uma ferramenta essencial - para quem precisa - que já existe há algum tempo. No entanto, nem todos usarão este sistema; até mesmo drivers e outros desenvolvedores de software de baixo nível raramente o usam. Já que você está lendo isso, significa que deseja saber mais sobre o Sistema de Compilação de Kernel.
Assim, vamos discutir 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:
- Makefile: Este é o arquivo principal localizado na raiz de origem.
- arch / $ (ARCH) Makefile: Este é o Arch Makefile; ele atua como um suplemento para o Makefile principal.
- .config: Este é o arquivo de configuração do Kernel.
- Scripts / Makefile.*: Isto define as regras definidas para todos os Makefiles kbuild.
- Makefiles do Kbuild: Existem cerca de 500 Makefiles kbuild, e eles não são muito fáceis de ler. Considere um arquivo como:
https: // elixir.bootlin.com / linux / mais recente / source / scripts / Kbuild.incluir
Kconfig
O arquivo Kconfig contém módulos que ajudam ao usar o make * config. Ajuda o Kernel a fazer configurações seletivas, criando modularidade e personalizabilidade para o processo de construção do Kernel.
Existem vários alvos de configuração especificados pelo sistema Kconfig. Você pode usar o make help para visualizar os alvos disponíveis. Esses alvos são processados por vários programas fornecidos pelo Kernel durante o processo de construção.
Alguns dos alvos do 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 do Kconfig que oferece acesso baseado em menu às opções do Kernel. Para iniciar o 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 de menuconfig do Kconfig. No entanto, você também pode iniciar o menuconfig com outros recursos de configuração do kernel do Linux GUI, como xconfig e gconfig. fazer linux-windriver.menuconfig - Executa o menuconfig em uma sessão de terminal separada.
- gconfig e xconfig: Gconfig ativa recursos de kernel Linux baseados em GUI. Gconfig emprega a interface de usuário baseada em GTK ou (baseada em X). Por outro lado, o Xconfig utiliza IU baseada em Qt. Use os seguintes comandos para iniciar gconfig e xconfig, respectivamente:
fazer linux-windriver.xconfig
NOTA: 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 baseado em menu Ncurses. Isso permite que você selecione os pacotes a serem construídos, como CPU, drivers e sistema de arquivos ao construir o Kernel. Use o comando: make nconfig.
- Oldconfig: O recurso oldconfig permite que você aplique os mais novos .arquivos de configuração para arquivos de configuração do kernel mais antigos. Por exemplo, um antigo .arquivo de configuração e um mais recente .arquivo de configuração (versão de kernel mais recente) terá diferenças, o que significa que você precisa atualizar a configuração atual antes de construir o kernel. Você pode usar make oldconfig para atualizar a configuração antiga interativamente aplicando as opções que faltam no arquivo de configuração antigo.
- Defconfig: Este 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 defconfig especifica uma opção no arquivo, o sistema Kbuild usa o valor especificado para adicionar a opção ao .config. Se o defconfig não menciona a opção, o Kbuild usa os valores padrão no .config.
Considere o seguinte:
Instantâneo do código Defconfig do seguinte recurso:
https: // elixir.bootlin.com / linux / v5.9 / source / scripts / kconfig / Makefile # L98
1. defconfig: $ (obj) / conf2. ifneq ($ (wildcard $ (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. senão
6. @ $ (kecho) "*** A configuração padrão é baseada no destino '$ (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. $ (if $ (call configfiles) ,, $ (error Nenhuma configuração existe para este destino nesta arquitetura))
17. $ (Q) $ (CONFIG_SHELL) $ (srctree) / scripts / kconfig / merge_config.sh -m .config $ (configfiles)
18. $ (Q) $ (MAKE) -f $ (srctree) / Makefile olddefconfig
Instantâneo do código Oldconfig do seguinte recurso:
https: // elixir.bootlin.com / linux / v5.9 / source / scripts / kconfig / conf.c # L694
1. case olddefconfig:2. padrão:
3. pausa;
4.
5.
6. if (input_mode == savedefconfig)
7. if (conf_write_defconfig (defconfig_file))
8. fprintf (stderr, "n *** Erro ao salvar defconfig em:% s \ n \ n",
9. defconfig_file);
10. return 1;
11.
12. else if (input_mode != listnewconfig && input_mode != helpnewconfig)
13. E se (!no_conf_write && conf_write (NULL))
14. fprintf (stderr, "\ n *** Erro durante a gravação da configuração.\ n \ n ");
15. saída (1);
16.
17.
18. / *
19. * Criar auto.conf se não existe.
20. * Isso evita que o GNU Make 4.1 ou mais velho de emitir
21. * "include / config / auto.conf: Esse arquivo ou diretório não existe "
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. return 1;
31.
32.
33. return 0;
34.
- Savedefconfig: Esta regra salva o atual .configuração 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 ativa opções para suporte KVM. Use o comando: make kvm_guest.config
- Allyesconfig: Isso cria um novo arquivo de configuração do kernel com todas as opções definidas como sim. É o oposto de allnoconfig.
- Allmodconfig: Isso cria uma nova configuração do kernel com a qual os módulos são habilitados 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.
Conforme mencionado, os destinos 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 / source / scripts / kconfig
https: // elixir.bootlin.com / linux / mais recente / source / scripts / kconfig / Makefile
O primeiro processo geralmente é ler o arquivo Kconfig no diretório raiz, que é usado para construir um banco de dados de configuração inicial. Conforme o processo continua, o banco de dados é atualizado ao ler os arquivos na seguinte ordem:
.config/ lib / modules / $ (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 em syncconfig, que aceita o .arquivo de configuração como entrada. Ele processa o arquivo e gera arquivos, que são classificados em várias categorias, como:
- autoconf.h: Isso é usado para arquivos fonte da linguagem 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 Kernel são Kbuild Makefiles que usam a infraestrutura Kbuild, que é um recurso de make recursivo. Make recursivo é uma forma de usar a ferramenta Make como um comando em um Makefile. A recursão é muito útil ao compilar um grande projeto.
O Kbuild funciona referindo-se a todos os arquivos que mencionamos na seção acima.
O sistema Kbuild constrói seus componentes usando o Makefile superior que inclui os Makefiles de arch com o nome arch / $ (ARCH) / Makefile nos arquivos de configuração. Ele desce recursivamente em subdiretórios invocando Make nos componentes usando as rotinas em scripts / Makefile.*. O Kbuild então se baseia no objeto adjacente e os vincula aos objetos, criando o vmlinux.
Para aprender mais sobre a sintaxe usada nos Kbuild Makefiles, consulte a documentação.
Considere o seguinte script.
https: // github.com / torvalds / linux / blob / master / scripts / link-vmlinux.sh
Os arquivos objeto o usados para criar o vmlinux são compilados primeiro em seus respectivos built-in .a arquivos como var KBUILD_VMLINUX_INIT, MAIN, LIBS. Estes são compostos em vmlinux.
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 compilação do Kernel e como eles funcionam. Como mencionamos no início do tutorial, os tópicos discutidos são amplos e não podem ser cobertos em um único tutorial.
