How_to_build_android_kernel_to_load_modules_dynamically
1.0.0
Este es un tutorial que muestra los pasos para:
Este tuto se ha realizado para el siguiente objetivo:
Downlad ADB y FastBoot desde su administrador de paquetes o siguiendo esta guía.
sudo apt-get install adb fastboot
Inicie el Daemon ADB , verifique que pueda ver el teléfono con ADB y reiniciarlo en modo de gotador de arranque (modo FastBoot).
adb start-server
adb devices
adb reboot bootloader
Verifique que pueda ver el teléfono con FastBoot y desbloquear el gestor de arranque
fastboot devices
fastboot oem unlock
(or fastboot flashing unlock for newest phones)
También puede seguir esta guía oficial para comenzar manualmente en modo FastBoot y desbloquear el cargador de arranque.
Puede encontrar otros comandos FastBoot aquí.
Primero intenté usar el último NDK estable del repositorio oficial.
(¡No lo descargue! No funciona)
export PATH=$PATH:/home/user/ndk/android-ndk-r17b/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin/
export CROSS_COMPILE=arm-linux-androideabi-
Pero tuve advertencias muy extrañas en la compilación que bloquearon el linkking final.
Entonces, después de unas pocas investigaciones, encontré aquí que era mejor usar el brazo-eabi-gcc en lugar del brazo-linux-androideaBi-GCC .
Por lo tanto, descargué la última versión de ARM-EABI-4.8.
==> Extraelo a /home/user/ndk/arm-eabi-4.8
export PATH=$PATH:/home/user/ndk/arm-eabi-4.8/bin
export CROSS_COMPILE=arm-eabi-
NOTA: Puedo confirmar la elección de ARM-EABI-4.8 porque es el compilador cruzado definido en la imagen del núcleo en sí en build.config :
ARCH=arm
BRANCH=android-msm-shamu-3.10
CROSS_COMPILE=arm-eabi-
DEFCONFIG=shamu_defconfig
EXTRA_CMDS=''
KERNEL_DIR=private/msm-moto
LINUX_GCC_CROSS_COMPILE_PREBUILTS_BIN=prebuilts/gcc/linux-x86/arm/arm-eabi-4.8/bin
FILES="
arch/arm/boot/zImage-dtb
vmlinux
System.map
"
Para insertar nuestro propio módulo del núcleo en el nexo 6 del núcleo, necesitamos activar el soporte del módulo cargable del módulo de configuración del kernel. Si ya ha rooteado su teléfono, puede verificarlo con la grabación, OtroLse confía en mí:
adb shell su -c "lsmod"
or
adb shell su -c "insmod /data/local/tmp/glitchmin.ko"
Estas funciones no están autorizadas de forma predeterminada en los núcleos de Android. Por lo tanto, flashearemos un nuevo núcleo con el soporte del módulo cargable de opción habilitado.
El Nexus 6 (Shamu) que recibimos se configuró de la siguiente manera:
Según esta lista, descargué este kernel oficial de Google Android-MSM-Shamu-3.10-Marshmallow.
==> Extraelo a /home/user/images_kernel/msm-android-msm-shamu-3.10-marshmallow export mykernel =/home/user/images_kernel/msm-android-msm-shamu-3.10-marshmallow cd $ myKernel
También puede usar el [CyanogenMod Kernel android_kernel_moto_shamu] (https://github.com/cyanogenmod/android_kernel_moto_shamu) (<- Finalmente, este no arranca)
Luego puede construir su núcleo siguiendo los próximos pasos (inspirado en esta guía o esta guía o [esta] (https://source.android.com/setup/build/devices o este último).
En $ mykernel/arch/arm/configs/shamu_config, sustituir
# CONFIG_MODULES is not set
por
CONFIG_MODULES=y
Entonces
cp arch/arm/configs/shamu_config .config
make ARCH=arm SUBARCH=arm CROSS_COMPILE=arm-eabi- shamu_defconfig
Verifique si la opción Habilitar el soporte del módulo cargable está bien activado con: make ARCH=arm SUBARCH=arm CROSS_COMPILE=arm-eabi- menuconfig
==> si no seleccione Habilitar el soporte del módulo cargable , presione el espacio en su teclado y luego seleccione Guardar y Salir
Finalmente compile todo el núcleo (lleva mucho tiempo ...): make ARCH=arm SUBARCH=arm CROSS_COMPILE=arm-eabi- -j4
(Nota: -jn significa que usará n procesador en paralele)
Debes obtener al final algo como:
Kernel: arch/arm/boot/Image is ready
DTC arch/arm/boot/dts/apq8084-shamu-p2.dtb
AS arch/arm/boot/compressed/head.o
GZIP arch/arm/boot/compressed/piggy.gzip
CC arch/arm/boot/compressed/misc.o
CC arch/arm/boot/compressed/decompress.o
CC arch/arm/boot/compressed/string.o
SHIPPED arch/arm/boot/compressed/hyp-stub.S
SHIPPED arch/arm/boot/compressed/lib1funcs.S
SHIPPED arch/arm/boot/compressed/ashldi3.S
AS arch/arm/boot/compressed/hyp-stub.o
AS arch/arm/boot/compressed/lib1funcs.o
AS arch/arm/boot/compressed/ashldi3.o
AS arch/arm/boot/compressed/piggy.gzip.o
LD arch/arm/boot/compressed/vmlinux
OBJCOPY arch/arm/boot/zImage
Kernel: arch/arm/boot/zImage is ready
CAT arch/arm/boot/zImage-dtb
Kernel: arch/arm/boot/zImage-dtb is ready
Puede encontrar su imagen , zimage y zimage-dtb en $ mykernel/arco/arm/boot/
Puede encontrar la blob del árbol del dispositivo .dtb en $ mykernel/arch/arm/boot/dts/*. Dtb
Tienes tu núcleo listo. En la mayoría de los sistemas integrados, ese será el final de su trabajo. Por lo general, copiará el núcleo a la tarjeta SD o la ubicación de NFS, y la placa se iniciará. Pero en Android es diferente. Debe preparar una partición de arranque especial que luego puede arrancar usando FastBoot.
Más información sobre la imagen del núcleo y el arranque en este enlace.
Por lo tanto, debe comenzar a descargar la imagen de Android para su teléfono desde los sitios de Google. Vaya al sitio de imágenes de fábrica de Nexus y descargue la imagen de fábrica que coincida con la versión de Android que está en su teléfono.
Descargue la imagen de fábrica para el Nexus6 (Shamu) Android 6.0.1 (MMB29K) aquí.
==> Extraelo a/home/user/factory/shamu-mmb29k
export FACTORY=/home/user/factory/shamu-mmb29k
cd $FACTORY
mkdir unziped_img
unzip ./image-shamu-mmb29k.zip -d unziped_img
cd unziped_img
O descargue el boot.img desde este enlace.
Inspirado en [esta guía] (http://rex-shen.net/android-unpackpack-factory-images/.
sudo apt-get install abootimg
Vaya a un archivo de imagen de fábrica descomprimido o un archivo Boot.img descargado,
mkdir boot
cd boot
abootimg -x ../boot.img
# after the successful execution of the last command, we will have initrd.img (= ramdisk), zImage (= kernel) and bootimg.cfg (= kernel config)
# inside the boot folder.
Si desea inspeccionar los rootfs del sistema de archivos raíz desde el ramdisk :
file initrd.img
# the output should be similar to the following line:
# initrd.img: gzip compressed data, from Unix
mkdir ramdisk
cd ramdisk
# "gunzip -c" means unpack to standard output, and "cpio -i" convert standard output in files
gunzip -c ../initrd.img|cpio -i
# to create an image:
abootimg --create boot.img -f bootimg.cfg -k $MYKERNEL/arch/arm/boot/zImage-dtb -r initrd.img [-s <secondstage>] -c bootsize=[SIZE_IT_WANTS]
# to update an existing image:
abootimg -u boot.img -f bootimg.cfg -k $MYKERNEL/arch/arm/boot/zImage-dtb -r initrd.img [-s <secondstage>] -c bootsize=[SIZE_IT_WANTS]
Nota: La opción "-r" , donde Ramdisk es initrd.img, no la carpeta Ramdisk.
Nota: Es mi caso, solo funciona con Zimage-DTB , no con Zimage ni ** Imagen
Descargue la herramienta oficial de Google.
==> Extraelo a/home/user/bootimgtool
mkdir $FACTORY/unpacked_img
export BOOTIMGTOOL=/home/user/bootimgtool
cd $BOOTIMGTOOL
./unpack_bootimg --boot_img $FACTORY/unziped_img/boot.img --out $FACTORY/unpacked_img
cp $MYKERNEL/arch/arm/boot/zImage-dtb $ $FACTORY/unpacked_img/kernel
./mkbootimg --kernel $FACTORY/unpacked_img/kernel --ramdisk $FACTORY/unpacked_img/ramdisk -o $FACTORY/boot.img
Descargue esta herramienta.
git clone https://github.com/bzyx/bootimg-tools
export BOOTIMGTOOL=/home/user/bootimg-tools
Luego debe desempaquetar el .img de su imagen de fábrica. Insérvelo su núcleo personalizado y vuelva a empaquetarlo.
cd $BOOTIMGTOOL
make
cd mkbootimg
./unmkbootimg -i $FACTORY/unziped_img/boot.img
cp $MYKERNEL/arch/arm/boot/zImage-dtb $ $FACTORY/unpacked_img/kernel
./mkbootimg --base 0 --pagesize 2048 --kernel_offset 0x00008000 --ramdisk_offset 0x02000000 --second_offset 0x00f00000 --tags_offset 0x01e00000 --cmdline 'console=ttyHSL0,115200,n8 androidboot.console=ttyHSL0 androidboot.hardware=shamu msm_rtb.filter=0x37 ehci-hcd.park=3 utags.blkdev=/dev/block/platform/msm_sdcc.1/by-name/utags utags.backup=/dev/block/platform/msm_sdcc.1/by-name/utagsBackup coherent_pool=8M' --kernel kernel --ramdisk ramdisk.cpio.gz -o $FACTORY/boot.img
adb reboot bootloadero presionar manualmente la potencia y sonar más abajo durante unos segundos.
Luego grabando: fastboot devices
Su dispositivo debe aparecer en la lista
Si desea probar rápidamente si su nuevo arranque personalizado.img está bien, intente funcional: fastboot boot boot.img
Si no regresa, falló , puede intentar flashearlo en la memoria usando:
fastboot flash boot boot.img
fastboot reboot
cd $FACTORY
zip -r ../image-shamu-mmb29k.zip boot.img
fastboot devices ==> device must appear in the list
./flash-all.sh o fastboot -w update image-shamu-mmb29k.zip
fastboot reboot
Si desea obtener más información sobre las diferentes particiones, el sistema Android, los comandos FastBoot, etc., lanzar una mirada aquí.
Puede usar un script automático como CF-Auto-Root para él.
O siga los siguientes pasos inspirados en esta guía.
/*
* hello-1.c - The simplest kernel module.
*/
#include <linux/module.h> /* Needed by all modules */
#include <linux/kernel.h> /* Needed for KERN_INFO */
int init_module(void)
{
printk(KERN_INFO "Hello world 1.n");
/*
* A non 0 return means init_module failed; module can't be loaded.
*/
return 0;
}
void cleanup_module(void)
{
printk(KERN_INFO "Goodbye world 1.n");
}
ccflags-y += -fno-stack-protector -fno-pic -Wno-unused-function
obj-m += module.o
module-objs := hello-1.o hello-2.o hello-3.o
CROSS_COMPILE=/home/user/ndk/arm-eabi-4.8/binarm-eabi-
KERNEL_DIR=/home/user/images_kernel/msm-android-msm-shamu-3.10-marshmallow
TMP_BUILD ?= /tmp/build
MODULE_NAME = module.ko
mkfile_path := $(abspath $(lastword $(MAKEFILE_LIST)))
current_dir := $(patsubst %/,%,$(dir $(mkfile_path)))
all:
mkdir -p $(TMP_BUILD)
cp ./*.c ./*.h ./Makefile $(TMP_BUILD)
make -C ${KERNEL_DIR} M=$(TMP_BUILD) ARCH=arm PLATFORM=shamu CROSS_COMPILE=${CROSS_COMPILE} modules V=1
cp $(TMP_BUILD)/$(MODULE_NAME) $(PWD)/$(MODULE_NAME)
rm -rf $(TMP_BUILD)
clean:
make -C ${KERNEL_DIR} M=$(PWD) clean
make
Debería crear el módulo.ko
adb push module.ko /data/local/tmp
adb shell su -c "lsmod"
adb shell su -c "insmod /data/local/tmp/module.ko"
adb shell su -c "lsmod"
Puedes tener más información con:
adb shell su -c "cat /proc/kmsg"
Más información sobre la programación del módulo del núcleo aquí.
