Steps To Fix Android X86 Kernel Build

Launch Android On Your PC

Adapt Core

The Android build system doesn’t build the kernel on the fly. It only contains your pre-built kernel binary, which is sometimes added to the target image. This approach may be sufficient for the Arm emulator, but it never works for x86 platforms. There are hardware on different x86 platforms. The kernel binary and its modules may indeed need some tweaking at compile time or run time.

This article explains another feature of the Android x86 build program. This means the ability to customize the kernel and modules using the configuration defined or adapted during method creation.

Prepare This Source Tree

We’ve tweaked the Android build system to build a kernel image on the fly. You should use our repository to get this functionality. Read the table of contents for more details.

Build A Goal To Avoid Paying The Core

We have standard guaranteed target configurations for Android-x86 in kernel / arch / x86 / configs / . As a result, the defconfig of the selected person is automatically used. For example,

make iso_img TARGET_PRODUCT = android_x86_64

TARGET_PRODUCT For android_x86_64 , the build system will automatically pick a specific android-x86_64_defconfig configuration to run this kernel binary and its compilation units. This information is generated in binary format in out / target / product / x86_64 / kernel , modules are also stored in detail in out / target / product / x86_64 / system / lib / modules / … The final target out / target / product / x86_64 / android_x86_64.iso contains things like kernel, binary, and these are indeed modules.

Build Only On This Update Kernel

To advertise only the kernel and its programs, change the target of iso_img so that the kernel can:

. build / envsetup.sh; Lunch android_x86_64-userdebug
Building the kernel

Then withFamilies can copy $ OUT / kernel and $ OUT / system / lib / modules / to support the target device. Place the initial version in the Android-x86 installation directory and therefore the latest in / system / lib / modules . Note that the specific / system must be installed in the same way as in read-write mode.

Core

Specify The Architecture

Since Android 5.0, it supports all 32bit 64bit images. Typically 32-bit user-space would work with a 32-bit kernel, and 64-bit user-space should work with a 64-bit kernel. Android x86 build system supports viewing as x86 Lollipop.

Sometimes you might want to run 32-bit user space with 64-bit kernels. In this case, you can specify the kernel style with TARGET_KERNEL_ARCH :

. build / envsetup.sh; Lunch android_x86-userdebug
m -j8 iso_img TARGET_KERNEL_ARCH = x86_64

This creates a great 32-bit user-space image with a 64-bit kernel.

Forced Kernel Recompilation

Android and the kernel Use completely different build systems. Although we alternate them together, the integration doesn’t work very well. For example, whether you change the view of the kernel tree or not, the Android build system will not notice the whitespace. This means that sometimes the kernel is not automatically rebuilt when you rebuild images.

There are several solutions for this. We contact defconfig as:

touch kernel / arch / x86 / configs / android-x86_ *

Or, as you can see, remove the kernel config in the out / directory:

rm $ OUT / obj / kernel / .config

Or remove the visible kernel image:

Recommended: Fortect

Are you tired of your computer running slowly? Is it riddled with viruses and malware? Fear not, my friend, for Fortect is here to save the day! This powerful tool is designed to diagnose and repair all manner of Windows issues, while also boosting performance, optimizing memory, and keeping your PC running like new. So don't wait any longer - download Fortect today!

1. Download and install Fortect

2. Open the program and click "Scan"

3. Click "Repair" to start the repair process

rm $ OUT / obj / kernel / arch / x86 / boot / bzImage

Then recreate the image, although this is common.

Replace Current Kernel

Since we are building a module-aware kernel to keep the installed platform kernel new, you should also replace each of our modules accordingly. To do this, copy the kernel from theBack to a specific Android x86 installation directory and copy the quests to / system / lib / modules . The best way to do this is to start with the debug method:

Android-x86 recognized … can be found in / dev / sda1

enter ‘exit’ to continue …

Launching Korn mirbsd Shell …
Quit

Use Alt-F1 / F2 / F3 to get real fruits. between virtual consoles
Enter “exit” to access Android …

Launching Korn mirbsd Shell …
mount / dev / sdb1 / hd
cp / hd / kernel / src
rm -rf / system / lib / modules / *
cp -a / hd / modules / * / system / lib / modules
sync ; mount / hd; Restart -f

The instance is taking a new kernel image, but the corresponding modules are on some USB hard drive / dev / sdb1 and you can see that / system / was installed in read mode -records.

Building Your Own Kernel

Suppose you already have a large working kernel configuration for universal serialoh tires. Just put your awesome config file in kernel / arch / x86 / configs / and stream (assuming your own config name is my_defconfig)

make iso_img TARGET_PRODUCT = android_x86 TARGET_KERNEL_CONFIG = my_defconfig

Please note that due to Android-x86, you cannot use the kernel config from a regular Linux distribution (like Ubuntu). For this to work, you need to enable the mobile core features. See android / configs / android-base.cfg for a list of related configuration options required for a kernel to actually support the Android system. (but takes Android-x86 specific parameters like PMEM)

Set Up Kernel Config

It is never a good idea to directly edit a specific kernel config file because the site can generate misconfiguration (unfulfilled dependencies, etc.). The correct way to set up kernel config is indeed (at the top of the android-x86 tree)

. build / envsetup.sh; Snacks android_x86_64-userdebug
make -C kernel O = $ OUT / obj / kernel ARCH = x86 menuconfig


If you get a great error message Unknown parameter: -C , use make / usr / bin / make . This is because the build system on Android 8 takes precedence over the default build system. To overcome this, simply use the system command line make.

Generated config: $ OUT / obj / kernel / .config . It copies what helps you where you want it.

DO NOT create menuconfig directly in the kernel / directory. This could violate simple building rules. In this case, try restoring the items (at the top of the Android x86 tree):

make -C kernel distclean
rm -rf $ OUT / obj / kernel


Use A Ready-made Kernel

If you see a working prebuilt kernel binary on your hardware, you can use it to create a specific ISO:

make iso_img TARGET_PRODUCT = android_x86 TARGET_PREBUILT_KERNEL =

Compile Kernel For ARM (deprecated)

It is also possible to use a kernel build system that can compile a kernel for ARM. For example, compile kernel 2.6.29 for Goldfish processor from armpit emulator, run

Core CD
explore git x86 / android-goldfish-2.6.29
cd ..
make core TARGET_NO_KERNEL =
target_kernel_config = goldfish_defconfig

The kernel binary is generated at out / target / product / generic / kernel.
It would be important to set TARGET_NO_KERNEL to empty, otherwise the kernel build methods will be ignored.