build_kernel

#!/bin/bash

# SPDX-FileCopyrightText: 2024 Edrick Sinsuan
# SPDX-License-Identifier: Apache-2.0

script_dir=$(dirname $0)
if ! check_file "$script_dir/setup_env"; then
    decho "setup_env must be present in $script_dir!"
    exit_timestamp 1
fi
source $script_dir/setup_env

# Kernel directories
readonly KERNEL_PARENT_DIR=$HOME/kernel
readonly SRC_DIR=$KERNEL_PARENT_DIR
readonly OUT_DIR=$KERNEL_PARENT_DIR/output
readonly TARGET_DIR=$KERNEL_PARENT_DIR/test
readonly SRT_DIR=$KERNEL_PARENT_DIR/scripts
readonly ZIP_DIR=$KERNEL_PARENT_DIR/zip
readonly LOG_DIR=$KERNEL_PARENT_DIR/buildlog
readonly CLANG_DIR=$KERNEL_PARENT_DIR/toolchain/clang
readonly GCC_DIR=$KERNEL_PARENT_DIR/toolchain/gcc

# Default properties
test_build=n
debug=n

log=/dev/null
brnch_ver=$curr_date
ver=1

jn=$(nproc)

# Build x-ft by default
srcn="x-ft"

#
# Defined srcn properties
#

define_x-ft() {
    if [[ $debug == "y" ]]; then
        dc="msm8998_oneplus_debug_android_defconfig"
    else
        dc="msm8998_oneplus_android_defconfig"
    fi
    af="arch/arm64/configs"
    arch="arm64"
    subarch=$arch
    lwimg="Image.gz-dtb"

    clang_path="$CLANG_DIR/clang-r530567/bin"
    gcc_path="${GCC_DIR}64/bin:${GCC_DIR}32/bin"
    cc_path="$clang_path:$cc_path"

    c64="aarch64-linux-gnu-"
    c32="arm-linux-gnueabi-"
    cc="${c64}gcc"

    use_clang=y
    export PATH="/usr/local/bin:$cc_path:$PATH"
}

define_wsl2() {
    dcf="config-wsl-x86"
    af="arch/x86/configs"
    dc="KCONFIG_CONFIG=$af/$dcf"
    arch="x86"
    lwimg="bzImage"

    # WSL directory (windows and linux) for wsl2-kernel
    readonly WSLKDIRW='C:\\Users\\evcsi\\WSL\\'
    readonly WSLKDIRL=$C_USER_DIR/WSL

    use_clang=y
    export PATH="/usr/lib/ccache:$PATH"
}

define_srcn() {
    if [[ $srcn == "x-ft" ]]; then
        define_x-ft
        return 0
    fi

    if [[ $srcn == "wsl2-kernel" ]]; then
        define_wsl2
        return 0
    fi

    return 1
}

#
# Build functions
#

define_log() {
    create_dir "$LOG_DIR"

    if ! check_file "$log"; then
        touch "$LOG_DIR/$kname.log"
    else
        echo "" > $log
    fi

    decho "Build start: $date_full" >> $log
    log="$LOG_DIR/$kname.log"
    {
        border
        echo "Last Commit:"
        echo $(git -C $srcn_dir log -1 --pretty=%B)
        border
    } >> $log
}

define_kname() {
    khash=$(git rev-parse --short HEAD)
    kname="$userhost-$srcn-$src_brnch-$brnch_ver-$ver"
    kname_s="$srcn-$brnch_ver-$ver"
    if [[ $debug == "y" ]]; then
        kname="d-$kname"
        kname_s="d-$kname_s"
    fi
    if [[ $ksu_build == "y" ]]; then
        kname="k-$kname"
        kname_s="k-$kname_s"
    fi
}

define_clang() {
    cc="clang"

    clangmkp=" \
        LLVM=1 \
        LLVM_IAS=1 \
        "
}

define_debug() {
    debugmkp="    \
        CONFIG_DEBUG_SECTION_MISMATCH=y \
        "
}

define_ksu() {
    ksumkp="    \
        KSU_DEFINED=1 \
        "
}

define_env() {
    border
    if [[ $src_brnch != "" ]]; then
        echo "Checking out to branch:"
        git checkout $src_brnch
    else
        echo "Using current branch:"
        src_brnch="$(git rev-parse --abbrev-ref HEAD)"
    fi
    echo $src_brnch
    border

    out=$OUT_DIR/$srcn/$src_brnch
    bti=$out/arch/$arch/boot

    define_kname

    if [[ $force_ver != "y" ]]; then
        while [[ -f $LOG_DIR/$kname.log ]]
            do
            ver="$(($ver + 1))"
            define_kname
        done
    fi

    if [[ $configure == "y" ]]; then
        echo "Configure only, no builds will be made..."
    else
        log=$LOG_DIR/$kname.log
        define_log
    fi

    if [[ $use_clang == "y" ]]; then
        define_clang
    fi

    if [[ $debug == "y" ]]; then
        define_debug
    fi

    if [[ $ksu_build == "y" ]]; then
        define_ksu
    fi

    local compiler="$($cc --version | head -1)"
    decho_log "Compiler being used: $compiler"

    build_str="$srcn release: $src_brnch-$brnch_ver-$ver built using $compiler | \
        Date: $date_full | Hash: $khash"

    mkp=" \
        $clangmkp \
        $debugmkp \
        $ksumkp \
        CC_WRAPPER=ccache \
        ARCH=$arch \
        SUBARCH=$subarch \
        CROSS_COMPILE=$c64 \
        CROSS_COMPILE_ARM32=$c32 \
        LOCALVERSION=-$kname_s \
        O=$out \
        -j$jn \
        "

    if [[ $srcn == "wsl2-kernel" ]]; then
        mkp=" \
            $clangmkp \
            $debugmkp \
            LOCALVERSION=-$kname_s \
            O=$out \
            -j$jn \
            "
    fi

    decho "Make variables: $mkp" >> $log
}

build_func() {
    cd $srcn_dir

    define_env

    if create_dir "$out"; then
        time make_cmd clean
        time make_cmd mrproper 
    fi

    if [[ $configure == "y" ]]; then
        time make_cmd $dc menuconfig
        if [[ $srcn == "wsl2-kernel" ]]; then
            dc=$dcf
        fi
        time make_cmd $dc savedefconfig
        cp -v $out/defconfig $srcn_dir/$af/$dc
        decho "Copied defconfig to $dc"
        exit_timestamp 0
    fi

    time make_cmd $dc

    if [[ $srcn == "wsl2-kernel" ]]; then
        return
    fi

    if [[ $make_only == "y" ]]; then
        decho_log "Done generating .config at $out"
        code $out/.config
        exit_timestamp 0
    fi

    time make_cmd
}

export_img_wsl2() {
    decho "Copying $bti/$lwimg to $C_USER_DIR/WSL"
    cp $bti/$lwimg $WSLKDIRL/$kname_s 

    decho "Updating kernel in .wslconfig"
    sed -i '/kernel=/d' $C_USER_DIR/.wslconfig
    echo "kernel=$WSLKDIRW$kname_s" >> $C_USER_DIR/.wslconfig
    cat $C_USER_DIR/.wslconfig
}

export_img_zip() {
    if ! check_dir "$ZIP_DIR" || ! cd "$ZIP_DIR"; then
        decho_log "There's no zip directory, abort!"
        exit_timestamp 1
    fi

    create_dir $TARGET_DIR

    mv -f $bti/$lwimg $ZIP_DIR
    touch version

    {
        echo "Kernel: $srcn by $userhost"
        echo "Build code: $src_brnch-$brnch_ver-$ver"
        echo "Date: $date_full"
        echo "Hash: $khash"
    } >> version

    zip_image $TARGET_DIR/$kname
    create_dir $SHARED_ROOT_DIR/builds
    cp $TARGET_DIR/$kname.zip $SHARED_ROOT_DIR/builds/

    rm -f $lwimg
    rm -f version
}

export_img() {
    if [[ $srcn == "wsl2-kernel" ]]; then
        export_img_wsl2
        return 0
    fi

    # Set kernel zipping as default
    export_img_zip
    return 0
}

main_func() {
    if ! check_dir $srcn_dir; then
        decho_log "Abort, source directory must exist."
        exit_timestamp 1
    fi

    build_func

    if check_file "$bti/$lwimg"; then
        export_img
        decho "Log file: $log"
    elif [[ $log != "/dev/null" ]]; then
        decho "$log"
        cat $log
    fi

    decho "$build_str"
    create_dir $SHARED_ROOT_DIR/logs
    cp $log $SHARED_ROOT_DIR/logs/
}

param_func() {
    while [[ $# -gt 0 ]]
        do
        key="$1"

        case $key in
            -s|--source)
                if check_valid "$2"; then
                    srcn="$2"
                    shift
                fi
            ;;
            -b|--branch)
                if check_valid "$2"; then
                    src_brnch="$2"
                    shift
                fi
            ;;
            -v|--version)
                if check_valid "$2"; then
                    force_ver=y
                    ver="$2"
                    shift
                fi
            ;;
            -cl|--clang)
                use_clang=y
            ;;
            -a|--all)
                build_all=y
            ;;
            -c|--configure)
                configure=y
            ;;
            -t|--test)
                test_build=y
            ;;
            -d|--debug)
                debug=y
            ;;
            -mo|--make-only)
                make_only=y
            ;;
            -k|--ksu)
                ksu_build=y
            ;;
        esac
        shift
    done
}

param_main_func() {
    param_func "$@"
    main_func
}

#
# Build start
#

decho "Executing build script..."

param_func "$@"

if ! define_srcn; then
    decho "srcn=$srcn is unknown, please define in $0!"
    exit_timestamp 1
fi

srcn_dir=$SRC_DIR/$srcn

if [[ $srcn == "x-ft" ]] && [[ $build_all == "y" ]]; then
    if [[ $test_build == "y" ]]; then
        param_main_func -b testing
        param_main_func -b testing -k
    else
        param_main_func -b stable
        param_main_func -b stable -k
    fi

    exit_timestamp 0
fi

main_func

exit_timestamp 0