build-kernel.yml

name: Build Kernel
on:
  workflow_dispatch:
    inputs:
      select_device:
        description: 'Select device:'
        required: true
        type: choice
        options:
        - 'lancelot'
        - 'merlin'
      build_ksun:
        description: 'Build KernelSU-Next A13+'
        required: true
        default: true
        type: boolean
      build_ksun_old:
        description: 'Build KernelSU-Next A11+'
        required: true
        default: true
        type: boolean
      build_suki:
        description: 'Build SukiSU A13+'
        required: true
        default: true
        type: boolean
      build_suki_old:
        description: 'Build SukiSU A11+'
        required: true
        default: true
        type: boolean

jobs:
  generate-build-matrix:
    name: What to build?
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set.outputs.matrix }}
    steps:
      - id: set
        name: Generate build matrix
        run: |
          targets=()
          if [[ "${{ github.event.inputs.build_ksun }}" == "true" ]]; then targets+=("ksun"); fi
          if [[ "${{ github.event.inputs.build_ksun_old }}" == "true" ]]; then targets+=("ksun-old"); fi
          if [[ "${{ github.event.inputs.build_suki }}" == "true" ]]; then targets+=("suki"); fi
          if [[ "${{ github.event.inputs.build_suki_old }}" == "true" ]]; then targets+=("suki-old"); fi
          json=$(printf '%s\n' "${targets[@]}" | jq -R . | jq -s '{target: .}')
          echo "matrix<<EOF" >> $GITHUB_OUTPUT
          echo "$json" >> $GITHUB_OUTPUT
          echo "EOF" >> $GITHUB_OUTPUT

  build:
    needs: generate-build-matrix
    runs-on: ubuntu-24.04
    env:
      DEVICE: ${{ github.event.inputs.select_device }}
      CCACHE_COMPILERCHECK: "%compiler% -dumpmachine; %compiler% -dumpversion"
      CCACHE_NOHASHDIR: "true"
      CCACHE_HARDLINK: "true"
    strategy:
      fail-fast: false
      matrix: ${{ fromJson(needs.generate-build-matrix.outputs.matrix) }}
    steps:
    - uses: actions/checkout@v4

    - name: Maximize build space
      if: env.REMOVE_UNUSED_PACKAGES == 'true'
      uses: easimon/maximize-build-space@master
      with:
        root-reserve-mb: 8192
        temp-reserve-mb: 2048
        remove-dotnet: 'true'
        remove-android: 'true'
        remove-haskell: 'true'
        remove-codeql: 'true'

    - name: Prepare environment
      run: |
        TARGET_CONFIG_FILENAME="${{ matrix.target }}"
        TARGET_CONFIG_FILENAME="${TARGET_CONFIG_FILENAME/-old/}"
        TARGET_CONFIG_FILENAME_SUFFIX=$TARGET_CONFIG_FILENAME
        grep -v -E "^#|^\n" config-${TARGET_CONFIG_FILENAME_SUFFIX}.env | sed 's/ #.*//; s/#.*//' >> $GITHUB_ENV
        if [[ "${{ matrix.target }}" == *"-old" ]]; then
            echo "ANDROID_TAG=[A11+]" >> $GITHUB_ENV
        else
            echo "ANDROID_TAG=[A13+]" >> $GITHUB_ENV
        fi

    - name: Check if old Android build
      if: contains(matrix.target, 'old')
      run: |
        echo "OLD_ANDROID_SUPPORT=true" >> $GITHUB_ENV

    - name: Set swap to 10G
      uses: pierotofy/set-swap-space@master
      with:
        swap-size-gb: 10

    - name: Setup kernel build environment
      run: |
        echo "BUILD_TIME=$(TZ=Asia/Dhaka date "+%Y%m%d%H%M")" >> $GITHUB_ENV
        sudo apt-get update
        sudo apt-get install -y lld bc bison build-essential ccache curl flex g++-multilib gcc-multilib git git-lfs gnupg gperf imagemagick lib32ncurses-dev lib32readline-dev lib32z1-dev liblz4-tool libncurses6 libncurses-dev libsdl1.2-dev libssl-dev libwxgtk3.2-dev libxml2 libxml2-utils lzop pngcrush rsync schedtool squashfs-tools xsltproc zip zlib1g-dev
        mkdir -p $GITHUB_WORKSPACE/kernel_workspace

    - name: Install python2
      if: env.ENABLE_PYTHON2 == 'true'
      run: |
        mkdir -p ~/python2-jammy && cd ~/python2-jammy
        wget http://security.ubuntu.com/ubuntu/pool/universe/p/python2.7/python2.7_2.7.18-13ubuntu1.5_amd64.deb
        wget http://security.ubuntu.com/ubuntu/pool/universe/p/python2.7/libpython2.7-stdlib_2.7.18-13ubuntu1.5_amd64.deb
        wget http://security.ubuntu.com/ubuntu/pool/universe/p/python2.7/python2.7-minimal_2.7.18-13ubuntu1.5_amd64.deb
        wget http://security.ubuntu.com/ubuntu/pool/universe/p/python2.7/libpython2.7-minimal_2.7.18-13ubuntu1.5_amd64.deb
        sudo apt install libnsl2 -y
        sudo dpkg -i libpython2.7-minimal_*.deb
        sudo dpkg -i python2.7-minimal_*.deb
        sudo dpkg -i libpython2.7-stdlib_*.deb
        sudo dpkg -i python2.7_*.deb
        sudo apt --fix-broken install
        sudo ln -s /usr/bin/python2.7 /usr/local/bin/python2
        rm -rf ~/python2-jammy

    - name: Download Clang
      if: env.USE_CLANG == 'true'
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace
        wget -nv -O clang.tar.xz https://github.com/llvm/llvm-project/releases/download/llvmorg-17.0.6/clang+llvm-17.0.6-aarch64-linux-gnu.tar.xz
        mkdir clang
        tar -C clang/ -Jxvf clang.tar.xz --strip-components=1
        rm clang.tar.xz
        echo "Listing Clang binaries:"
        ls -l clang/bin
        for bin in clang ld.lld llvm-as llvm-ar llvm-nm llvm-objcopy llvm-objdump llvm-readelf llvm-strip; do
          test -f clang/bin/$bin && echo "Found: $bin" || echo "Missing: $bin"
        done

    - name: Download GCC
      if: env.USE_GCC == 'true'
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace
        if [ ${{ env.USE_GCC_64 }} = true ]; then
            wget -nv -O gcc-64.tar.xz ${{ env.GCC_64_SOURCE }}
            mkdir gcc-64
            tar -C gcc-64/ -Jxvf gcc-64.tar.xz --strip-components=1
            rm gcc-64.tar.xz
            echo "Listing GCC 64-bit binaries:"
            ls -l gcc-64/bin
            test -f gcc-64/bin/aarch64-linux-gnu-gcc && echo "Found: aarch64-linux-gnu-gcc" || echo "Missing: aarch64-linux-gnu-gcc"
        fi
        if [ ${{ env.USE_GCC_32 }} = true ]; then
            wget -nv -O gcc-32.tar.xz ${{ env.GCC_32_SOURCE }}
            mkdir gcc-32
            tar -C gcc-32/ -Jxvf gcc-32.tar.xz --strip-components=1
            rm gcc-32.tar.xz
            echo "Listing GCC 32-bit binaries:"
            ls -l gcc-32/bin
            test -f gcc-32/bin/arm-linux-gnueabi-gcc && echo "Found: arm-linux-gnueabi-gcc" || echo "Missing: arm-linux-gnueabi-gcc"
        fi

    - name: Download mkbootimg tools
      if: env.BUILD_BOOT_IMG == 'true'
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace
        git clone https://android.googlesource.com/platform/system/tools/mkbootimg tools -b master-kernel-build-2022 --depth=1

    - name: Download kernel source
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace
        git clone --recursive ${{ env.KERNEL_SOURCE }} -b ${{ env.KERNEL_SOURCE_BRANCH }} android-kernel --depth=1

    - name: Apply Kconfig patch
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace/android-kernel
        if [ -f $GITHUB_WORKSPACE/patches/fix_kconfig.patch ]; then
            git apply $GITHUB_WORKSPACE/patches/fix_kconfig.patch
        else
            echo "Kconfig patch not found, skipping"
        fi

    - name: Disable strong stack protector
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace/android-kernel
        echo "Listing scripts directory:"
        ls -l scripts
        echo "Checking scripts/config existence:"
        ls -l scripts/config
        make ARCH=arm64 ${DEVICE}_defconfig
        ./scripts/config --disable CONFIG_CC_STACKPROTECTOR_STRONG
        echo "Verifying CONFIG_CC_STACKPROTECTOR_STRONG is disabled:"
        grep CONFIG_CC_STACKPROTECTOR_STRONG out/.config || echo "CONFIG_CC_STACKPROTECTOR_STRONG not found"
        make ARCH=arm64 olddefconfig
        echo "Final .config contents for stack protector:"
        grep CONFIG_CC_STACKPROTECTOR out/.config || echo "No stack protector configs found"

    - name: Download source boot image
      if: env.BUILD_BOOT_IMG == 'true'
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace
        wget -nv -O boot-source.img ${{ env.SOURCE_BOOT_IMAGE }}
        if [ -f boot-source.img ]; then
            echo "FORMAT_MKBOOTING=$(echo `tools/unpack_bootimg.py --boot_img=boot-source.img --format mkbootimg`)" >> $GITHUB_ENV
            echo "HAVE_SOURCE_BOOT_IMAGE=true" >> $GITHUB_ENV
        fi

    - name: Setup KernelSU
      if: env.ENABLE_KERNELSU == 'true'
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace/android-kernel
        curl -LSs "$KERNELSU_SETUP_SOURCE" | bash -s ${{ env.KERNELSU_TAG }}
        KSU_VERSION="_$(cd $(echo "$KERNELSU_SETUP_SOURCE" | cut -d/ -f5) || cd KernelSU && expr $(git rev-list --count HEAD) + 10200)"
        echo "UPLOADNAME=-KernelSU-${{ matrix.target }}$KSU_VERSION" >> $GITHUB_ENV
        if [ ${{ env.KSU_REVERT }} = true ]; then
            git apply $GITHUB_WORKSPACE/patches/KSU_REVERT.patch
        fi

    - name: Setup Configuration for kernel
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace/android-kernel
        if [ ${{ env.ENABLE_KERNELSU }} = true ]; then
            if [ ${{ env.KSU_HOOKS_PATCH }} = true ]; then
                git apply $GITHUB_WORKSPACE/patches/KSU_HOOKS_PATCH.patch
                if grep -q "CONFIG_KSU" arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig; then
                    sed -i 's/# CONFIG_KSU is not set/CONFIG_KSU=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                    sed -i 's/CONFIG_KSU=n/CONFIG_KSU=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                else
                    echo "CONFIG_KSU=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                fi
            fi
            if [ ${{ env.ADD_KPROBES_CONFIG }} = true -a ${{ env.KSU_HOOKS_PATCH }} != true ]; then
                echo "CONFIG_MODULES=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                echo "CONFIG_KPROBES=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                echo "CONFIG_HAVE_KPROBES=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                echo "CONFIG_KPROBE_EVENTS=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
            fi
        for config in CONFIG_KSU=y \
                      CONFIG_WITH_KPROBES=n \
                      CONFIG_KSU_SUSFS=y \
                      CONFIG_KSU_SUSFS_SUS_PATH=y \
                      CONFIG_KSU_SUSFS_HAS_MAGIC_MOUNT=y \
                      CONFIG_KSU_SUSFS_SUS_MOUNT=y \
                      CONFIG_KSU_SUSFS_AUTO_ADD_SUS_KSU_DEFAULT_MOUNT=y \
                      CONFIG_KSU_SUSFS_AUTO_ADD_SUS_BIND_MOUNT=y \
                      CONFIG_KSU_SUSFS_SUS_KSTAT=y \
                      CONFIG_KSU_SUSFS_TRY_UMOUNT=y \
                      CONFIG_KSU_SUSFS_AUTO_ADD_TRY_UMOUNT_FOR_BIND_MOUNT=y \
                      CONFIG_KSU_SUSFS_SPOOF_UNAME=y \
                      CONFIG_KSU_SUSFS_ENABLE_LOG=y \
                      CONFIG_KSU_SUSFS_HIDE_KSU_SUSFS_SYMBOLS=y \
                      CONFIG_KSU_SUSFS_SPOOF_PROC_CMDLINE=y \
                      CONFIG_KSU_SUSFS_OPEN_REDIRECT=y \
                      CONFIG_KSU_SUSFS_SUS_SU=n
        do
        echo "$config" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
        done
        fi
        if [ ${{ env.ADD_OVERLAYFS_CONFIG }} = true ]; then
            echo "CONFIG_OVERLAY_FS=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
            echo "CONFIG_OVERLAY_FS_REDIRECT_DIR=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
            echo "CONFIG_OVERLAY_FS_INDEX=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
        fi
        if [ ${{ env.ADD_APATCH_SUPPORT }} = true ]; then
                sed -i 's/# CONFIG_DEBUG_KERNEL is not set/CONFIG_DEBUG_KERNEL=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                sed -i 's/CONFIG_DEBUG_KERNEL=n/CONFIG_DEBUG_KERNEL=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                echo "CONFIG_DEBUG_KERNEL=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                sed -i 's/# CONFIG_KALLSYMS is not set/CONFIG_KALLSYMS=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                sed -i 's/CONFIG_KALLSYMS=n/CONFIG_KALLSYMS=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                echo "CONFIG_KALLSYMS=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                sed -i 's/# CONFIG_KALLSYMS_ALL is not set/CONFIG_KALLSYMS_ALL=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                sed -i 's/CONFIG_KALLSYMS_ALL=n/CONFIG_KALLSYMS_ALL=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                echo "CONFIG_KALLSYMS_ALL=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                sed -i 's/# CONFIG_KALLSYMS_BASE_RELATIVE is not set/CONFIG_KALLSYMS_BASE_RELATIVE=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                sed -i 's/CONFIG_KALLSYMS_BASE_RELATIVE=n/CONFIG_KALLSYMS_BASE_RELATIVE=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                echo "CONFIG_KALLSYMS_BASE_RELATIVE=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                if [ ${{ env.FIX_APATCH_OPENELA }} = true ]; then
                    git apply $GITHUB_WORKSPACE/patches/FIX_APATCH_OPENELA.patch || {
                    git apply $GITHUB_WORKSPACE/patches/REVERT_ADD_GET_CRED_RCU.patch
                    git apply $GITHUB_WORKSPACE/patches/FIX_APATCH_OPENELA.patch
                    }
                fi
        fi
        if [ ${{ env.DISABLE_LTO }} = true ]; then
            sed -i 's/CONFIG_LTO=y/CONFIG_LTO=n/' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
            sed -i 's/CONFIG_LTO_CLANG=y/CONFIG_LTO_CLANG=n/' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
            sed -i 's/CONFIG_THINLTO=y/CONFIG_THINLTO=n/' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
            echo "CONFIG_LTO_NONE=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
        fi
        if [ ${{ env.DISABLE_CC_WERROR }} = true ]; then
            echo "CONFIG_CC_WERROR=n" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
        fi
        if [ ${{ env.OLD_ANDROID_SUPPORT }} = true ]; then
            git apply $GITHUB_WORKSPACE/patches/OLD_ANDROID_SUPPORT.patch
            if grep -q "CONFIG_MMC_CRYPTO_LEGACY" arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig; then
                sed -i 's/# CONFIG_MMC_CRYPTO_LEGACY is not set/CONFIG_MMC_CRYPTO_LEGACY=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
                sed -i 's/CONFIG_MMC_CRYPTO_LEGACY=n/CONFIG_MMC_CRYPTO_LEGACY=y/g' arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
            else
                echo "CONFIG_MMC_CRYPTO_LEGACY=y" >> arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig
            fi
        fi
        if [ ${{ env.FIX_WIFI_SPEED }} = true ]; then
            rm -rf drivers/misc/mediatek/connectivity
            cd $GITHUB_WORKSPACE/kernel_workspace/android-kernel/drivers/misc/mediatek
            git clone https://github.com/Jbub5/connectivity.git --depth=1
            cd $GITHUB_WORKSPACE/kernel_workspace/android-kernel
        fi

    - name: Setup ccache
      if: env.ENABLE_CCACHE == 'true'
      uses: hendrikmuhs/ccache-action@v1.2
      with:
        key: build-kernel-${{ env.DEVICE }}${{ env.LOCALVERSION }}${{ env.UPLOADNAME }}
        max-size: 2G

    - name: Build kernel
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace/android-kernel
        if [ ${{ env.USE_GCC }} = true ]; then
            export PATH=$GITHUB_WORKSPACE/kernel_workspace/gcc-64/bin:$GITHUB_WORKSPACE/kernel_workspace/gcc-32/bin:$PATH
            echo "Using GCC toolchain"
            export CC=aarch64-linux-gnu-gcc
            export CROSS_COMPILE=aarch64-linux-gnu-
            export CROSS_COMPILE_ARM32=arm-linux-gnueabi-
            export CROSS_COMPILE_COMPAT=arm-linux-gnueabi-
        elif [ ${{ env.USE_CLANG }} = true ]; then
            export PATH=$GITHUB_WORKSPACE/kernel_workspace/clang/bin:$PATH
            echo "Using Clang toolchain"
            export CC=clang
            export CROSS_COMPILE=aarch64-linux-gnu-
            export CROSS_COMPILE_ARM32=arm-linux-gnueabi-
            export CROSS_COMPILE_COMPAT=arm-linux-gnueabi-
        else
            echo "Toolchain not selected"
            exit 1
        fi
        echo "Checking for required toolchain binaries:"
        for bin in $CC ld.lld llvm-as llvm-ar llvm-nm llvm-objcopy llvm-objdump llvm-readelf llvm-strip aarch64-linux-gnu-gcc arm-linux-gnueabi-gcc; do
          which $bin || echo "Missing: $bin"
        done
        export KBUILD_BUILD_HOST=Github-Action
        export KBUILD_BUILD_USER=$(echo ${{ github.actor }} | tr A-Z a-z)
        if [ -n "${{ env.KSU_EXPECTED_SIZE }}" ] && [ -n "${{ env.KSU_EXPECTED_HASH }}" ]; then
          export KSU_EXPECTED_SIZE=${{ env.KSU_EXPECTED_SIZE }}
          export KSU_EXPECTED_HASH=${{ env.KSU_EXPECTED_HASH }}
        fi
        echo "test EXTRA_CMDS="
        echo $EXTRA_CMDS
        make V=1 -j$(nproc --all) CC=$CC O=out ARCH=${{ env.KERNEL_ARCH }} CROSS_COMPILE=$CROSS_COMPILE CROSS_COMPILE_ARM32=$CROSS_COMPILE_ARM32 CROSS_COMPILE_COMPAT=$CROSS_COMPILE_COMPAT CONFIG_NO_ERROR_ON_MISMATCH=y TARGET_BUILD_VARIANT=user ${DEVICE}_defconfig
        if [ ${{ env.ENABLE_CCACHE }} = true ]; then
            make -j$(nproc --all) CC="ccache $CC" O=out ARCH=${{ env.KERNEL_ARCH }} CROSS_COMPILE=$CROSS_COMPILE CROSS_COMPILE_ARM32=$CROSS_COMPILE_ARM32 CROSS_COMPILE_COMPAT=$CROSS_COMPILE_COMPAT CONFIG_NO_ERROR_ON_MISMATCH=y TARGET_BUILD_VARIANT=user
        else
            make -j$(nproc --all) CC=$CC O=out ARCH=${{ env.KERNEL_ARCH }} CROSS_COMPILE=$CROSS_COMPILE CROSS_COMPILE_ARM32=$CROSS_COMPILE_ARM32 CROSS_COMPILE_COMPAT=$CROSS_COMPILE_COMPAT CONFIG_NO_ERROR_ON_MISMATCH=y TARGET_BUILD_VARIANT=user
        fi

    - name: Check a kernel output files
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace
        if [ -f android-kernel/out/arch/${{ env.KERNEL_ARCH }}/boot/${{ env.KERNEL_IMAGE_NAME }} ]; then
            echo "CHECK_FILE_IS_OK=true" >> $GITHUB_ENV
        else
            echo "Kernel output file is empty"
            exit 1
        fi
        if [ ${{ env.NEED_DTBO }} = true ]; then
            if [ -f android-kernel/out/arch/${{ env.KERNEL_ARCH }}/boot/dtbo.img ]; then
                echo "CHECK_DTBO_IS_OK=true" >> $GITHUB_ENV
            else
                echo "DTBO image is empty"
                exit 1
            fi
        fi

    - name: Patch SukiSU Ultra KPM
      if: env.CHECK_FILE_IS_OK == 'true' && env.KPM_SUPPORT == 'true'
      run: |
        OUT_BOOT=$GITHUB_WORKSPACE/kernel_workspace/android-kernel/out/arch/${{ env.KERNEL_ARCH }}/boot
        mkdir $GITHUB_WORKSPACE/kernel_workspace/SukiSU-Patch
        cd $GITHUB_WORKSPACE/kernel_workspace/SukiSU-Patch
        wget ${{ env.KPM_URL }}
        cp $OUT_BOOT/Image ./
        cp $OUT_BOOT/dts/mediatek/mt6768.dtb ./
        chmod +x patch_linux
        ./patch_linux
        mv -f oImage Image
        gzip -k Image
        cat Image.gz *.dtb > Image.gz-dtb
        mv -f Image.gz-dtb $OUT_BOOT/${{ env.KERNEL_IMAGE_NAME }}

    - name: Create flashable Anykernel3 zip
      if: env.CHECK_FILE_IS_OK == 'true' && env.USE_ANYKERNEL3 == 'true'
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace
        if [[ ${{ env.ANYKERNEL3_SOURCE }} == *'.tar.gz' ]]; then
            wget -nv -O AnyKernel3.tar.gz ${{ env.ANYKERNEL3_SOURCE }}
            mkdir AnyKernel3
            tar -C AnyKernel3/ -zxvf AnyKernel3.tar.gz
            rm AnyKernel3.tar.gz
        elif [[ ${{ env.ANYKERNEL3_SOURCE }} == *'.tar.xz' ]]; then
            wget -nv -O AnyKernel3.tar.xz ${{ env.ANYKERNEL3_SOURCE }}
            mkdir AnyKernel3
            tar -C AnyKernel3/ -Jxvf AnyKernel3.tar.xz
            rm AnyKernel3.tar.xz
        elif [[ ${{ env.ANYKERNEL3_SOURCE }} == *'.tar.zst' ]]; then
            wget -nv -O AnyKernel3.tar.zst ${{ env.ANYKERNEL3_SOURCE }}
            mkdir AnyKernel3
            tar -C AnyKernel3/ -I zstd -xf AnyKernel3.tar.zst
            rm AnyKernel3.tar.zst
        elif [[ ${{ env.ANYKERNEL3_SOURCE }} == *'.git' ]]; then
            git clone ${{ env.ANYKERNEL3_SOURCE }} -b ${{ env.ANYKERNEL3_BRANCH }} --depth=1 AnyKernel3
        else
            wget -nv -O AnyKernel3.zip ${{ env.ANYKERNEL3_SOURCE }}
            mkdir AnyKernel3
            unzip AnyKernel3.zip -d AnyKernel3/
            rm AnyKernel3.zip
        fi
        cp android-kernel/out/arch/${{ env.KERNEL_ARCH }}/boot/${{ env.KERNEL_IMAGE_NAME }} AnyKernel3/
        if [ ${{ env.CHECK_DTBO_IS_OK }} = true ]; then
            cp android-kernel/out/arch/${{ env.KERNEL_ARCH }}/boot/dtbo.img AnyKernel3/
        fi
        rm -rf AnyKernel3/.git* AnyKernel3/README.md

    - name: Make boot image
      if: env.HAVE_SOURCE_BOOT_IMAGE == 'true' && env.CHECK_FILE_IS_OK == 'true'
      run: |
        cd $GITHUB_WORKSPACE/kernel_workspace
        tools/unpack_bootimg.py --boot_img boot-source.img
        cp android-kernel/out/arch/${{ env.KERNEL_ARCH }}/boot/${{ env.KERNEL_IMAGE_NAME }} out/kernel
        tools/mkbootimg.py ${{ env.FORMAT_MKBOOTING }} -o boot.img
        if [ -f boot.img ]; then
            echo "MAKE_BOOT_IMAGE_IS_OK=true" >> $GITHUB_ENV
        else
            echo "Boot image is empty"
            exit 1
        fi

    - name: Export kernel name from defconfig
      run: |
        DEFCONFIG_FILE="kernel_workspace/android-kernel/arch/${{ env.KERNEL_ARCH }}/configs/${DEVICE}_defconfig"
        RAW_LOCALVERSION=$(grep -oP 'CONFIG_LOCALVERSION="\K[^"]+' "$DEFCONFIG_FILE")
        KERNEL_NAME=$(echo "$RAW_LOCALVERSION" | sed 's/^-//')
        [ -z "$KERNEL_NAME" ] && KERNEL_NAME="CustomKernel"
        echo "KERNEL_LOCALVERSION=${KERNEL_NAME}" >> $GITHUB_ENV

    - name: Upload AnyKernel3
      if: env.CHECK_FILE_IS_OK == 'true'
      uses: actions/upload-artifact@v4
      with:
        name: ${{ env.ANDROID_TAG }}${{ env.KERNEL_LOCALVERSION }}-${{ env.DEVICE }}-${{ env.BUILD_TIME }}
        path: kernel_workspace/AnyKernel3/*

    - name: Upload Kernel Image
      if: env.CHECK_FILE_IS_OK == 'true'
      uses: actions/upload-artifact@v4
      with:        
        name: ${{ env.KERNEL_IMAGE_NAME }}${{ env.LOCALVERSION }}${{ env.UPLOADNAME }}-${{ env.DEVICE }}-${{ env.BUILD_TIME }}
        path: kernel_workspace/android-kernel/out/arch/${{ env.KERNEL_ARCH }}/boot/${{ env.KERNEL_IMAGE_NAME }}

    - name: Upload DTBO image
      if: env.CHECK_DTBO_IS_OK == 'true'
      uses: actions/upload-artifact@v4
      with:
        name: dtbo-${{ env.DEVICE }}-${{ env.BUILD_TIME }}
        path: kernel_workspace/android-kernel/out/arch/${{ env.KERNEL_ARCH }}/boot/dtbo.img

    - name: Upload boot image
      if: env.MAKE_BOOT_IMAGE_IS_OK == 'true'
      uses: actions/upload-artifact@v4
      with:
        name: boot${{ env.LOCALVERSION }}${{ env.UPLOADNAME }}-${{ env.DEVICE }}-${{ env.BUILD_TIME }}
        path: kernel_workspace/boot.img