If you’ve ever wondered “how to build an Android kernel”, this guide is for you. Building your own kernel can be a rewarding experience as it will give you a greater degree of control over your Android device, from the CPU, RAM, GPU to even the battery.
This is a very hands-on process that involves a lot of compiling and console commands, but if you’re familiar with Linux (or good at following directions) it should be no problem.
Please note this guide is for non-Mediatek devices.
If you’re building a custom kernel, you will just need to clone the kernel from Git with commands provided below. But if you’re compiling a stock kernel, you need to know where to get the original kernel from source (for all sorts of reasons).
So as an example, this would be the command to grab the latest Nexus 6P Nougat 3.10 kernel from Google: git clone -b android-msm-angler-3.10-nougat-mr2 https://android.googlesource.com/kernel/msm/ angler
This should clone the kernel / msm repo into an angler folder, and automatically checkout the android-msm-angler-3.10-nougat-mr2.
Now because most Android devices are ARM based, we’ll need to use a compiler that will target ARM devices – this means a host/native compiler won’t work, unless you’re compiling on another ARM device. You have a few options here. You can either compile one yourself if you know how, using something like Crosstool-NG. Alternatively, you can download a prebuilt compiler – such as the one Google provides for Arm 32-bit and Arm64.
Before downloading a prebuilt compiler, you need to know the exact architecture of your device, so use an app like CPU-Z to determine it.
One other popular toolchain would be UberTC – but for any kernels higher than 4.9, you’ll need to patch them, and compiling with Google’s toolchain first is best practice.
In any case, once you’ve decided on the toolchain, you need to clone it. git clone
Now point the Makefile to your compiler, running it from within the toolchain folder**.**
Locate your proper defconfig by navigating to the arch//configs folder within the kernel source (e.g. arch/arm64/configs).
Next locate the developer’s proper config file for the kernel you are building. It should typically be in the form of _defconfig or <kernel_name>_defconfig. The defconfig will instruct the compiler what options to include in the kernel.
Generic Qualcomm configs may also be found, these will usually be something like (msm-perf_defconfig, msmcortex-perf_defconfig).
Building the Kernel
Code:
make clean make mrproper
_make _ make -j$(nproc –all)
When those commands are successful, you should have: an Image, Image-dtb, Image.gz, or Image.gz-dtb file at the end.
If those commands failed, you might need to specify the output directory when making a new CAF based kernel, like this:
mkdir -p out make O=out clean make O=out mrproper
_make O=out _ make O=out -j$(nproc –all)
If it still doesn’t want to work, something is broken – check your headers or bring it up with the kernel developers.
If the kernel was successfully compiled, you now need to flash it. There are two different ways of doing this – you can unpack and repack the bootimage using either Android Image Kitchen or AnyKernel2.
There may also be some nuances based on specific devices – you’ll need to ask your device developers for assistance if this is the case.
The first column is the value you want to set block to.
Now re-zip the kernel, and flash it in AnyKernel2: zip -r9 kernel.zip * -x README.md kernel.zip
Be warned that many kernels from CAF include a Python script that will trigger –Werror, which basically causes your build to throw errors at the tiniest of things. So for higher GCC versions (which include more warnings), you’ll typically need to make changes in the Makefile:
`
diff --git a/Makefile b/Makefile
index 1aaa760f255f..bfccd5594630 100644
--- a/Makefile
+++ b/Makefile
@@ -326,7 +326,7 @@ include $(srctree)/scripts/Kbuild.include
AS = $(CROSS_COMPILE)as
LD = $(CROSS_COMPILE)ld
-REAL_CC = $(CROSS_COMPILE)gcc
+CC = $(CROSS_COMPILE)gcc
CPP = $(CC) -E
AR = $(CROSS_COMPILE)ar
NM = $(CROSS_COMPILE)nm
@@ -340,10 +340,6 @@ DEPMOD = /sbin/depmod
PERL = perl
CHECK = sparse``
-# Use the wrapper for the compiler. This wrapper scans for new
-# warnings and causes the build to stop upon encountering them.
-CC = $(srctree)/scripts/gcc-wrapper.py $(REAL_CC)
CHECKFLAGS := -Dlinux -Dlinux -DSTDC -Dunix -Dunix \
-Wbitwise -Wno-return-void $(CF)
CFLAGS_MODULE =
`
Using a higher GCC toolchain (5.x, 6.x, 7.x or even 8.x) will require you to nuke the GCC wrapper script as above and use a unified GCC header file (pick the following if you have an include/linux/compiler-gcc#.h file):
If you’ve ever wondered “how to build an Android kernel”, this guide is for you. Building your own kernel can be a rewarding experience as it will give you a greater degree of control over your Android device, from the CPU, RAM, GPU to even the battery.
This is a very hands-on process that involves a lot of compiling and console commands, but if you’re familiar with Linux (or good at following directions) it should be no problem.
Please note this guide is for non-Mediatek devices.
Other Appual’s articles of interest include:
If you’re building a custom kernel, you will just need to clone the kernel from Git with commands provided below. But if you’re compiling a stock kernel, you need to know where to get the original kernel from source (for all sorts of reasons).
Original Kernel Sources for Various Brands:
For downloading the kernel, either use a git clone or download the tarball file and extract it.
Here is the git command:
git clone -b <branch_to_checkout> <desired_folder_name>
–OR–
tar -xvf
So as an example, this would be the command to grab the latest Nexus 6P Nougat 3.10 kernel from Google:
git clone -b android-msm-angler-3.10-nougat-mr2 https://android.googlesource.com/kernel/msm/ angler
This should clone the kernel / msm repo into an angler folder, and automatically checkout the android-msm-angler-3.10-nougat-mr2.
Now because most Android devices are ARM based, we’ll need to use a compiler that will target ARM devices – this means a host/native compiler won’t work, unless you’re compiling on another ARM device. You have a few options here. You can either compile one yourself if you know how, using something like Crosstool-NG. Alternatively, you can download a prebuilt compiler – such as the one Google provides for Arm 32-bit and Arm64.
Before downloading a prebuilt compiler, you need to know the exact architecture of your device, so use an app like CPU-Z to determine it.
One other popular toolchain would be UberTC – but for any kernels higher than 4.9, you’ll need to patch them, and compiling with Google’s toolchain first is best practice.
In any case, once you’ve decided on the toolchain, you need to clone it.
git clone
Now point the Makefile to your compiler, running it from within the toolchain folder**.**
Example:
Now tell the Makefile your device architecture.
Example:
Locate your proper defconfig by navigating to the arch//configs folder within the kernel source (e.g. arch/arm64/configs).
Next locate the developer’s proper config file for the kernel you are building. It should typically be in the form of_defconfig or <kernel_name>_defconfig. The defconfig will instruct the compiler what options to include in the kernel.
Generic Qualcomm configs may also be found, these will usually be something like (msm-perf_defconfig, msmcortex-perf_defconfig).
Building the Kernel
Code:
make clean_
make mrproper
_make
make -j$(nproc –all)
When those commands are successful, you should have: an Image, Image-dtb, Image.gz, or Image.gz-dtb file at the end.
If those commands failed, you might need to specify the output directory when making a new CAF based kernel, like this:
mkdir -p out_
make O=out clean
make O=out mrproper
_make O=out
make O=out -j$(nproc –all)
If it still doesn’t want to work, something is broken – check your headers or bring it up with the kernel developers.
If the kernel was successfully compiled, you now need to flash it. There are two different ways of doing this – you can unpack and repack the bootimage using either Android Image Kitchen or AnyKernel2.
There may also be some nuances based on specific devices – you’ll need to ask your device developers for assistance if this is the case.
Flashing the Kernel in Android Image Kitchen
Download Android Image Kitchen
Extract your Android device’s boot image from the latest available image (whether stock or custom ROM).
Now unpack the image using this code:.img_
_unpackimg.sh
Next locate the zImage file, and replace it with your compiled kernel image – rename it to what was in the boot image.
Now run this code to repack the image:
repackimg.sh
Now you can flash the new boot image using fastboot, TWRP, etc.
Flashing the Kernel in AnyKernel2
Download the latest AnyKernel2
Apply this patch to flush out all the demo files.
wget https://github.com/nathanchance/AnyKernel2/commit/addb6ea860aab14f0ef684f6956d17418f95f29a.diff
patch -p1 < addb6ea860aab14f0ef684f6956d17418f95f29a.diff
rm addb6ea860aab14f0ef684f6956d17418f95f29a.diff
Now place your kernel image in the root of the file, and open the anykernel.sh to modify these values:
The first column is the value you want to set block to.
Now re-zip the kernel, and flash it in AnyKernel2:
zip -r9 kernel.zip * -x README.md kernel.zip
Be warned that many kernels from CAF include a Python script that will trigger –Werror, which basically causes your build to throw errors at the tiniest of things. So for higher GCC versions (which include more warnings), you’ll typically need to make changes in the Makefile:
`
diff --git a/Makefile b/Makefile
index 1aaa760f255f..bfccd5594630 100644
--- a/Makefile
+++ b/Makefile
@@ -326,7 +326,7 @@ include $(srctree)/scripts/Kbuild.include
AS = $(CROSS_COMPILE)as
LD = $(CROSS_COMPILE)ld
-REAL_CC = $(CROSS_COMPILE)gcc
+CC = $(CROSS_COMPILE)gcc
CPP = $(CC) -E
AR = $(CROSS_COMPILE)ar
NM = $(CROSS_COMPILE)nm
@@ -340,10 +340,6 @@ DEPMOD = /sbin/depmod
PERL = perl
CHECK = sparse``
-# Use the wrapper for the compiler. This wrapper scans for new
-# warnings and causes the build to stop upon encountering them.
-CC = $(srctree)/scripts/gcc-wrapper.py $(REAL_CC)
CHECKFLAGS := -Dlinux -Dlinux -DSTDC -Dunix -Dunix \
-Wbitwise -Wno-return-void $(CF)
CFLAGS_MODULE =
`
Using a higher GCC toolchain (5.x, 6.x, 7.x or even 8.x) will require you to nuke the GCC wrapper script as above and use a unified GCC header file (pick the following if you have an include/linux/compiler-gcc#.h file):
3.4/3.10: https://git.kernel.org/pub/scm/linux…9bb8868d562a8a
3.18: https://git.kernel.org/pub/scm/linux…9f67d656b1ec2f
Even if you get a lot of warnings, they’re not necessary to fix (typically).
Your kernel is built and ready to go!