Califica esta publicación

Kernel Android

Anteriormente os comentamos como compilar una ROM completa para nuestro dispositivo. Una parte importante de una ROM es el Kernel, el cual contiene todos los drivers y es el cerebro de nuestro sistema. Puede que en vez de una ROM completa querramos compilar solamente el Kernel Android para habilitar o deshabilitar cosas o añadirle nuevas funcionalidades y en este tutorial comentaremos el procedimiento para realizarlo.

Requisitos

  • Sistema operativo Linux 64bits como Linux Mint o Ubuntu (debería funcionar con cualquier distribución basada en Debian)
  • Hardware medio decente (mínimo 2GB de RAM)

Preparar el entorno de compilación

Antes de empezar, si reunimos los requisitos anteriores, tendremos que preparar nuestro sistema para poder compilar nuestro Kernel Android.

Instalación de herramientas de compilación

Para empezar, primero tendremos que instalar las diferentes herramientas que se usarán para la compilación del código fuente, para ello escribimos en el terminal:

  • sudo apt install build-essential kernel-package libncurses5-dev zip bzip2 gcc g++-multilib gcc-multilib make git libfdt-dev

Con esto ya tendremos nuestro sistema listo para compilar diferentes Kernels.

Descarga del código fuente del Kernel (Sources)

Para compilar el Kernel, primero tendremos que bajar su código fuente que actualmente suele ocupar  de unos 300 a 500 megas mas o menos y también las toolchains que son las herramientas para compilar nuestro Kernel.

  1. El primer paso es crear el directorio donde vamos a descargar el código fuente (lo haremos en nuestra carpeta personal) y entrar en él, para ello escribimos el siguiente comando:
    • mkdir android && cd android
  2. Ahora descargaremos las toolchains con las que compilaremos nuestro kernel, tenemos muchas para elegir pero en el ejemplo pondré las de Google para 64 bits:
    • git clone https://android.googlesource.com/platform/prebuilts/gcc/linux-x86/aarch64/aarch64-linux-android-4.9
  3. Opcionalmente, si nuestro boot.img además del zImage (el archivo binario que se consigue al compilar) contiene un dt.img, también tendremos que compilar uno nuevo, por lo que también tendremos que descargar las herramientas para compilarlo:
    • git clone git://codeaurora.org/quic/kernel/skalesrepo
  4. Por último, descargamos el código fuente del kernel de nuestro dispositivo y si es necesario lo descomprimimos para que la carpeta que contiene el código fuente del kernel quede dentro de nuestra carpeta llamada android. Para ello debemos buscarlas en el Github correcto o descargarlas desde la pagina web de la marca del terminal. Aquí os dejo unas de ellas:

Una vez tengamos las sources de nuestro kernel, las toolchains y las dtbtools (solo si es necesario) continuamos.

Obtener el Config (solo modelos antiguos)

Para poder compilar un kernel necesitamos un archivo llamado config, que es el que configura los drivers, opciones del kernel etc. En los modelos mas recientes viene incluido en las propias sources del kernel y algunos fabricantes en el zip de las sources indican cual es el que debemos usar para nuestro modelo, pero en los mas antiguos lo mas apropiado es extraerlo de nuestro dispositivo. Para ello debemos hacer lo siguiente:

  • Nos vamos a la raíz de las sources del kernel
    • cd "tus_sources"
  • Conectamos el teléfono al ordenador con la depuración usb activada y ejecutamos en el terminal
    • adb pull /proc/config.gz
  • Ahora lo descomprimos
    • gunzip config.gz
  • Lo movemos al destino apropiado
    • mv config arch/arm/configs/"tu_config_nombre"_defconfig

Una vez echo esto, podremos hacer los cambios que queramos en las sources de nuestro kernel y después de todo ello ya tendremos nuestras sources listas para compilar un nuevo kernel con los cambios.

https://instatecno.com/compilar-roms-desde-el-codigo-fuente/

Compilar nuestro Kernel Android

Si hemos realizado todo lo anterior, ya podremos compilar nuestro nuevo kernel siguiendo los siguientes pasos:

  1. Exportamos las toolchains con las que trabajaremos, para ello, estando con el terminal en la carpeta raíz de nuestro kernel ejecutamos lo siguiente
    • export CROSS_COMPILE=~/android/aarch64-linux-android-4.9/bin/aarch64-linux-android-
  2. Establecemos la arquitectura para que queramos compilar (arm64)
    • export ARCH=arm64 && export SUBARCH=arm64
  3. Una vez hecho, hay que decirle que configuración debemos usar, para ello hacemos lo siguiente
    • make "tu_config_nombre"_defconfig
      Los defconfig disponibles los podemos encontrar en la ruta arch/arm/configs (para 32 bits) y arch/arm64/configs (para 64 bits)
  4. Por último ya podremos compilar nuestro kernel ejecutando el siguiente comando
    • make -j#
      Donde # es el número de núcleos de nuestro PC -1, si tenemos 4 núcleos ponemos 3 (para no cargar demasiado al procesador)
      Para usuarios mas avanzados, después de hacer make «tu_config_nombre»_defconfig , podemos ejecutar «make menuconfig» para agregar y/o quitar configuraciones del defconfig.
  5. Una vez compilado el kernel, si es necesario tendremos que compilar el dt.img, para ello escribimos lo siguiente en el terminal
    • ~/android/skales/dtbTool -o arch/arm64/boot/dt.img -s 2048 arch/arm64/boot/dts

Una vez echo todo esto (puede tardar un tiempo dependiendo de la potencia de tu PC), obtendremos en la ruta arch/arm64/boot/ el zImage y el dt.img (si lo hemos tenido que compilar) que tendremos que introducir en el boot.img de nuestro dispositivo para posteriormente flashearlo.

Para volver a compilar solo hay que ejecutar «make clean» para que limpie la compilación anterior y volvéis a repetir.

Fuente: Antiguo foro de ActualizaTuMovil

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies

ACEPTAR
Aviso de cookies