Explicación del archivo Makefile del kernel de Linux

En el desarrollo de software, el proceso de crear y administrar grandes repositorios de código puede volverse muy complejo fácilmente.

Para administrar y reducir esta complejidad, los desarrolladores de software organizan el código en pequeños archivos que se vinculan a módulos específicos. Los desarrolladores pueden compilar cada uno de estos archivos por separado y luego vincularlos para crear un software ejecutable final.

Un ejemplo de esto son los proyectos C compuestos por archivos de código fuente en .c extensiones e interfaces de software en .h extensiones. Cada archivo de origen se compila junto con los archivos de encabezado para crear. o objetos vinculados entre sí mediante bibliotecas, creando así archivos ejecutables.

Para realizar este proceso, los desarrolladores de software utilizan herramientas, como Make, para automatizar el proceso de compilación y las dependencias de archivos requeridas. Hacer usos Makefiles para gestionar el comportamiento del proceso de compilación.

Las herramientas GNU Make proporcionan un conjunto de reglas y convenciones que se utilizan para crear Makefiles y reducir la complejidad para mejorar la eficiencia.

En este tutorial, discutiremos los Makefiles del kernel de Linux, específicamente Kconfig y Kbuild.

Antes de comenzar, es bueno tener en cuenta que este artículo no pretende enseñar todo sobre el sistema Kernel Build. Sin embargo, proporcionamos una descripción general de alto nivel de la creación de una imagen y módulos de vmlinux.

Si desea obtener información más allá del alcance de este tutorial, le recomendamos el siguiente recurso para obtener una mejor información:

https: // linkfy.to / goMakefilesDocs

https: // linkfy.a / gnuMake

Kernel Makefiles: una descripción general

El Kernel Build System, también llamado sistema de configuración, es una herramienta esencial, para aquellos que la necesitan, que existe desde hace un tiempo. Sin embargo, no todo el mundo utilizará este sistema; incluso los controladores y otros desarrolladores de software de bajo nivel rara vez lo usan. Ya que está leyendo esto, significa que quiere saber más sobre el sistema de compilación del kernel.

Por lo tanto, discutiremos cómo se compila el Kernel y discutiremos el sistema Kbuild y Kconfig para que pueda comprenderlos mejor.

El Kernel Makefile tiene cinco componentes principales:

1. Makefile: Este es el archivo de creación superior ubicado en la raíz de origen.
2. arch / $ (ARCH) Makefile: Este es el archivo Makefile arch; actúa como un complemento del Makefile superior.
3. .config: Este es el archivo de configuración del Kernel.
4. Scripts / Makefile.*: Esto define reglas establecidas para todos los Makefiles de kbuild.
5. Kbuild Makefiles: Hay alrededor de 500 kbuild Makefiles, y no son muy fáciles de leer. Considere un archivo como:

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

Kconfig

El archivo Kconfig contiene módulos que ayudan al usar la configuración make *. Ayuda al Kernel a realizar configuraciones selectivas, creando modularidad y personalización para el proceso de construcción del Kernel.

Hay varios destinos de configuración especificados por el sistema Kconfig. Puede utilizar la ayuda de make para ver los objetivos disponibles. Estos objetivos son procesados ​​por varios programas proporcionados por el Kernel durante el proceso de compilación.

Algunos de los objetivos de Kconfig incluyen:

• Config: Esto se usa para actualizar el archivo de configuración del kernel usando el programa de línea.
• Menuconfig: Esta es una función o mecanismo de Kconfig que ofrece acceso basado en menús a las opciones del Kernel. Para iniciar menuconfig y otras funciones de Kconfig, debe estar dentro del directorio del proyecto de la plataforma. Puede utilizar lo siguiente para iniciar la función menuconfig de Kconfig. Sin embargo, también puede iniciar menuconfig con otras funciones de configuración del kernel de Linux GUI como xconfig y gconfig.
hacer linux-windriver.menuconfig: ejecuta menuconfig en una sesión de terminal separada.
• gconfig y xconfig: Gconfig activa las funciones del kernel de Linux basadas en GUI. Gconfig emplea la interfaz de usuario basada en GTK o (basada en X). Por otro lado, Xconfig utiliza una interfaz de usuario basada en Qt. Utilice los siguientes comandos para iniciar gconfig y xconfig, respectivamente:

hacer linux-windriver.gconfig
hacer linux-windriver.xconfig

NOTA: Para usar gconfig y xconfig, debe tener las herramientas de desarrollo QT instaladas en el sistema host.

• Nconfig: La función Nconfig ejecuta la configuración actual (Buildtools) y se aplica al programa controlado por menús de Ncurses. Esto le permite seleccionar los paquetes para compilar, como CPU, controladores y sistema de archivos al compilar el Kernel. Usa el comando: make nconfig.
• Oldconfig: La función oldconfig le permite aplicar nuevos .archivos de configuración a archivos de configuración de kernel más antiguos. Por ejemplo, un viejo .config archivo y una más reciente .El archivo de configuración (versión más reciente del kernel) tendrá diferencias, lo que significa que debe actualizar la configuración actual antes de la compilación del kernel. Puede usar make oldconfig para actualizar la configuración anterior de forma interactiva aplicando las opciones que faltan en el archivo de configuración anterior.
• Defconfig: Esta característica permite que el sistema de compilación del kernel agregue una nueva configuración proporcionada por defconfig al .archivo de configuración. Más precisamente, el sistema Kbuild comprueba todos los archivos Kconfig. Si defconfig especifica una opción en el archivo, el sistema Kbuild usa el valor especificado para agregar la opción al archivo .config. Si defconfig no menciona la opción, Kbuild usa valores predeterminados en el .config.

Considera lo siguiente:

Instantánea del código Defconfig del siguiente recurso:

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

1. defconfig: $ (obj) / conf
2. ifneq ($ (comodín $ (srctree) / arch / $ (SRCARCH) / configs / $ (KBUILD_DEFCONFIG)),)
3. @ $ (kecho) "*** La configuración predeterminada se basa en '$ (KBUILD_DEFCONFIG)'"
4. $ (Q) $< $(silent) --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
5. demás
6. @ $ (kecho) "*** La configuración predeterminada se basa en el objetivo '$ (KBUILD_DEFCONFIG)'"
7. $ (Q) $ (HACER) -f $ (árbol de origen) / Makefile $ (KBUILD_DEFCONFIG)
8. terminara si
9.
10. % _defconfig: $ (obj) / conf
11. $ (Q) $< $(silent) --defconfig=arch/$(SRCARCH)/configs/$@ $(Kconfig)
12.
13. configfiles = $ (comodín $ (srctree) / kernel / configs / $ @ $ (srctree) / arch / $ (SRCARCH) / configs / $ @)
14.
15. %.config: $ (obj) / conf
dieciséis. $ (if $ (llamar configfiles) ,, $ (error No existe configuración para este objetivo en esta arquitectura))
17. $ (Q) $ (CONFIG_SHELL) $ (srctree) / scripts / kconfig / merge_config.sh -m .config $ (archivos de configuración)
18. $ (Q) $ (MAKE) -f $ (srctree) / Makefile olddefconfig

Instantánea del código de Oldconfig del siguiente recurso:

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

1. caso olddefconfig:
2. defecto:
3. rotura;
4.
5.
6. if (input_mode == savedefconfig)
7. if (conf_write_defconfig (defconfig_file))
8. fprintf (stderr, "n *** Error al guardar defconfig en:% s \ n \ n",
9. defconfig_file);
10. return 1;
11.
12. más si (modo_entrada != listnewconfig && input_mode != helpnewconfig)
13. Si (!no_conf_write && conf_write (NULL))
14. fprintf (stderr, "\ n *** Error durante la escritura de la configuración.\ n \ n ");
15. salida (1);
dieciséis.
17.
18. / *
19. * Crear auto.conf si no existe.
20. * Esto evita que GNU Make 4.1 o más de emitir
21. * "incluir / config / auto.conf: No existe tal archivo o directorio "
22. * en el Makefile de nivel superior
23. *
24. * syncconfig siempre crea o actualiza automáticamente.conf porque es
25. * utilizado durante la construcción.
26. * /
27. if (conf_write_autoconf (sync_kconfig) && sync_kconfig)
28. fprintf (stderr,
29. "\ n *** Error durante la sincronización de la configuración.\ n \ n ");
30. return 1;
31.
32.
33. return 0;
34.

• Savedefconfig: Esta regla guarda la corriente .config en forma de ./ defconfig, que se considera un archivo de configuración mínimo. Utilice el comando: hacer savedefconfig
• Listnewconfig: Esto se usa para listar nuevas opciones.
• Kvmconfig: Esto habilita opciones para soporte KVM. Utilice el comando: make kvm_guest.config
• Allyesconfig: Esto crea un nuevo archivo de configuración del kernel con todas las opciones configuradas en sí. Es lo opuesto a allnoconfig.
• Allmodconfig: Esto crea una nueva configuración de kernel con los módulos habilitados de forma predeterminada.
• Randconfig: Esto crea un nuevo archivo de configuración del kernel con respuestas aleatorias a todas las opciones.
• Tinyconfig: Esto hace posible el kernel más pequeño.

Hay muchos objetivos en el sistema Kconfig. Algunos comunes incluyen config y menuconfig.

Como se mencionó, los objetivos son procesados ​​por varios programas en los sistemas host, ya sea proporcionando una GUI o una línea de comando. Puede encontrar las herramientas de Kconfig en / scripts / Kconfig en el código fuente del kernel.

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

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

El primer proceso suele ser leer el archivo Kconfig en el directorio raíz, que se utiliza para construir una base de datos de configuración inicial. A medida que continúa el proceso, la base de datos se actualiza al leer archivos en el siguiente orden:

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

.El archivo de configuración luego se coloca en syncconfig, que acepta la .archivo de configuración como entrada. Procesa el archivo y los archivos de salida, que luego se clasifican en varias categorías, tales como:

• autoconf.h: Esto se usa para archivos fuente en lenguaje C.
• auto.conf y tristate.conf: Estos se utilizan para el procesamiento de texto Makefile.
• / incluye / config: Estos son archivos de encabezado vacíos que se utilizan en el seguimiento de dependencias.

Archivos Kbuild

Casi todos los archivos de Kernel son Kbuild Makefiles que utilizan la infraestructura de Kbuild, que es una función de creación recursiva. Make recursivo es una forma de usar la herramienta Make como un comando en un Makefile. La recursividad es muy útil al compilar un proyecto grande.

Kbuild funciona refiriéndose a todos los archivos que mencionamos en la sección anterior.

El sistema Kbuild construye sus componentes utilizando el Makefile superior que incluye los archivos Makefiles arch con el nombre arch / $ (ARCH) / Makefile en los archivos de configuración. Desciende recursivamente a subdirectorios invocando Make en los componentes usando las rutinas en scripts / Makefile.*. Kbuild luego se basa en el objeto adyacente y los vincula en objetos, creando vmlinux.

Para obtener más información sobre la sintaxis utilizada en Kbuild Makefiles, consulte la documentación.

Considere el siguiente guión.

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

Los archivos de objeto o utilizados para crear vmlinux se compilan primero en sus respectivos archivos integrados .a archivos como var KBUILD_VMLINUX_INIT, MAIN, LIBS. Estos están compuestos en vmlinux.

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

Conclusión

En esta guía, echamos un vistazo a los sistemas Kbuild y Kconfig en el sistema de compilación Kernel y cómo funciona. Como mencionamos al comienzo del tutorial, los temas tratados son amplios y no se pueden cubrir en un solo tutorial.