How_to_build_android_kernel_to_load_modules_dynamically
1.0.0
C'est un tutoriel qui montre les étapes pour:
Ce Tuto a été fait pour la cible suivante:
Downlad ADB et Fastboot de votre gestionnaire de packages ou suivant ce guide.
sudo apt-get install adb fastboot
Démarrez le démon ADB , vérifiez que vous pouvez voir le téléphone avec ADB et le redémarrer en mode chargeur de démarrage (mode FastBoot).
adb start-server
adb devices
adb reboot bootloader
Vérifiez que vous pouvez voir le téléphone avec Fastboot et déverrouiller le chargeur de démarrage
fastboot devices
fastboot oem unlock
(or fastboot flashing unlock for newest phones)
Vous pouvez également suivre ce guide officiel pour démarrer manuellement en mode FastBoot et pour déverrouiller le chargeur de démarrage.
Vous pouvez trouver d'autres commandes FastBoot ici.
J'ai d'abord essayé d'utiliser le dernier NDK stable du dépôt officiel.
(Ne le téléchargez pas !! ça ne fonctionne pas)
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-
Mais j'ai eu des avertissements très étranges à la compilation qui bloquaient la finition finale.
Donc, après quelques recherches que j'ai trouvées ici, il valait mieux utiliser l' ARM-EABI-GCC plutôt que le bras-linux-androidabi-gcc .
J'ai donc téléchargé la dernière version d'ARM-EABI-4.8.
==> Extrairez-le sur /home/user/ndk/arm-eabi-4.8
export PATH=$PATH:/home/user/ndk/arm-eabi-4.8/bin
export CROSS_COMPILE=arm-eabi-
Remarque: Je peux confirmer le choix d' ARM-EABI-4.8 car c'est le compilateur croisé défini dans l'image du noyau lui-même dans 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
"
Afin d'insérer notre propre module de noyau dans le noyau Nexus 6, nous devons faire en sorte que l'option de configuration du noyau prenne en charge le module chargeable . Si vous avez déjà enraciné votre téléphone, vous pouvez le vérifier à enregistrer, AngelElse Crusez-moi:
adb shell su -c "lsmod"
or
adb shell su -c "insmod /data/local/tmp/glitchmin.ko"
Ces fonctions ne sont pas autorisées par défaut dans les noyaux Android. Par conséquent, nous allons flasher un nouveau noyau avec l'option Prise en charge du module chargé activé.
Le Nexus 6 (Shamu) que nous avons reçu a été configuré comme suit:
Selon cette liste, j'ai téléchargé ce Kernel Google officiel Android-MSM-Shamu-3.10-Marshmallow.
==> Extrairez-le sur /home/user/images_kernel/msm-android-msm-chamu-3.10-marshmallow export mykernel = / home / user / images_kernel / msm-android-msm-shamu-3.10-marshmallow cd $ mykernel
Vous pouvez également utiliser le [Kernel CyanogenMod Android_Kernel_Moto_Shamu] (https://github.com/cyanogenmod/android_kernel_moto_shamu) (<- enfin celui-ci ne démarre pas)
Ensuite, vous pouvez construire votre noyau après les étapes suivantes (inspirées de ce guide ou de ce guide ou [celle-ci] (https://source.android.com/setup/build/devices ou ce dernier).
Dans $ mykernel / arch / arm / configs / shamu_config, substitut
# CONFIG_MODULES is not set
par
CONFIG_MODULES=y
Alors
cp arch/arm/configs/shamu_config .config
make ARCH=arm SUBARCH=arm CROSS_COMPILE=arm-eabi- shamu_defconfig
Vérifiez si l'option Activer la prise en charge du module chargé est bien activée avec: make ARCH=arm SUBARCH=arm CROSS_COMPILE=arm-eabi- menuconfig
==> Si non, sélectionnez Activer la prise en charge du module chargé , appuyez sur l'espace sur votre clavier, puis sélectionnez Enregistrer et quitter
Enfin, compilez le noyau entier (cela prend beaucoup de temps ...): make ARCH=arm SUBARCH=arm CROSS_COMPILE=arm-eabi- -j4
(Remarque: -jn signifie qu'il utilisera le processeur n en parallele)
Vous devez obtenir à la fin quelque chose comme:
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
Vous pouvez trouver votre image , Zimage et Zimage-DTB dans $ mykernel / arch / arm / boot /
Vous pouvez trouver l'arborescence de l'appareil blob .dtb à $ mykernel / arch / arm / boot / dts / *. Dtb
Vous avez votre noyau prêt. Sur la plupart des systèmes intégrés, ce sera la fin de votre travail. Habituellement, vous copiez le noyau sur la carte SD ou l'emplacement NFS, et la carte démarrera. Mais sur Android, c'est différent. Vous devez préparer une partition de démarrage spéciale qui peut ensuite démarrer à l'aide de Fastboot.
Plus d'informations sur le noyau et l'image de démarrage sur ce lien.
Vous devez donc commencer par le téléchargement de l'image Android pour votre téléphone à partir de sites Google. Accédez au site d'images d'usine Nexus et téléchargez l'image d'usine qui correspond à la version Android qui se trouve sur votre téléphone.
Téléchargez l' image d'usine pour le Nexus6 (Shamu) Android 6.0.1 (MMB29K) ici.
==> Extraire à / home / utilisateur / usine / 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 téléchargez le boot.img à partir de ce lien.
Inspiré de [ce guide] (http://rex-shen.net/android-unpackpack-factory-images/.
sudo apt-get install abootimg
Allez dans un fichier image d'usine non terzy
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 vous souhaitez inspecter le système de fichiers racine rootfs à partir du 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]
Remarque: L'option "-r" , où Ramdisk est initrd.img, pas le dossier Ramdisk.
Remarque: c'est mon cas, cela ne fonctionne qu'avec Zimage-DTB , pas avec Zimage ni ** image
Téléchargez l'outil Google officiel.
==> Extraire à / 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
Téléchargez cet outil.
git clone https://github.com/bzyx/bootimg-tools
export BOOTIMGTOOL=/home/user/bootimg-tools
Ensuite, vous devez déballer le .img de votre image d'usine. Insérez-le votre noyau personnalisé et reconditionnez-le.
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 appuyer sur la puissance manuelle et le son plus bas pendant quelques secondes.
Puis enregistrement: fastboot devices
Votre appareil doit apparaître dans la liste
Si vous souhaitez tester rapidement si votre nouveau démarrage personnalisé fastboot boot boot.img
S'il ne revient pas, vous pouvez essayer de le flasher en mémoire en utilisant:
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
Si vous souhaitez en savoir plus sur les différences de partitions, le système Android, les commandes FastBoot, etc ..., jettent un coup d'œil à ce sujet ici.
Vous pouvez utiliser un script automatique comme CF-Auto-Root pour cela.
Ou suivez ces prochaines étapes inspirées de ce guide.
/*
* 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
Il devrait créer le module.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"
Vous pouvez avoir plus d'informations avec:
adb shell su -c "cat /proc/kmsg"
Plus d'informations sur la programmation des modules de noyau ici.
