Linux Kernel Makefile explicó

Para administrar y reducir esta complejidad, los desarrolladores de software organizan el código en archivos pequeños 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 ejecutable de software final.

Un ejemplo de esto es los proyectos C compuestos por archivos de código fuente en .C extensiones e interfaces de software en .H extensiones. Cada archivo fuente se compila junto con los archivos de encabezado para crear. o Objetos vinculados juntos usando bibliotecas, creando así archivos ejecutables.

Para realizar este proceso, los desarrolladores de software usan 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 de fabricación de GNU proporcionan un conjunto de reglas y convenciones utilizadas para crear mapas y reducir la complejidad para mejorar la eficiencia.

En este tutorial, discutiremos los kernel de Linux, específicamente Kconfig y Cebo.

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

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

https: // linkfy.a/gomakeFilesdocs

https: // linkfy.a/gnumake

Kernel Makefiles: una descripción general

El sistema de compilación del kernel, también llamado sistema de configuración, es una herramienta esencial para aquellos que lo necesitan, que ha existido por un tiempo. Sin embargo, no todos usarán este sistema; Incluso los conductores y otros desarrolladores de software de bajo nivel rara vez lo usan. Como estás leyendo esto, significa que quieres saber más sobre el sistema de construcción del núcleo.

Por lo tanto, discutiremos cómo se compila el núcleo y discutiremos el sistema KBuild y Kconfig para que pueda entenderlos mejor.

El kernel makfile tiene cinco componentes centrales:

1. Makefile: Este es el archivo de fabricación superior ubicado en la raíz de origen.
2. Arch/$ (Arch) Makefile: Este es el arco Makefile; Actúa como un suplemento para el mejor makile.
3. .Configuración: Este es el archivo de configuración del kernel.
4. Scripts/makfile.*: Esto define reglas establecidas para todos los kbuild makfiles.
5. Kbuild Makfiles: Hay alrededor de 500 kbuild makfiles, y no son muy fáciles de leer. Considere un archivo como:

https: // elixir.bootlin.com/linux/ortat/source/scripts/kbuild.incluir

Kconfig

El archivo kconfig contiene módulos que ayudan cuando se usa la configuración Make *. Ayuda al núcleo a hacer configuraciones selectivas, creando modularidad y personalización para el proceso de compilación del núcleo.

Hay varios objetivos de configuración especificados por el sistema KConfig. Puede usar la ayuda para ver los objetivos disponibles. Estos objetivos son procesados ​​por varios programas proporcionados por el núcleo durante el proceso de compilación.

Algunos de los objetivos de KConfig incluyen:

• Configuración: Esto se utiliza para actualizar el archivo de configuración del kernel utilizando el programa de línea.
• Menuconfig: Esta es una característica o mecanismo de Kconfig que ofrece acceso basado en menú a las opciones de kernel. Para iniciar Menuconfig y otras características de KConfig, debe estar dentro del directorio de proyectos de plataforma. Puede usar lo siguiente para iniciar la función Kconfig menuconfig. Sin embargo, también puede iniciar Menuconfig con otras características de configuración del kernel de GUI Linux como XConfig y GConfig.

Hacer un Windux-Windriver.Menuconfig: ejecuta Menuconfig en una sesión terminal separada.

• gconfig y xconfig: GCONFIG activa las funciones de Linux Kernel basadas en GUI. GCONFIG emplea la interfaz de usuario basada en GTK o (basada en X). Por otro lado, Xconfig utiliza la interfaz de usuario basada en Qt. Use los siguientes comandos para iniciar GCONFIG y XCONFIG, respectivamente:

Hacer un Windux-Windriver.gconfig
Hacer un Windux-Windriver.xconfig

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

• Nconfig: La función NCONFIG ejecuta la configuración actual (buildTools) y se aplica para el programa NCURSES basado en el menú. Esto le permite seleccionar los paquetes para construir, como CPU, controladores y sistema de archivos al construir el núcleo. Use el comando: hacer nconfig.
• OldConfig: La función OldConfig le permite aplicar más nuevo .Archivos de configuración a archivos de configuración de kernel más antiguos. Por ejemplo, un viejo .Archivo de configuración y un nuevo .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 manera interactiva aplicando opciones que faltan en el archivo de configuración anterior.
• Defconfig: Esta característica permite que el sistema de compilación del núcleo agregue una nueva configuración suministrada por defconfig al .archivo de configuración. Más precisamente, el sistema KBuild verifica 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 .configuración. Si el defconfig no menciona la opción, KBuild usa valores predeterminados en el .configuración.

Considera lo siguiente:

Instantánea de 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) $ (make) -f $ (srctree)/makefile $ (kbuild_defconfig)
8. terminara si
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. De %.config: $ (obj)/conf
dieciséis. $ (si $ (llame configfiles), $ (error no existe configuración para este objetivo en esta arquitectura)))
17. $ (Q) $ (config_shell) $ (srctree)/scripts/kconfig/merge_config.sh -m .config $ (configfiles)
18. $ (Q) $ (make) -f $ (srctree)/makefile Olddefconfig

OldConfig Code Snapshot del siguiente recurso:

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

1. Caso OlddefConfig:
2. por defecto:
3. romper;
4.
5.
6. if (input_mode == saveDefConfig)
7. if (conf_write_defconfig (defconfig_file))
8. fprintf (stderr, "N *** Error mientras se guarda defconfig a: %s \ n \ n",
9. defconfig_file);
10. regresar 1;
11.
12. else if (input_mode != 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 haga 4.1 o más por emitir
21. * "Incluir/config/auto.conf: no hay dicho archivo o directorio "
22. * En el archivo de nivel superior
23. *
24. * SyncConfig siempre crea o actualiza automáticamente.conf porque es
25. * Usado durante la construcción.
26. */
27. if (conf_write_autoconf (sync_kconfig) && sync_kconfig)
28. fprintf (stderr,
29. "Error de \ n *** durante la sincronización de la configuración.\ n \ n ");
30. regresar 1;
31.
32.
33. regresar 0;
34.

• SaveDefConfig: Esta regla guarda la corriente .configurar en forma de ./defconfig, que se considera un archivo de configuración mínimo. Use el comando: hacer saveDefconfig
• ListNewConfig: Esto se usa para enumerar nuevas opciones.
• Kvmconfig: Esto permite opciones para soporte KVM. Use el comando: hacer kvm_guest.configuración
• Allyesconfig: Esto crea un nuevo archivo de configuración de kernel con todas las opciones establecidas en sí. Es lo opuesto a Allnoconfig.
• AllModConfig: Esto crea una nueva configuración del kernel con la que los módulos están 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 núcleo 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 de host, ya sea proporcionando una GUI o línea de comandos. Puede encontrar herramientas de kconfig en /scripts /kconfig en la fuente del kernel.

https: // elixir.bootlin.com/Linux/ortat/Source/scripts/kconfig

https: // elixir.bootlin.com/linux/ortat/source/scripts/kconfig/makefile

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

.configuración
/lib/módulos/$ (shell, uname-r)/.configuración
/etc/kernel-config
/Boot/config-$ (shell, uname-r)
Arch_defconfig
Arch/$ (Arch)/Defconfig

.El archivo de configuración se suelta a SyncConfig, que acepta el .Archivo de configuración como entrada. Procesa los archivos de archivo y emite, que luego se clasifican en varias categorías, como:

• autoconf.H: Esto se usa para los archivos de origen del idioma C.
• auto.Conf y tristado.conf: Estos se utilizan para el procesamiento de texto de makefile.
• /incluye/config: Estos son archivos de encabezado vacíos utilizados en el seguimiento de la dependencia.

Archivos kbuild

Casi todos los archivos de kernel son kbuild makfiles que usan la infraestructura de kbuild, que es una característica de fabricación recursiva. La marca recursiva es una forma de usar la herramienta Make como un comando en un archivo de make. La recursión 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 archivo principal que incluye el Arch Makefiles con el nombre Arch/$ (Arch)/Makefile en los archivos de configuración. Desciende recursivamente a subdirectorios que invocan la marca en los componentes utilizando 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 script.

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

Los archivos de objetos O utilizados para crear el vmlinux se compilan primero en sus respectivos incorporados .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 del núcleo y cómo funciona. Como mencionamos al comienzo del tutorial, los temas discutidos son amplios y no se pueden cubrir en un solo tutorial.