| #!/bin/sh |
| # |
| # A small script used to rebuild the Android goldfish kernel image |
| # See docs/KERNEL.TXT for usage instructions. |
| # |
| |
| export LANG=C |
| export LC_ALL=C |
| |
| PROGNAME=$(basename "$0") |
| |
| MACHINE=goldfish |
| VARIANT=goldfish |
| OUTPUT=/tmp/kernel-qemu |
| CROSSPREFIX=arm-linux-androideabi- |
| CONFIG=goldfish |
| GCC_VERSION=4.9 |
| |
| VALID_ARCHS="arm x86 x86_64 mips arm64 mips64" |
| |
| # Determine the host architecture, and which default prebuilt tag we need. |
| # For the toolchain auto-detection. |
| # |
| HOST_OS=`uname -s` |
| case "$HOST_OS" in |
| Darwin) |
| HOST_OS=darwin |
| HOST_TAG=darwin-x86 |
| BUILD_NUM_CPUS=$(sysctl -n hw.ncpu) |
| ;; |
| Linux) |
| # note that building 32-bit binaries on x86_64 is handled later |
| HOST_OS=linux |
| HOST_TAG=linux-x86 |
| BUILD_NUM_CPUS=$(grep -c processor /proc/cpuinfo) |
| ;; |
| *) |
| echo "ERROR: Unsupported OS: $HOST_OS" |
| exit 1 |
| esac |
| |
| # Default number of parallel jobs during the build: cores * 2 |
| JOBS=$(( $BUILD_NUM_CPUS * 2 )) |
| |
| ARCH=arm |
| |
| OPTION_HELP=no |
| OPTION_ARMV7=yes |
| OPTION_OUT= |
| OPTION_CROSS= |
| OPTION_ARCH= |
| OPTION_CONFIG= |
| OPTION_SAVEDEFCONFIG=no |
| OPTION_JOBS= |
| OPTION_VERBOSE= |
| OPTION_GCC_VERSION= |
| CCACHE= |
| |
| case "$USE_CCACHE" in |
| "") |
| CCACHE= |
| ;; |
| *) |
| # use ccache bundled in AOSP source tree |
| CCACHE=${ANDROID_BUILD_TOP:-$(dirname $0)/../..}/prebuilts/misc/$HOST_TAG/ccache/ccache |
| [ -x $CCACHE ] || CCACHE= |
| ;; |
| esac |
| |
| for opt do |
| optarg=$(expr "x$opt" : 'x[^=]*=\(.*\)') |
| case $opt in |
| --help|-h|-\?) OPTION_HELP=yes |
| ;; |
| --arch=*) |
| OPTION_ARCH=$optarg |
| ;; |
| --armv5) |
| OPTION_ARMV7=no |
| ;; |
| --armv7) |
| OPTION_ARMV7=yes |
| ;; |
| --ccache=*) |
| CCACHE=$optarg |
| ;; |
| --config=*) |
| OPTION_CONFIG=$optarg |
| ;; |
| --cross=*) |
| OPTION_CROSS=$optarg |
| ;; |
| --gcc-version=*) |
| OPTION_GCC_VERSION=$optarg |
| ;; |
| -j*|--jobs=*) |
| OPTION_JOBS=$optarg |
| ;; |
| --out=*) |
| OPTION_OUT=$optarg |
| ;; |
| --savedefconfig) |
| OPTION_SAVEDEFCONFIG=yes |
| ;; |
| --verbose) |
| OPTION_VERBOSE=true |
| ;; |
| *) |
| echo "unknown option '$opt', use --help" |
| exit 1 |
| esac |
| done |
| |
| if [ $OPTION_HELP = "yes" ] ; then |
| echo "Rebuild the prebuilt kernel binary for Android's emulator." |
| echo "" |
| echo "options (defaults are within brackets):" |
| echo "" |
| echo " --help print this message" |
| echo " --arch=<arch> change target architecture [$ARCH]" |
| echo " --armv5 build ARMv5 binaries" |
| echo " --armv7 build ARMv7 binaries (default. see note below)" |
| echo " --out=<directory> output directory [$OUTPUT]" |
| echo " --cross=<prefix> cross-toolchain prefix [$CROSSPREFIX]" |
| echo " --config=<name> kernel config name [$CONFIG]" |
| echo " --savedefconfig run savedefconfig" |
| echo " --ccache=<path> use compiler cache [${CCACHE:-not set}]" |
| echo " --gcc-version=<version> use specific GCC version [$GCC_VERSION]" |
| echo " --verbose show build commands" |
| echo " -j<number> launch <number> parallel build jobs [$JOBS]" |
| echo "" |
| echo "NOTE: --armv7 is equivalent to --config=goldfish_armv7. It is" |
| echo " ignored if --config=<name> is used." |
| echo "" |
| exit 0 |
| fi |
| |
| if [ ! -f include/linux/vermagic.h ]; then |
| echo "ERROR: You must be in the top-level kernel source directory to run this script." |
| exit 1 |
| fi |
| |
| # Extract kernel version, we'll need to put this in the final binaries names |
| # to ensure the emulator can trivially know it without probing the binary with |
| # 'file' or other unreliable heuristics. |
| KERNEL_MAJOR=$(awk '$1 == "VERSION" { print $3; }' Makefile) |
| KERNEL_MINOR=$(awk '$1 == "PATCHLEVEL" { print $3; }' Makefile) |
| KERNEL_PATCH=$(awk '$1 == "SUBLEVEL" { print $3; }' Makefile) |
| KERNEL_VERSION="$KERNEL_MAJOR.$KERNEL_MINOR.$KERNEL_PATCH" |
| echo "Found kernel version: $KERNEL_VERSION" |
| |
| if [ -n "$OPTION_ARCH" ]; then |
| ARCH=$OPTION_ARCH |
| fi |
| |
| if [ -n "$OPTION_GCC_VERSION" ]; then |
| GCC_VERSION=$OPTION_GCC_VERSION |
| else |
| if [ "$ARCH" = "x86" ]; then |
| # Work-around a nasty bug. |
| # Hence 132637 is 2.6.29. |
| if [ "$KERNEL_VERSION" = "2.6.29" ]; then |
| GCC_VERSION=4.6 |
| echo "WARNING: android-goldfish-$KERNEL_VERSION doesn't build --arch=$ARCH with GCC 4.7" |
| fi |
| fi |
| if [ "$ARCH" = "arm64" ]; then |
| # There is no GCC 4.7 toolchain to build AARCH64 binaries. |
| GCC_VERSION=4.8 |
| fi |
| if [ "$ARCH" = "mips64" ]; then |
| GCC_VERSION=4.9 |
| fi |
| if [ "$ARCH" = "mips" ]; then |
| GCC_VERSION=4.9 |
| fi |
| echo "Autoconfig: --gcc-version=$GCC_VERSION" |
| fi |
| |
| if [ -n "$OPTION_CONFIG" ]; then |
| CONFIG=$OPTION_CONFIG |
| else |
| case $ARCH in |
| arm) |
| CONFIG=goldfish_armv7 |
| if [ "$OPTION_ARMV7" = "no" ]; then |
| CONFIG=goldfish |
| fi |
| ;; |
| x86) |
| # Warning: this is ambiguous, should be 'goldfish' before 3.10, |
| # and 'i386_emu" after it. |
| if [ -f "arch/x86/configs/i386_emu_defconfig" ]; then |
| CONFIG=i386_emu |
| else |
| CONFIG=goldfish |
| fi |
| ;; |
| x86_64) |
| CONFIG=x86_64_emu |
| ;; |
| mips) |
| CONFIG=goldfish |
| ;; |
| mips64) |
| CONFIG=ranchu64 |
| ;; |
| arm64) |
| CONFIG=ranchu |
| ;; |
| *) |
| echo "ERROR: Invalid arch '$ARCH', try one of $VALID_ARCHS" |
| exit 1 |
| esac |
| echo "Auto-config: --config=$CONFIG" |
| fi |
| |
| # Check output directory. |
| if [ -n "$OPTION_OUT" ] ; then |
| if [ ! -d "$OPTION_OUT" ] ; then |
| echo "Output directory '$OPTION_OUT' does not exist ! Aborting." |
| exit 1 |
| fi |
| OUTPUT=$OPTION_OUT |
| else |
| OUTPUT=$OUTPUT/${ARCH}-${KERNEL_VERSION} |
| case $CONFIG in |
| vbox*) |
| OUTPUT=${OUTPUT}-vbox |
| ;; |
| goldfish) |
| if [ "$ARCH" = "arm" ]; then |
| OUTPUT=${OUTPUT}-armv5 |
| fi |
| ;; |
| esac |
| echo "Auto-config: --out=$OUTPUT" |
| mkdir -p $OUTPUT |
| fi |
| |
| if [ -n "$OPTION_CROSS" ] ; then |
| CROSSPREFIX="$OPTION_CROSS" |
| CROSSTOOLCHAIN=${CROSSPREFIX}$GCC_VERSION |
| else |
| case $ARCH in |
| arm) |
| CROSSPREFIX=arm-linux-androideabi- |
| ;; |
| x86) |
| CROSSPREFIX=x86_64-linux-android- |
| # NOTE: kernel-toolchain/toolbox.sh will add -m32 |
| ;; |
| x86_64) |
| CROSSPREFIX=x86_64-linux-android- |
| ;; |
| mips) |
| CROSSPREFIX=mips64el-linux-android- |
| ;; |
| mips64) |
| CROSSPREFIX=mips64el-linux-android- |
| ;; |
| arm64) |
| CROSSPREFIX=aarch64-linux-android- |
| ;; |
| *) |
| echo "ERROR: Unsupported architecture!" |
| exit 1 |
| ;; |
| esac |
| CROSSTOOLCHAIN=${CROSSPREFIX}$GCC_VERSION |
| echo "Auto-config: --cross=$CROSSPREFIX" |
| fi |
| |
| ZIMAGE=zImage |
| |
| case $ARCH in |
| x86|x86_64) |
| ZIMAGE=bzImage |
| ;; |
| arm64) |
| ZIMAGE=Image |
| ;; |
| mips) |
| ZIMAGE= |
| ;; |
| mips64) |
| ZIMAGE= |
| ;; |
| esac |
| |
| # If the cross-compiler is not in the path, try to find it automatically |
| CROSS_COMPILER="${CROSSPREFIX}gcc" |
| CROSS_COMPILER_VERSION=$($CROSS_COMPILER --version 2>/dev/null) |
| if [ $? != 0 ] ; then |
| BUILD_TOP=$ANDROID_BUILD_TOP |
| if [ -z "$BUILD_TOP" ]; then |
| # Assume this script is under external/qemu/distrib/ in the |
| # Android source tree. |
| BUILD_TOP=$(dirname $0)/../.. |
| if [ ! -d "$BUILD_TOP/prebuilts" ]; then |
| BUILD_TOP= |
| else |
| BUILD_TOP=$(cd $BUILD_TOP && pwd) |
| fi |
| fi |
| case $ARCH in |
| x86_64) |
| # x86_46 binaries are under prebuilts/gcc/<host>/x86 !! |
| PREBUILT_ARCH=x86 |
| ;; |
| arm64) |
| PREBUILT_ARCH=aarch64 |
| ;; |
| mips64) |
| PREBUILT_ARCH=mips |
| ;; |
| *) |
| PREBUILT_ARCH=$ARCH |
| ;; |
| esac |
| CROSSPREFIX=$BUILD_TOP/prebuilts/gcc/$HOST_TAG/$PREBUILT_ARCH/$CROSSTOOLCHAIN/bin/$CROSSPREFIX |
| echo "Checking for ${CROSSPREFIX}gcc" |
| if [ "$BUILD_TOP" -a -f ${CROSSPREFIX}gcc ]; then |
| echo "Auto-config: --cross=$CROSSPREFIX" |
| else |
| echo "It looks like $CROSS_COMPILER is not in your path ! Aborting." |
| exit 1 |
| fi |
| fi |
| |
| if [ "$CCACHE" ] ; then |
| echo "Using ccache program: $CCACHE" |
| CROSSPREFIX="$CCACHE $CROSSPREFIX" |
| fi |
| |
| export CROSS_COMPILE="$CROSSPREFIX" ARCH SUBARCH=$ARCH |
| |
| if [ "$OPTION_JOBS" ]; then |
| JOBS=$OPTION_JOBS |
| else |
| echo "Auto-config: -j$JOBS" |
| fi |
| |
| |
| # Special magic redirection with our magic toolbox script |
| # This is needed to add extra compiler flags to compiler. |
| # See kernel-toolchain/android-kernel-toolchain-* for details |
| # |
| export REAL_CROSS_COMPILE="$CROSS_COMPILE" |
| CROSS_COMPILE=$(dirname "$0")/kernel-toolchain/android-kernel-toolchain- |
| |
| MAKE_FLAGS= |
| if [ "$OPTION_VERBOSE" ]; then |
| MAKE_FLAGS="$MAKE_FLAGS V=1" |
| fi |
| |
| case $CONFIG in |
| defconfig) |
| MAKE_DEFCONFIG=$CONFIG |
| ;; |
| *) |
| MAKE_DEFCONFIG=${CONFIG}_defconfig |
| ;; |
| esac |
| |
| ORG_ARCH=$ARCH |
| case $ARCH in |
| mips64) |
| # MIPS64 Kernel code base is under arch/mips |
| ARCH=mips |
| ;; |
| esac |
| |
| # Do the build |
| # |
| rm -f include/asm && |
| make $MAKE_DEFCONFIG && # configure the kernel |
| make -j$JOBS $MAKE_FLAGS # build it |
| |
| if [ $? != 0 ] ; then |
| echo "Could not build the kernel. Aborting !" |
| exit 1 |
| fi |
| |
| if [ "$OPTION_SAVEDEFCONFIG" = "yes" ]; then |
| case $ARCH in |
| x86_64) |
| DEFCONFIG_ARCH=x86 |
| ;; |
| *) |
| DEFCONFIG_ARCH=$ARCH |
| ;; |
| esac |
| make savedefconfig |
| mv -f defconfig arch/$DEFCONFIG_ARCH/configs/${CONFIG}_defconfig |
| fi |
| |
| # Note: The exact names of the output files are important for the Android build, |
| # do not change the definitions lightly. |
| KERNEL_PREFIX=kernel-$KERNEL_VERSION |
| |
| # Naming conventions for the kernel image files: |
| # |
| # 1) The kernel image is called kernel-qemu, except for 32-bit ARM |
| # where it must be called kernel-qemu-armv7 |
| # |
| # 2) The debug symbol file is called vmlinux-qemu, except for 32-bit |
| # ARM where it must be called vmlinux-qemu-armv7 |
| # |
| OUTPUT_KERNEL=kernel-qemu |
| OUTPUT_VMLINUX=vmlinux-qemu |
| if [ "$CONFIG" = "goldfish_armv7" ]; then |
| OUTPUT_KERNEL=${OUTPUT_KERNEL}-armv7 |
| OUTPUT_VMLINUX=${OUTPUT_VMLINUX}-armv7 |
| fi |
| |
| cp -f vmlinux $OUTPUT/$OUTPUT_VMLINUX |
| if [ ! -z $ZIMAGE ]; then |
| cp -f arch/$ARCH/boot/$ZIMAGE $OUTPUT/$OUTPUT_KERNEL |
| else |
| cp -f vmlinux $OUTPUT/$OUTPUT_KERNEL |
| fi |
| echo "Kernel $CONFIG prebuilt images ($OUTPUT_KERNEL and $OUTPUT_VMLINUX) copied to $OUTPUT successfully !" |
| |
| cp COPYING $OUTPUT/LINUX_KERNEL_COPYING |
| |
| cat > $OUTPUT/README <<EOF |
| This directory contains kernel images to be used with the Android emulator |
| program, for the $ORG_ARCH CPU architecture. It was built with the $PROGNAME |
| script. For more details, read: |
| |
| \$AOSP/external/qemu/docs/ANDROID-KERNEL.TXT |
| |
| EOF |
| |
| exit 0 |
