Kernel (Español)/Traditional compilation (Español) - ArchWiki

Jump to content

# Kernel (Español)/Traditional compilation (Español)

From ArchWiki
< Kernel (Español)

Este artículo es una introducción para construir kernels personalizados desde kernel.org sources. Este método de compilación de kernels es el tradicional, común a todas las distribuciones. Puede ser, según tu experiencia, más complejo que usar el sistema de compilación Kernel/Arch. Ten en cuenta que las herramientas del sistema de compilación Arch se desarrollan y mantienen para que las tareas de compilación repetibles sean eficientes y seguras.

## Preparación

No es necesario (ni recomendable) usar la cuenta root ni privilegios de root (es decir, mediante sudo (Español)) para la preparación del kernel.

### Instalar los paquetes principales

Instala el base-devel meta package (Español), que incluye los paquetes necesarios, como make y gcc. También se recomienda instalar los siguientes paquetes, tal como se enumeran en el kernel Arch predeterminado PKGBUILD: xmlto, kmod, inetutils, bc, libelf, git, cpio, perl, tar, xz.

### Crear un directorio de compilación del kernel

Se recomienda crear un directorio de compilación independiente para su(s) kernel(s). En este ejemplo, el directorio `kernelbuild` se creará en el directorio `home`:

    $ mkdir ~/kernelbuild

### Descargar el código fuente del kernel

Advertencia systemd (Español) requiere al menos la versión 3.12 del kernel (4.2 o superior para compatibilidad con la jerarquía unificada de cgroups). Consulte `/usr/share/doc/systemd/README` para obtener más información.

Descargue el código fuente del kernel desde https://www.kernel.org. Este debería ser el archivo tarball (.tar.xz) del kernel elegido.

Puede descargarlo simplemente haciendo clic derecho en el enlace `tar.xz` en su navegador y seleccionando `Guardar enlace como...`, o de cualquier otra forma mediante herramientas gráficas o de línea de comandos alternativas que utilicen HTTP, TFTP (Español), Rsync (Español) o Git (Español).

Nota

- Es recomendable verificar la firma PGP de cualquier archivo tar del kernel descargado. Esto garantiza su legitimidad y contribuye a la construcción de la Red de Confianza. Consulte kernel.org/signature.
- Para ciertas versiones (por ejemplo, las versiones `-rc`), el archivo descargado y los directorios resultantes no seguirán estrictamente la nomenclatura `A.B.C` utilizada en los ejemplos de esta página; adáptelos a sus necesidades.

En los siguientes comandos de línea de comandos, se ha instalado wget y se utiliza dentro del directorio `~/kernelbuild` para obtener el kernel A.B.C:

    $ cd ~/kernelbuild
    $ wget https://cdn.kernel.org/pub/linux/kernel/vA.x/linux-A.B.C.tar.xz

También debe verificar la corrección de la descarga antes de confiar en ella. Primero, obtenga la firma y, a continuación, úsela para obtener la huella digital de la clave de firma. A continuación, use la huella digital para obtener la clave de firma real:

    $ wget https://cdn.kernel.org/pub/linux/kernel/vA.x/linux-A.B.C.tar.sign
    $ gpg --list-packets linux-A.B.C.tar.sign | grep -i keyid | awk '{print $NF}' | xargs gpg --recv-keys

Tenga en cuenta que la firma se generó para el archivo tar (es decir, con extensión `.tar`), no para el archivo comprimido `.tar.xz` que descargó. Debe descomprimir este último sin descomprimirlo. Verifique que tenga xz instalado y luego proceda de la siguiente manera:

    $ unxz linux-A.B.C.tar.xz
    $ gpg --verify linux-A.B.C.tar.sign linux-A.B.C.tar

No continúe si esto no genera una salida que incluya la cadena "Firma correcta".

Si no se usó `wget` dentro del directorio de compilación, será necesario mover el archivo tar a él, por ejemplo:

    $ mv /path/to/linux-''A''.''B''.''C''.tar.xz ~/kernelbuild/

#### Espejos semioficiales del kernel

This article or section needs expansion.

Reason: En lugar de usar espejos semioficiales, se puede lograr una clonación inicial más rápida usando los paquetes Git oficiales. (Discuss in Talk:Kernel (Español)/Traditional compilation (Español))

Los espejos semioficiales de algunos repositorios Git de kernel.org son proporcionados por sus respectivos mantenedores. Suelen ser más rápidos para clonar que desde kernel.org.

- La rama principal está reflejada en la cuenta de GitHub de Linus Torvalds: https://github.com/torvalds/linux.git.
- Las ramas estables están reflejadas en la cuenta de GitHub de Greg Kroah-Hartman: https://github.com/gregkh/linux. [1]

### Descomprimir el código fuente del kernel

Dentro del directorio de compilación, descomprimir el archivo tar del kernel:

    $ tar -xvf linux-A.B.C.tar

Para garantizar que no se produzcan errores de permisos, es necesario ejecutar chown para transferir la propiedad de la carpeta al usuario actual.

Para transferir la propiedad de una carpeta con todos los archivos que contiene a nuestro usuario, ejecute el comando chown.

    $ chown -R $USER:$USER linux-A.B.C

Esto le transferirá la propiedad de todos los archivos de la carpeta, para que no se produzcan errores relacionados con los permisos.

Para finalizar la preparación, asegúrese de que el árbol del kernel esté completamente limpio. No confíe en que el árbol de fuentes esté limpio después de descomprimir. Para ello, primero acceda al nuevo directorio de fuentes del kernel creado y luego ejecute el comando `make mrproper`:

    $ cd linux-A.B.C
    $ make mrproper

Nota El objetivo de Make `mrproper` depende del objetivo `clean` y, por lo tanto, no es necesario ejecutar ambos. Consulte [2] como referencia.

## Configuración del kernel

Este es el paso más crucial para personalizar el kernel predeterminado y adaptarlo a las especificaciones precisas de su computadora. La configuración del kernel se establece en su archivo `.config`, que incluye el uso de kernel modules (Español). Al configurar correctamente las opciones en `.config`, su kernel y su computadora funcionarán de manera más eficiente.

Nota No es necesario usar la cuenta root ni privilegios root en esta etapa.

Puede combinar dos opciones:

- Usar la configuración predeterminada de Arch de un kernel oficial (recomendado)
- Configurar manualmente las opciones del kernel (opcional, avanzado y no recomendado)

### Configuración predeterminada de Arch

Este método creará un archivo `.config` para el kernel personalizado usando la configuración predeterminada del kernel de Arch. Si se está ejecutando un kernel estándar de Arch, puede usar el siguiente comando dentro del directorio fuente del kernel personalizado:

    $ zcat /proc/config.gz > .config

De lo contrario, la configuración predeterminada se puede encontrar en línea en el paquete del kernel oficial de Arch Linux.

Tip

- Si está actualizando kernels, es posible que algunas opciones hayan cambiado o se hayan eliminado. En este caso, al ejecutar `make` en #Compilación, se le solicitará que proporcione respuestas a cada opción de configuración que haya cambiado entre versiones. Para aceptar los valores predeterminados sin que se le solicite, ejecute `make olddefconfig`.
- modprobed-db puede usarse para eliminar módulos innecesarios del archivo predeterminado de Arch `.config`. Una vez que se obtenga una base de datos correctamente poblada, ejecute `make LSMOD=$HOME/.config/modprobed.db localmodconfig` para eliminar todos los módulos que no estén presentes en la base de datos `modprobed.db`.

Advertencia Si está compilando un kernel con su archivo `.config` actual, no olvide cambiar el nombre de la versión del kernel a "CONFIG_LOCALVERSION" en el nuevo archivo `.config` o en la opción "Configuración general > Versión local - añadir a la versión del kernel" mediante una de las interfaces de usuario que aparecen en #Configuración avanzada. Si omite este paso, corre el riesgo de sobrescribir uno de sus kernels existentes por error.

### Configuración avanzada

Tip A menos que desee ver muchos mensajes adicionales al arrancar y apagar con el kernel personalizado, es recomendable desactivar las opciones de depuración correspondientes.

Existen varias herramientas disponibles para ajustar la configuración del kernel, lo que ofrece una alternativa a pasar horas configurando manualmente todas las opciones disponibles durante la compilación.

Nota Las herramientas que se listan a continuación le proporcionarán tres opciones de configuración para cada función del kernel: `y` para habilitar, `n` para deshabilitar y `m` para habilitar como módulo del kernel (cargado cuando sea necesario).

Estas herramientas son:

- `make menuconfig`: Interfaz de línea de comandos de ncurses reemplazada por `nconfig`
- `make nconfig`: Interfaz de línea de comandos de ncurses más reciente
- `make xconfig`: Interfaz gráfica intuitiva que requiere la instalación de packagekit-qt5[enlace roto: package not found] como dependencia. Este es el método recomendado, especialmente para usuarios con poca experiencia, ya que facilita la navegación y también muestra información sobre cada opción.
- `make gconfig`: Configuración gráfica similar a xconfig, pero con GTK. Esto requiere gtk2AUR, glib2 y libgladeAUR.

Una vez realizados los cambios, guarde el archivo `.config`. Es recomendable hacer una copia de seguridad fuera del directorio de origen. Es posible que tenga que repetir esta operación varias veces hasta que todas las opciones sean correctas.

Si no está seguro, modifique solo algunas opciones entre compilaciones. Si no puede arrancar el kernel recién compilado, consulte la lista de elementos necesarios aquí.

Al ejecutar `lspci -k #` desde el medio en vivo, se listan los nombres de los módulos del kernel en uso. Es fundamental mantener la compatibilidad con cgroups. Esto es necesario para systemd (Español). Para obtener información más detallada, consulte Gentoo:Kernel/Gentoo Kernel Configuration Guide/es y Gentoo:Intel#Kernel o Gentoo:Ryzen#Kernel para procesadores Intel o AMD Ryzen.

## Compilación

Tip Si desea que gcc se optimice para los conjuntos de instrucciones de su procesador, edite `arch/x86/Makefile` en el directorio de origen del kernel:

- Busque `CONFIG_MK8,CONFIG_MPSC,CONFIG_MCORE2,CONFIG_MATOM,CONFIG_GENERIC_CPU` que haya seleccionado en `Tipo y características del procesador > Familia del procesador`
- Cambie el indicador `call cc-options` de `-march=native` al que haya seleccionado en Familia del procesador, por ejemplo, `cflags-$(CONFIG_MK8) += $(call cc-option,-march=native)`. Esta es probablemente la mejor manera de compilar con `-march=native`, ya que funciona correctamente.

El tiempo de compilación puede variar desde tan solo quince minutos hasta más de una hora, dependiendo de la configuración del kernel y la capacidad del procesador. Una vez configurado el archivo `.config` para el kernel personalizado, ejecute el siguiente comando en el directorio de origen para compilar:

    $ make

Tip Para compilar más rápido, se puede ejecutar make con el argumento `-jX`, donde `X` es un número entero de trabajos paralelos. Los mejores resultados suelen obtenerse utilizando el número de núcleos de CPU en la máquina; por ejemplo, con un procesador de 2 núcleos, ejecute `make -j2`. Consulte Makepkg (Español)#Mejorar tiempos de compilación para obtener más información.

## Instalación

### Instalar los módulos

Una vez compilado el kernel, deben instalarse los módulos correspondientes. Primero, compila los módulos:

    $ make modules

Luego, instala los módulos. Como root o con privilegios de root, ejecuta el siguiente comando:

    # make modules_install

Esto copiará los módulos compilados en `/lib/modules/A.B.C/`. Esto mantiene separados los módulos de cada kernel.

Tip Si tu sistema requiere módulos que no se distribuyen con el kernel de Linux estándar, debes compilarlos para tu kernel personalizado una vez finalizado. Estos módulos suelen ser los que instalaste explícitamente por separado para tu sistema. Consulta NVIDIA (Español)#Kernel personalizado para ver un ejemplo.

### Copia el kernel al directorio /boot

Nota Asegúrate de que el archivo del kernel `bzImage` se haya copiado del directorio adecuado para la arquitectura de tu sistema. Consulta a continuación.

El proceso de compilación del núcleo generará una `bzImage` comprimida (Big zImage) de ese núcleo; si no lo hace, es posible que tenga que ejecutar:

     $ make bzImage

Este archivo debe copiarse al directorio `/boot` y renombrarse durante el proceso. Si el nombre tiene el prefijo `vmlinuz-`, puede nombrar el kernel como desee. En los ejemplos a continuación, el kernel A.B.C instalado y compilado se ha copiado y renombrado a `vmlinuz-linuxAB`:

    # cp -v arch/x86/boot/bzImage /boot/vmlinuz-linuxAB

### Crear disco RAM inicial

Nota Puede nombrar el archivo de imagen initramfs como desee al generarlo. Sin embargo, se recomienda usar la convención `linuxmajor_revisionminor_revision`. Esta convención facilitará el mantenimiento de varios kernels, el uso regular de mkinitcpio y la creación de módulos de terceros.
Tip Si utiliza el gestor de arranque LILO y no puede comunicarse con el controlador del mapeador de dispositivos del kernel, primero debe ejecutar `modprobe dm-mod`.

Si no sabe qué es crear un disco RAM inicial, consulte Initramfs en Wikipedia y mkinitcpio (Español).

### Método de preajuste automatizado

Un preajuste de mkinitcpio existente se puede copiar y modificar para que las imágenes initramfs del kernel personalizadas se puedan generar de la misma manera que para un kernel oficial. Esto es útil si se pretende recompilar el kernel (por ejemplo, si se actualiza). En el ejemplo a continuación, el archivo de ajustes preestablecidos del kernel estándar de Arch se copiará y modificará para el kernel A, B, C, instalado anteriormente.

Primero, copie el archivo de ajustes preestablecidos existente y cámbiele el nombre para que coincida con el nombre del kernel personalizado especificado como sufijo de `/boot/vmlinuz-` al copiar `bzImage`:

    # cp /etc/mkinitcpio.d/linux.preset /etc/mkinitcpio.d/linuxAB.preset

Segundo, edite el archivo y modifique para el kernel personalizado. Tenga en cuenta (de nuevo) que el parámetro `ALL_kver=` también coincide con el nombre del kernel personalizado especificado al copiar `bzImage`:

    /etc/mkinitcpio.d/linuxAB.preset

    ...
    ALL_kver="/boot/vmlinuz-linuxAB"
    ...
    default_image="/boot/initramfs-linuxAB.img"
    ...
    fallback_image="/boot/initramfs-linuxAB-fallback.img"

Finalmente, genere las imágenes initramfs para el kernel personalizado de la misma manera que para un kernel oficial:

    # mkinitcpio -p linuxAB

#### Método manual

En lugar de usar un archivo predefinido, también puede usar mkinitcpio para generar un archivo initramfs manualmente. La sintaxis del comando es:

    # mkinitcpio -k ''kernel_version'' -g /boot/initramfs-''file_name''.img

- `-k` (`--kernel kernel_version`): Especifica los módulos que se usarán al generar la imagen initramfs. El nombre `kernel_version` será el mismo que el nombre del directorio de módulos, ubicado en `/usr/lib/modules/` (como alternativa, se puede usar la ruta a la imagen del kernel).

- `-g` (`--generate file_name`): Especifica el nombre del archivo initramfs que se generará en el directorio `/boot`. Se recomienda usar la convención de nomenclatura mencionada anteriormente.

Por ejemplo, el comando para el kernel personalizado A.B.C instalado anteriormente sería:

    # mkinitcpio -k A.B.C -g /boot/initramfs-linuxAB.img

### Copiar System.map

El archivo `System.map` no es necesario para arrancar Linux. Es una especie de "directorio telefónico" con las funciones de una compilación específica del kernel. El archivo `System.map` contiene una lista de símbolos del kernel (es decir, nombres de funciones, nombres de variables, etc.) y sus direcciones correspondientes. Esta "asignación de nombre de símbolo a dirección" es utilizada por:

- Algunos procesos como klogd, ksymoops, etc.
- El controlador OOPS cuando se debe mostrar información en pantalla durante un fallo del kernel (es decir, información sobre en qué función se ha producido el fallo).

Tip Los sistemas de partición EFI se formatean con FAT32, que no admite enlaces simbólicos.

Si su `/boot` está en un sistema de archivos que admite enlaces simbólicos (es decir, no FAT32), copie `System.map` a `/boot` y añada el nombre de su kernel al archivo de destino. Luego, crea un enlace simbólico desde `/boot/System.map` que apunte a `/boot/System.map-linuxAB`:

    # cp System.map /boot/System.map-linuxAB
    # ln -sf /boot/System.map-linuxAB /boot/System.map

Después de completar todos los pasos anteriores, deberías tener los siguientes 3 archivos y 1 enlace simbólico suave en tu directorio `/boot`, junto con cualquier otro archivo existente:

- Kernel: `vmlinuz-linuxAB`
- Initramfs: `initramfs-linuxAB.img`
- Mapa del sistema: `System.map-linuxAB`
- Enlace simbólico del kernel del Mapa del sistema: `System.map` (que enlaza simbólicamente a `System.map-linuxAB`)

## Arranque Configuración del cargador

Agregue una entrada para su nuevo kernel en el archivo de configuración del bootloader. Consulte Arch boot process (Español)#Comparación de características para ver posibles cargadores de arranque, sus artículos wiki y otra información.

Tip El código fuente del kernel incluye un script para automatizar el proceso de LILO (Español): puede ignorarlo sin problemas si utiliza otro cargador de arranque.

## Véase también

- https://cateee.net/lkddb/web-lkddb/ incluye una lista completa de las cadenas de configuración del kernel y el texto correspondiente, ordenadas alfabéticamente.

Category:

- Kernel (Español)

Hidden categories:

- Pages or sections flagged with Template:Expansion
- Pages with broken package links

Kernel (Español)/Traditional compilation (Español)
Add topic