Compilación genérica de un kernel Linux

Un kernel Linux se puede compilar de más de una manera, especialmente dependiendo de la distro en la que nos encontremos. Sin ir más lejos hace casi un año estuve compilando el kernel 4.0 al “estilo Debian” generando los paquetes .deb correspondientes e instalándolos después con dpkg. CentOS, que forma parte de la familia de distros Red Hat, tiene también otro forma específica y particular para compilar un kernel.

Existe además una manera más o menos genérica de compilar un kernel que funcionará para la mayoría de distros como Debian, Red Hat, OpenSuse o derivadas de las mismas. Mención aparte Arch Linux, en la que generar el fichero .config o la compilación son exactamente iguales pero los pasos finales varían.

Preparación para la compilación

Instalar herramientas básicas para la compilación como gcc, make, libncurses-dev… Si después tenemos más dependencias, las instalaremos igualmente con nuestro gestor de paquetes correspondiente. Lo más básico con lo que tendremos que contar es gcc y make.

  • Preparamos un directorio donde vamos a descargar las fuentes del nuevo kernel:
    mkdir new_kernel
    cd new_kernel
    wget https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.4.2.tar.xz
    
  • Descomprimimos:
    tar -xvf linux-4.4.2.tar.xz
    cd linux-4.4.2
    
  • Limpieza inicial del árbol de las fuentes:
    make mrproper
    

Generar el fichero .config

El fichero .config será utilizado durante la compilación posterior. Guarda las “directrices” que se tienen que seguir.

Para generarlo tenemos varias opciones que cada uno podrá elegir según las necesidades:

  • Crear un fichero de configuración desde 0, seleccionando las opciones con las que vamos a querer compilar el kernel. Con esta opción es con la que podemos personalizar y optimizar más nuestra compilación posterior siempre que sepamos dónde estamos tocando y qué componentes seleccionamos. Podemos hacerlo de varias maneras:
    #Forma más básica
    make config
    #Configuración con menús
    make menuconfig
    #Si disponemos de ncurses instalado (necesitaremos instalar las librerías correspondientes)
    make nconfig
    #Si disponemos de servidor X11
    make xconfig
  • Utilizar la configuración que justo en estos momentos está utilizando nuestro kernel actual. No es muy recomendado ya que si en estos momentos el kernel no tiene cargado un determinado módulo, no lo incluirá en el fichero .config para la compilación posterior, por lo que puede dar lugar a un kernel “capado”:
    make localmodconfig
    
  • Partir de la configuración de nuestro kernel actual. La opción más segura y recomendable. Se diferencia de la opción anterior en que incluye todas las opciones, componentes y módulos con los que se compiló el kernel que estamos utilizando en estos momentos:
    make oldfconfig
    

    Puede que se nos pregunte acerca de nuevas funcionalidades, drivers, etc… de la nueva versión de kernel que vamos a compilar. Un pequeño truco para contestar por defecto a todas las preguntas que nos haga make oldconfig es contestar con un “enter” ante cada una de ellas con la sentencia yes:

    yes "" | make oldconfig
    
  • Otra opción es crear un .config a partir de la configuración por defecto para nuestra arquitectura (i386,x86_64…)
    make defconfig
    

Podemos además revisar el .config generado de cualquiera de las maneras anteriores haciendo un make menuconfig como comentaba al principio.

Por si resultan confusas la cantidad de opciones anteriormente mencionadas, a modo de ejemplo una posible secuencia segura sería:

# 1. Utilizamos la configuración del kernel actual para generar un .config
make oldconfig
# 2. Revisamos el fichero .config generado y cambiamos aquellas opciones que deseemos
make menuconfig

Proceso de compilación

  1. Compilar el núcleo: llegados a este punto ya tenemos listo nuestro fichero .config con las opciones y directrices para compilar nuestro núcleo Linux. Con el flag -j podemos optimizar el proceso, pasándole el valor nº de cores +1. El nº de cores lo podemos obtener de /proc/cpuinfo:
    make -j [nº cores + 1]
    
  2. Compilar los módulos: necesitaremos compilar también los módulos que va a cargar el kernel:
    make modules
    
  3. Instalar los módulos:
    make modules_install
    
  4. Finalmente, instalamos el núcleo:
    make install
    

    Durante este proceso también se crearán los ficheros correspondientes en /boot como la imagen vmlinuz, initrd, entradas al GRUB, etc…

Reiniciar

Una vez haya terminado la instalación, podemos reiniciar y arrancar con nuestro nuevo kernel:

reboot

Después, en una terminal podemos comprobar nuestro kernel con uname -r y comprobar que efectivamente, ya tenemos nuestro nuevo kernel en uso.