Cómo compilar el kernel de Android en Windows 10

Appual tiene algunas guías excelentes sobre el desarrollo de Android, como Cómo crear una ROM personalizada a partir del proyecto de código abierto de Android, pero estas guías generalmente están orientadas a un entorno de compilación de Linux puro.

En esta guía, le mostraremos cómo compilar un kernel de Android en Windows 10; sí, seguiremos usando un entorno de compilación de Linux, pero será un subsistema de Linux dentro de Windows 10. Entonces, si tiene Windows 10 usuario interesado en desarrollar para Android, siga atentamente nuestra guía.

En esta guía, aprenderemos específicamente cómo crear un kernel para dispositivos ARM y MediaTek, agregar funciones y una descripción general básica del uso de Git.

Requisitos

  • Windows 10 x64 (con la actualización de Fall Creator)

Configuración del entorno Linux

  1. En Windows 10, vaya a Configuración > Actualización y seguridad > Para desarrolladores > habilite el Modo de desarrollador.
  2. Ahora vaya a Panel de control > Programas > Activar o desactivar las características de Windows > habilitar el Subsistema de Windows para Linux.
  3. Reinicie su PC.
  4. Inicie el subsistema Linux y permita que pase por el proceso de descarga. Establece una contraseña y no la pierdas.
  5. Ahora ve a la tienda de aplicaciones de Windows y descarga Ubuntu.
  6. Inicie Ubuntu en el escritorio de Windows 10 y le solicitará un nombre de usuario y una contraseña.
  7. En Ubuntu, inicie la terminal nativa y escriba el siguiente comando: apt-get update
  8. Esto procederá a actualizar todos los repositorios para aplicaciones y dependencias.
  9. Siguiente en el tipo de terminal: sudo apt-get install -y build-essential kernel-package libncurses5-dev bzip2
  10. Para verificar si todas las dependencias se instalaron correctamente, escriba ‘gcc’ en la terminal (sin comillas).
  11. Si «gcc» ya está instalado, debería ver «gcc: error fatal: no hay archivo de entrada»
  12. Ahora puede escribir ‘hacer’ en la terminal. Si «make» ya está instalado, debería ver «make: *** no se especificó ningún destino y no se encontró ningún archivo MAKE. detener.»
  13. A continuación, escriba ‘git’, y si «git» ya está instalado, debería ver un montón de comandos básicos de git.
  14. Ahora necesitamos algunas cadenas de herramientas (hay varios tipos, incluidos GCC, Linaro y un puñado de cadenas personalizadas). Algunos dispositivos pueden requerir diferentes cadenas de herramientas, por ejemplo, no todos los núcleos de dispositivos se iniciarán o compilarán con GCC.

Para dispositivos ARM

Usaremos GCC 4.7 para esto.

  1. Abra la terminal de Linux y escriba: mkdir kernel
  2. Ahora escribe: cd kernel
  3. (No tiene que ser ‘kernel’, esto es por simplicidad, puede nombrarlo como quiera).
  4. Ahora escribe: git clone https://android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-eabi-4.7

Para dispositivos ARM 64

Necesita un compilador de kernel de 64 bits para dispositivos ARM 64, por ejemplo, aarch64.

Obtener los archivos fuente para su dispositivo

Esta es una parte complicada, ya que necesita encontrar un repositorio de GitHub que aloje la fuente de su kernel. Por supuesto, deberá buscarlo, lo más probable es que se pueda encontrar en los foros de XDA.

Aquí hay un ejemplo fuente del núcleo Git.

En el lado superior izquierdo, debería ver «Sucursal: Completado por xxxx».

Existen diferentes versiones de un kernel/proyecto, normalmente separadas por “Prueba”, “Beta”, “Lanzamiento Final”, etc.

Las carpetas del núcleo suelen ser las siguientes:

  • /arch/arm/configs: Contiene varios archivos de configuración para el dispositivo, como gobernadores, etc.
  • /salida/arco/brazo/arranque/: Aquí es donde se almacenará la zimage.
  • construir.sh: Un script que simplificará el proceso de construcción.
  • /arm-cortex-linux-gnueabi-linaro_5.2-2015.11-2: Normalmente se trata de una cadena de herramientas colocada en el código fuente del núcleo, lo que facilita su búsqueda.

Vas a necesitar descargar la fuente de tu kernel.

Abra la terminal de Linux y asegúrese de estar en la carpeta del kernel que creó anteriormente (cd kernel).

Luego escribe en la terminal: “git clone “URL del kernel de github” -b “nombre de la rama”

Por ejemplo: «git clon https://github.com/atxoxx/android_ke…amsung_msm8974 -b xenomTW”

Construyendo el núcleo

Para hacerlo más fácil, puede navegar a la ubicación en el explorador de archivos. Debería ser /home/ID de usuario/kernel (o el nombre que le haya dado a la carpeta del kernel).

Debería ver dos carpetas adentro, para la cadena de herramientas y la fuente del kernel. Vaya dentro de la carpeta fuente del kernel.

Para dispositivos ARM

En una terminal, escribe los siguientes comandos:

#!/bin/bash
export ARCH=arm
export CROSS_COMPILE=
mkdir output
make -C $(pwd) O=output "name of defconfig and variant if needed"
make -j4 -C $(pwd) O=output

Aquí hay una descripción general de lo que hacen estos comandos, para que sea más fácil en el futuro.

  • #!/bin/bash: Le dice al script que se ejecute en el comando de shell
  • exportar ARCO=brazo: Definir qué tipo de arquitectura de kernel es (por ejemplo, arm64, etc.)
  • exportar CROSS_COMPILE= : localice dónde está la cadena de herramientas. Debe coincidir con la ruta exacta, y el guión al final es realmente obligatorio.
  • salida mkdir: Esto crea un directorio para guardar el zimage compilado
  • hacer -C $(contraseña) O=salida : Definición de defconfig para guiar la compilación del núcleo.
  • hacer -j4 -C $(contraseña) O=salida: Cuando comienza el proceso de construcción, -j# le dice qué tan rápido debe intentar compilar. Por lo general, establece este número de acuerdo con su CPU. Establecer en -j32 en una CPU económica, por ejemplo, probablemente causaría una inestabilidad masiva.
  • salida cp/arch/arm/boot/Image $(pwd)/arch/arm/boot/zImage: Esto es para mover la imagen a una segunda ruta.

Otro ejemplo:

#!/bin/bash
export ARCH=arm
export CROSS_COMPILE=$(pwd)/arm-cortex-linux-gnueabi-linaro_5.2-2015.11-2/bin/arm-cortex-linux-gnueabi-
mkdir output
make -C $(pwd) O=output msm8974_sec_defconfig VARIANT_DEFCONFIG=msm8974_sec_ks01_skt_defconfig SELINUX_DEFCONFIG=selinux_defconfig
make -j4 -C $(pwd) O=output
cp output/arch/arm/boot/Image $(pwd)/arch/arm/boot/zImage

Para dispositivos ARM 64

#!/bin/bash
export ARCH=arm64
export CROSS_COMPILE="path to your toolchain" (it have to end by something like "nameofarch-something-")
mkdir output
make -C $(pwd) O=output "name of defconfig and variant if needed" 
make -j4 -C $(pwd) O=output

Para dispositivos Mediatek (MTK)

#!/bin/bash
export CROSS_COMPILE="path to your toolchain" (it have to end by something like "nameofarch-something-")
export ARCH=arm ARCH_MTK_PLATFORM=
make "name of defconfig and variant if needed"
make -j4

Cuando haya completado los pasos necesarios para la arquitectura de su kernel, puede escribir en la terminal: sudo bash build.sh

Luego ingresará su contraseña de usuario y comenzará el proceso de compilación.

Puede llevar un tiempo, pero por lo general no mucho, compilar un kernel no es como compilar una ROM de Android completa. Esto depende realmente de la CPU; por ejemplo, un AMD Phenom X4 de 3,4 GHz con 8 GB de RAM debería tardar unos 10 minutos en compilarse de principio a fin.

Cuando termine, debería notificarte con un mensaje como «zimage está listo».

Dispositivos ARM y ARM64

Vaya a «/Output/arch/arm/boot/» para encontrar su zimage.

Dispositivos Mediatek

Vaya a «/arch/arm/boot/» para encontrar su zimage.

No todas las compilaciones del núcleo darán como resultado un archivo Zimage, a veces se puede compilar como otros formatos de imagen.

Importante: si va a compilar nuevamente, se recomienda que ingrese los comandos make clean y make mrproper antes de comenzar el proceso de compilación nuevamente.

Haciendo el Arranque del Kernel

Hay dos opciones para que elijas.

Puede usar el método anykernel (como lo define el usuario de XDA @osm0sis en este hilo de XDA). Debe leer todo el tutorial, pero un resumen de los pasos es el siguiente:

  1. Coloque zImage en la raíz (dtb y/o dtbo también deben ir aquí para los dispositivos que requieren dispositivos personalizados, cada uno volverá al original si no se incluye)
  2. Coloque los archivos ramdisk requeridos en /ramdisk y los módulos en /modules (con la ruta completa como /modules/system/lib/modules)
  3. Coloque los archivos de parche requeridos (generalmente archivos parciales que van con los comandos) en /patch
  4. Modifique anykernel.sh para agregar el nombre de su núcleo, la ubicación de la partición de arranque, los permisos para los archivos ramdisk incluidos y los métodos de uso para cualquier modificación requerida de ramdisk (opcionalmente, también coloque los archivos de banner y/o versión en la raíz para que se muestren durante el flash)
  5. `zip -r9 ACTUALIZAR-AnyKernel2.zip * -x .git README.md *marcador`

El otro método que tienes disponible es descomprimir boot.img desde la misma ROM (como CM, TouchWiz, EMUI, etc.) y la misma versión de Android. Luego cambiarías el Zimage. Nuevamente, este es un proceso realmente complicado y debe leer el tutorial exactopero un resumen de los pasos es:

  1. Abrir la cremallera.
  2. Utilice la línea de comandos «unpackimg «, o simplemente arrastre y suelte la imagen. Esto dividirá la imagen y descomprimirá el ramdisk en un subdirectorio.
  3. Modifique el ramdisk como desee.
  4. El script por lotes repackimg no requiere entrada y simplemente vuelve a combinar el zImage previamente dividido con el ramdisk modificado recién empaquetado utilizando toda la información de la imagen original (que también se dividió y se guardó).
  5. El script por lotes de limpieza restablece la carpeta a su estado inicial, eliminando los directorios split_img+ramdisk y cualquier ramdisk o archivo de imagen empaquetados.

Antes de actualizar su kernel, debe crear una copia de seguridad de su stock boot.img y luego actualizar su kernel para ver si permite que su sistema Android arranque.

Agregar características a su kernel

Agregar funciones a su kernel es una excelente manera de darle vida. Hay muchas cosas que puede modificar, como los reguladores de la CPU, los programadores de E/S, el overclocking de la GPU, las mejoras de audio, etc.

Un ejemplo para agregar un gobernador es aquí (este gobernador tiene el nombre en código Intellimm).

Podemos ver en los 2 primeros cuadros de texto que en “arch/arm/configs/” se han modificado “msm8974_sec_defconfig” y “cm_msm8974_sec_defconfig”.

Entre las líneas 140 y 141 de estos archivos se ha añadido este texto: “CONFIG_CPU_FREQ_GOV_INTELLIMM=y”
(Esta línea es para habilitar Intellimm cuando está compilando su kernel)

La misma técnica se aplica a los otros cuadros de texto (lo que se ha agregado y eliminado y su ubicación)

Dependiendo de las funciones que agregue, se pueden modificar, agregar o eliminar más o menos archivos.

Entonces, para resumir, un Commit le permite ver todos los cambios que se han realizado y todo lo demás.

Consejos y trucos generales

Cómo cambiar el nombre y la versión del núcleo:

El método sencillo:

Edite esta línea en su archivo defconfig:

"CONFIG_LOCALVERSION="-" after - in your defconfig

Ejemplo: CONFIG_LOCALVERSION=”-XenomTW-3.2.6″

Los métodos avanzados:

Navegue hasta Makefile en la carpeta raíz de la fuente de su kernel.

Añade estas líneas:

CONFIG_LOCALVERSION="nameofyourkernel"
LOCALVERSION="versionofyourkernel"

NO modifique las líneas Version, PatchLevel, Sublevel o Extraversion.

Método alternativo:

Vaya a scripts/mkcompile_h y agregue estas líneas:

LINUX_COMPILE_BY="nameofyourchoice"
LINUX_COMPILE_HOST="nameofyourchoice"

Resolviendo problemas de PATH:

Si encuentra el error «¿Es correcta su ruta?», Intente esto en la terminal de Linux:

"export PATH="pathtotoolchainlocation"/bin:$PATH"

Accediendo a sus carpetas de Ubuntu desde Windows 10

Su ruta a Ubuntu normalmente debería ser:

C:\Users”NOMBRE”\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\home

Pero no debe editar archivos directamente desde Windows, ya que esto normalmente romperá los permisos sobre ellos; luego deberá restablecer los permisos desde la terminal de Linux.