How_to_build_android_kernel_to_load_modules_dynamically
1.0.0
Este é um tutorial que mostra as etapas para:
Este tuto foi feito para o seguinte alvo:
Downlad Adb e Fastboot do seu gerenciador de pacotes ou seguindo este guia.
sudo apt-get install adb fastboot
Inicie o daemon do ADB , verifique se você pode ver o telefone com o ADB e reiniciá -lo no modo Bootloader (modo Fastboot).
adb start-server
adb devices
adb reboot bootloader
Verifique se você pode ver o telefone com o Fastboot e desbloquear o carregador de inicialização
fastboot devices
fastboot oem unlock
(or fastboot flashing unlock for newest phones)
Você também pode seguir este guia oficial para iniciar manualmente no modo Fastboot e desbloquear o carregador de inicialização.
Você pode encontrar outros comandos Fastboot aqui.
Eu tentei usar o NDK estável mais recente do repositório oficial.
(Não baixe !! não 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-
Mas eu tive avisos muito estranhos na compilação que bloqueavam a lincking final.
Então, depois de poucas pesquisas que achei aqui, era melhor usar o Arm-EaBi-GCC em vez do Arm-Linux-AndroideAbi-GCC .
Portanto, baixei a versão mais recente do ARM-EABI-4.8.
==> Extraia-o para /home/user/ndk/arm-eabi-4.8
export PATH=$PATH:/home/user/ndk/arm-eabi-4.8/bin
export CROSS_COMPILE=arm-eabi-
NOTA: Posso confirmar a escolha do Arm-Eabi-4.8 porque é o compilador cruzado definido na própria imagem do kernel no 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 inserir nosso próprio módulo de kernel no kernel Nexus 6, precisamos ter o suporte ao módulo carregável da opção de configuração do kernel ativado. Se você já enraizou seu telefone, pode verificar a gravação, outros confie em mim:
adb shell su -c "lsmod"
or
adb shell su -c "insmod /data/local/tmp/glitchmin.ko"
Essas funções não são autorizadas por padrão nos kernels do Android. Portanto, exibiremos um novo kernel com o suporte ao módulo carregado de opção ativado.
O Nexus 6 (Shamu) que recebemos foi configurado da seguinte maneira:
De acordo com esta lista, baixei este Google Kernel Oficial Android-MSM-Shamu-3.10-Marshmallow.
==> Extraia-o para /home/user/images_kernel/msm-android-msm-shamu-3.10-marshmallow export mykernel =/home/user/imagens_kernel/msm-android-msm-shamu-3.10-marshmallow CD $ mykernel
Você também pode usar o [cyanogenmod kernel android_kernel_moto_shamu] (https://github.com/cyanogenmod/android_kernel_moto_shamu) (<- finalmente este não inicializa)
Em seguida, você pode criar seu kernel seguindo as próximas etapas (inspiradas neste guia ou neste guia ou [este] (https://source.android.com/setup/build/devices ou este último).
Em $ mykernel/arch/braç/configs/shamu_config, substitua
# CONFIG_MODULES is not set
por
CONFIG_MODULES=y
Então
cp arch/arm/configs/shamu_config .config
make ARCH=arm SUBARCH=arm CROSS_COMPILE=arm-eabi- shamu_defconfig
Verifique se a opção Ative o suporte do módulo carregável está bem ativado com: make ARCH=arm SUBARCH=arm CROSS_COMPILE=arm-eabi- menuconfig
==> Se não for, selecione Ativar suporte do módulo carregado , pressione espaço no teclado e selecione Salvar e sair
Finalmente, compilar todo o kernel (leva muito tempo ...): make ARCH=arm SUBARCH=arm CROSS_COMPILE=arm-eabi- -j4
(Nota: -jn significa que usará o processador N no Parallele)
Você deve obter no 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
Você pode encontrar sua imagem , Zimage e Zimage-DTB em $ mykernel/arch/braç/boot//
Você pode encontrar o Blob da Árvore do Device .dtb em $ mykernel/arch/braç/boot/dts/*. Dtb
Você tem seu kernel pronto. Na maioria dos sistemas incorporados que serão o fim do seu trabalho. Normalmente, você copia o kernel para o cartão SD ou o NFS, e a placa inicializa. Mas no Android é diferente. Você precisa preparar partição de inicialização especial, que pode inicializar usando o Fastboot.
Mais informações sobre o kernel e a imagem de inicialização neste link.
Então, você precisa começar ao baixar a imagem do Android para o seu telefone nos sites do Google. Vá para o site Nexus Factory Images e faça o download da imagem de fábrica que corresponde à versão Android que está no seu telefone.
Faça o download da imagem da fábrica para o Nexus6 (Shamu) Android 6.0.1 (MMB29K) aqui.
==> extraia-o para/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
Ou baixe o boot.img deste link.
Inspirado em [Este guia] (http://rex-shen.net/android-unpackpack-factory-images/.
sudo apt-get install abootimg
Vá para o arquivo de imagem de fábrica desconfiado ou o arquivo boot.img baixado, o arquivo,
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.
Se você deseja inspecionar o sistema de arquivos raiz rootfs do 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: A opção "-r" , onde o ramdisk é initrd.img, não a pasta Ramdisk.
Nota: é meu caso, funciona apenas com Zimage-DTB , não com Zimage nem ** imagem
Faça o download da ferramenta oficial do Google.
==> extraia -o para/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
Baixe esta ferramenta.
git clone https://github.com/bzyx/bootimg-tools
export BOOTIMGTOOL=/home/user/bootimg-tools
Então você precisa descompactar o .img da sua imagem de fábrica. Insira seu kernel personalizado e reembala -o.
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 bootloaderou pressionar manualmente poder e soar mais abaixo por alguns segundos.
Em seguida, gravação: fastboot devices
Seu dispositivo deve aparecer na lista
Se você deseja testar rapidamente se sua nova inicialização personalizada.img estiver bem funcional, tente: fastboot boot boot.img
Se não retornar, você falhou , você pode tentar exibi -lo na memória 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 ou fastboot -w update image-shamu-mmb29k.zip
fastboot reboot
Se você quiser aprender mais sobre as partições diferentes, o sistema Android, os comandos Fastboot, etc ..., ligue isso para aqui.
Você pode usar um script automático como o CF-AUTO-ROOT para ele.
Ou siga as próximas etapas inspiradas neste guia.
/*
* 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
Deve criar o 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"
Você pode ter mais informações com:
adb shell su -c "cat /proc/kmsg"
Mais informações sobre a programação do módulo do kernel aqui.
