GKI_KernelSU_SUSFS/.github/workflows/build.yml

name: Kernel Build Process
permissions:
  contents: write
  actions: write 

on:
  workflow_call:
    inputs:
      android_version:
        required: true
        type: string
      kernel_version:
        required: true
        type: string
      sub_level:
        required: true
        type: string
      os_patch_level:
        required: true
        type: string
      revision:
        required: false
        type: string

jobs:
  build-gki:
    runs-on: ubuntu-latest
    timeout-minutes: 120

    steps:
      # # - name: Maximize Build Space
        # uses: AdityaGarg8/remove-unwanted-software@v5
        # with:
          # remove-dotnet: 'true'          # Frees ~2 GB
          # remove-android: 'true'         # Frees ~9 GB
          # remove-haskell: 'true'         # Frees ~5.2 GB
          # remove-codeql: 'true'          # Frees ~5.4 GB
          # remove-docker-images: 'true'   # Frees ~3.2 GB
          # remove-large-packages: 'true'  # Frees ~3.1 GB
          # remove-swapfile: 'true'        # Frees ~4 GB
          # remove-cached-tools: 'false'   # Avoid unless confirmed safe
          # verbose: 'true'                # Enable detailed logging
          
      - name: Set CONFIG Environment Variable
        run: |
          # Set CONFIG dynamically based on inputs values
          CONFIG="${{ inputs.android_version }}-${{ inputs.kernel_version }}-${{ inputs.sub_level }}"

          # Set CONFIG as an environment variable for future steps
          echo "CONFIG=$CONFIG" >> $GITHUB_ENV



      - name: Setup Build Environment
        run: |
          sudo apt update && sudo apt install -y libelf-dev libssl-dev build-essential
          
          AOSP_MIRROR=https://android.googlesource.com
          BRANCH=main-kernel-build-2024
          git clone $AOSP_MIRROR/kernel/prebuilts/build-tools -b $BRANCH --depth 1 kernel-build-tools &
          git clone $AOSP_MIRROR/platform/system/tools/mkbootimg -b $BRANCH --depth 1 mkbootimg &
          wait
          
          echo "AVBTOOL=$GITHUB_WORKSPACE/kernel-build-tools/linux-x86/bin/avbtool" >> $GITHUB_ENV
          echo "MKBOOTIMG=$GITHUB_WORKSPACE/mkbootimg/mkbootimg.py" >> $GITHUB_ENV
          echo "UNPACK_BOOTIMG=$GITHUB_WORKSPACE/mkbootimg/unpack_bootimg.py" >> $GITHUB_ENV
          echo "BOOT_SIGN_KEY_PATH=$GITHUB_WORKSPACE/kernel-build-tools/linux-x86/share/avb/testkey_rsa2048.pem" >> $GITHUB_ENV
          
          mkdir -p ./git-repo
          curl https://storage.googleapis.com/git-repo-downloads/repo > ./git-repo/repo
          chmod a+rx ./git-repo/repo
          echo "REPO=$GITHUB_WORKSPACE/./git-repo/repo" >> $GITHUB_ENV

      - name: Clone AnyKernel3 and Other Dependencies
        run: |
          ANYKERNEL_BRANCH="gki-2.0"
          SUSFS_BRANCH="gki-${{ inputs.android_version }}-${{ inputs.kernel_version }}"
          
          git clone https://github.com/WildKernels/AnyKernel3.git -b "$ANYKERNEL_BRANCH"
          git clone https://gitlab.com/simonpunk/susfs4ksu.git -b "$SUSFS_BRANCH"
          git clone https://github.com/WildKernels/kernel_patches.git

      - name: Initialize and Sync Kernel Source
        run: |
          mkdir -p "$CONFIG"
          cd "$CONFIG"
          
          FORMATTED_BRANCH="${{ inputs.android_version }}-${{ inputs.kernel_version }}-${{ inputs.os_patch_level }}"
          
          $REPO init --depth=1 --u https://android.googlesource.com/kernel/manifest -b common-${FORMATTED_BRANCH} --repo-rev=v2.16
          
          REMOTE_BRANCH=$(git ls-remote https://android.googlesource.com/kernel/common ${FORMATTED_BRANCH})
          DEFAULT_MANIFEST_PATH=.repo/manifests/default.xml
          if grep -q deprecated <<< $REMOTE_BRANCH; then
            sed -i "s/\"${FORMATTED_BRANCH}\"/\"deprecated\/${FORMATTED_BRANCH}\"/g" $DEFAULT_MANIFEST_PATH
          fi
          
          $REPO --trace sync -c -j$(nproc --all) --no-tags --fail-fast

      - name: Extract Actual Sublevel for LTS Builds
        if: inputs.sub_level == 'X'
        run: |
          cd "$CONFIG/common"
          
          if [ -f "Makefile" ]; then
            ACTUAL_SUBLEVEL=$(grep '^SUBLEVEL = ' Makefile | awk '{print $3}')
            
            if [ -n "$ACTUAL_SUBLEVEL" ]; then
              OLD_CONFIG="$CONFIG"
              NEW_CONFIG="${{ inputs.android_version }}-${{ inputs.kernel_version }}-$ACTUAL_SUBLEVEL"
              
              echo "CONFIG=$NEW_CONFIG" >> $GITHUB_ENV
              echo "ACTUAL_SUBLEVEL=$ACTUAL_SUBLEVEL" >> $GITHUB_ENV
              
              cd ../..
              if [ -d "$OLD_CONFIG" ]; then
                mv "$OLD_CONFIG" "$NEW_CONFIG"
              fi
            fi
          fi

      - name: Apply glibc 2.38 Compatibility Fix
        if: inputs.android_version == 'android14' && inputs.kernel_version == '6.1'
        run: |
          if [ ! -e build/build.sh ]; then 
            GLIBC_VERSION=$(ldd --version 2>/dev/null | head -n 1 | awk '{print $NF}') 
            if [ "$(printf '%s\n' "2.38" "$GLIBC_VERSION" | sort -V | head -n1)" = "2.38" ]; then 
              cd $CONFIG/common/ && sed -i '/\$(Q)\$(MAKE) -C \$(SUBCMD_SRC) OUTPUT=\$(abspath \$(dir \$@))\/ \$(abspath \$@)/s//$(Q)$(MAKE) -C $(SUBCMD_SRC) EXTRA_CFLAGS="$(CFLAGS)" OUTPUT=$(abspath $(dir $@))\/ $(abspath $@)/' tools/bpf/resolve_btfids/Makefile 2>/dev/null || true
            fi 
          fi

      - name: Fix Less Then 6.6.50 Builds
        if: inputs.android_version == 'android15' && inputs.kernel_version == '6.6'
        run: |
          cd "$CONFIG/common"
          if ! grep -qxF '#include <trace/hooks/fs.h>' ./fs/namespace.c; then
              sed -i '/#include <trace\/hooks\/blk.h>/a #include <trace\/hooks\/fs.h>' ./fs/namespace.c
          fi

      - name: Apply ptrace patch for older kernels
        if: fromJSON(inputs.kernel_version) < 5.16
        run: |
          cd "$CONFIG/common"
          patch -p1 -F 3 < "../../kernel_patches/gki_ptrace.patch"

      - name: Add KernelSU
        run: |
          cd "$CONFIG"
          curl -LSs "https://raw.githubusercontent.com/WildKernels/Wild_KSU/wild/kernel/setup.sh" | bash -s wild
          
      - name: Apply SUSFS Patches for KernelSU Variants
        run: |
          cd "$CONFIG"
          
          # Apply core SUSFS patches
          cp ../susfs4ksu/kernel_patches/50_add_susfs_in_gki-${{ inputs.android_version }}-${{ inputs.kernel_version }}.patch ./common/
          cd common
          patch -p1 --forward < 50_add_susfs_in_gki-${{ inputs.android_version }}-${{ inputs.kernel_version }}.patch
          cd ..
          cp ../susfs4ksu/kernel_patches/fs/* ./common/fs/
          cp ../susfs4ksu/kernel_patches/include/linux/* ./common/include/linux/
          
          # Apply KSU integration patches
          cd ./Wild_KSU
          cp ../../susfs4ksu/kernel_patches/KernelSU/10_enable_susfs_for_ksu.patch ./
          patch -p1 --forward < 10_enable_susfs_for_ksu.patch || true
          
          # Apply compatibility fixes
          cp ../../kernel_patches/wild/susfs_fix_patches/v1.5.9/fix_core_hook.c.patch ./
          patch -p1 --forward --fuzz=3 < fix_core_hook.c.patch
          
          cp ../../kernel_patches/wild/susfs_fix_patches/v1.5.9/fix_rules.c.patch ./
          patch -p1 --forward < fix_rules.c.patch

          cp ../../kernel_patches/wild/susfs_fix_patches/v1.5.9/fix_sucompat.c.patch ./
          patch -p1 --forward < fix_sucompat.c.patch

          cp ../../kernel_patches/wild/susfs_fix_patches/v1.5.9/fix_kernel_compat.c.patch ./
          patch -p1 --forward < fix_kernel_compat.c.patch

      - name: Getting KernelSU Version
        run: |
          cd "$CONFIG/Wild_KSU/kernel"
          BASE_VERSION=10200
          COMMIT_COUNT=$(/usr/bin/git rev-list --count HEAD)
          KSU_VERSION=$(expr $COMMIT_COUNT "+" $BASE_VERSION)
          echo "KSUVER=$KSU_VERSION" >> $GITHUB_ENV
          
      - name: Apply Hooks Patches
        run: |
          cd "$CONFIG/common"
          cp ../../kernel_patches/wild/hooks/scope_min_manual_hooks_v1.4.patch ./
          patch -p1 --forward -F 3 < scope_min_manual_hooks_v1.4.patch

      - name: Apply Hide Stuff Patches
        run: |
          cd "$CONFIG/common"
          cp ../../kernel_patches/69_hide_stuff.patch ./
          patch -p1 --forward -F 3 < 69_hide_stuff.patch

      - name: Fix WiFi and Bluetooth on Samsung 6.6 GKI devices
        if: ${{ ( inputs.kernel_version == '6.6' ) }}
        run: |
          SYMBOL_LIST=$CONFIG/common/android/abi_gki_aarch64_galaxy
          echo "kdp_set_cred_non_rcu" >> $SYMBOL_LIST
          echo "kdp_usecount_dec_and_test" >> $SYMBOL_LIST
          echo "kdp_usecount_inc" >> $SYMBOL_LIST
          
          cd $CONFIG/common
          PATCH="../../kernel_patches/samsung/min_kdp/add-min_kdp-symbols.patch"
          if patch -p1 --dry-run < $PATCH; then
            patch -p1 --no-backup-if-mismatch < $PATCH
          fi
          
          cd drivers
          cp "../../../kernel_patches/samsung/min_kdp/min_kdp.c" min_kdp.c
          echo "obj-y += min_kdp.o" >> Makefile

      - name: Apply Kernel Configuration
        run: |
          cd "$CONFIG"
          
          defconfig="./common/arch/arm64/configs/gki_defconfig"
          
          echo "Applying kernel configurations..."
          
          # KernelSU Core Configuration
          cat >> "$defconfig" << 'EOF'
          # === KernelSU Configuration ===
          CONFIG_KSU=y
          CONFIG_KSU_KPROBES_HOOK=n

          # Mountify Support
          CONFIG_TMPFS_XATTR=y
          CONFIG_TMPFS_POSIX_ACL=y

          # === Networking Configuration ===
          # Netfilter TTL/HL support
          CONFIG_IP_NF_TARGET_TTL=y
          CONFIG_IP6_NF_TARGET_HL=y
          CONFIG_IP6_NF_MATCH_HL=y

          # BBR TCP Congestion Control
          CONFIG_TCP_CONG_ADVANCED=y
          CONFIG_TCP_CONG_BBR=y
          CONFIG_NET_SCH_FQ=y
          CONFIG_TCP_CONG_BIC=n
          CONFIG_TCP_CONG_WESTWOOD=n
          CONFIG_TCP_CONG_HTCP=n

          # IPSet support
          CONFIG_IP_SET=y
          CONFIG_IP_SET_MAX=256
          CONFIG_IP_SET_BITMAP_IP=y
          CONFIG_IP_SET_BITMAP_IPMAC=y
          CONFIG_IP_SET_BITMAP_PORT=y
          CONFIG_IP_SET_HASH_IP=y
          CONFIG_IP_SET_HASH_IPPORT=y
          CONFIG_IP_SET_HASH_IPPORTIP=y
          CONFIG_IP_SET_HASH_IPPORTNET=y
          CONFIG_IP_SET_HASH_NET=y
          CONFIG_IP_SET_HASH_NETNET=y
          CONFIG_IP_SET_HASH_NETPORT=y
          CONFIG_IP_SET_HASH_NETIFACE=y

          # === SUSFS Configuration ===
          # SUSFS Core
          CONFIG_KSU_SUSFS=y
          CONFIG_KSU_SUSFS_HAS_MAGIC_MOUNT=y
          CONFIG_KSU_SUSFS_SUS_PATH=y
          CONFIG_KSU_SUSFS_SUS_MOUNT=y

          # SUSFS Auto Mount Features
          CONFIG_KSU_SUSFS_AUTO_ADD_SUS_KSU_DEFAULT_MOUNT=y
          CONFIG_KSU_SUSFS_AUTO_ADD_SUS_BIND_MOUNT=y
          CONFIG_KSU_SUSFS_TRY_UMOUNT=y
          CONFIG_KSU_SUSFS_AUTO_ADD_TRY_UMOUNT_FOR_BIND_MOUNT=y

          # SUSFS Advanced Features
          CONFIG_KSU_SUSFS_SUS_KSTAT=y
          CONFIG_KSU_SUSFS_SUS_OVERLAYFS=n
          CONFIG_KSU_SUSFS_SPOOF_UNAME=y
          CONFIG_KSU_SUSFS_SPOOF_CMDLINE_OR_BOOTCONFIG=y
          CONFIG_KSU_SUSFS_OPEN_REDIRECT=y

          # SUSFS Debugging and Security
          CONFIG_KSU_SUSFS_ENABLE_LOG=y
          CONFIG_KSU_SUSFS_HIDE_KSU_SUSFS_SYMBOLS=y
          CONFIG_KSU_SUSFS_SUS_SU=n

          # === Build Optimization Configuration ===
          CONFIG_LTO_CLANG_THIN=y
          CONFIG_LTO_CLANG=y
          CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE=y
          CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE_O3=n
          EOF
          
          # Remove check_defconfig
          #sed -i 's/check_defconfig//' ./common/build.config.gki

      - name: Change Kernel Name
        run: |
          cd "$CONFIG"
          
          perl -pi -e 's/-dirty//' ./common/scripts/setlocalversion
          
          #Set Kernel Timestamp
          perl -pi -e 's{UTS_VERSION="\$\(echo \$UTS_VERSION \$CONFIG_FLAGS \$TIMESTAMP \| cut -b -\$UTS_LEN\)"}{UTS_VERSION="#1 SMP PREEMPT Sun Apr 20 04:20:00 UTC 2025"}' ./common/scripts/mkcompile_h
          
          #Set Kernel Name
          if [ "${{ inputs.kernel_version }}" = "6.6" ]; then
            perl -0777 -pi -e 's/(echo "\$\{KERNELVERSION\}\$\{file_localversion\}\$\{config_localversion\}\$\{LOCALVERSION\}\$\{scm_version\}")(?!.*\1)/echo "\$\{KERNELVERSION\}-${{ inputs.android_version }}-🟢-Wild"/s' ./common/scripts/setlocalversion
          else
            perl -0777 -pi -e 's/(echo "\$res")(?!.*\1)/echo "\-${{ inputs.android_version }}-🟢-Wild"/s' ./common/scripts/setlocalversion
          fi
              
          #Set Kernel Timestamp
          perl -pi -e 's/build-timestamp = \$\(or \$\(KBUILD_BUILD_TIMESTAMP\), \$\(build-timestamp-auto\)\)/build-timestamp = "Sun Apr 20 04:20:00 UTC 2025"/' ./common/init/Makefile
              
          #Remove Abi Exports and Error
          rm -rf ./common/android/abi_gki_protected_exports_*
          #perl -pi -e 's/^\s*"protected_exports_list"\s*:\s*"android\/abi_gki_protected_exports_aarch64",\s*$//;' ./common/BUILD.bazel

      - name: Detect Clang Version from Configs
        run: |
          KERNEL_PATH="$GITHUB_WORKSPACE/$CONFIG"
          DEFCONFIG="$KERNEL_PATH/common/arch/arm64/configs/gki_defconfig"
          BUILDCONFIG="$KERNEL_PATH/common/build.config.gki"
          CONSTANTSCONFIG="$KERNEL_PATH/common/build.config.constants"
          CLANG_VERSION=""
          CLANG_BIN_PATH=""
          if grep -q '^CONFIG_CLANG_VERSION=' "$DEFCONFIG" 2>/dev/null; then
            CLANG_VERSION=$(grep '^CONFIG_CLANG_VERSION=' "$DEFCONFIG" 2>/dev/null | head -n1 | cut -d'=' -f2 | tr -d '"' | xargs)
          elif grep -q '^CLANG_VERSION=' "$BUILDCONFIG" 2>/dev/null; then
            CLANG_VERSION=$(grep '^CLANG_VERSION=' "$BUILDCONFIG" 2>/dev/null | head -n1 | cut -d'=' -f2 | xargs)
          elif grep -q '^CLANG_VERSION=' "$CONSTANTSCONFIG" 2>/dev/null; then
            CLANG_VERSION=$(grep '^CLANG_VERSION=' "$CONSTANTSCONFIG" 2>/dev/null | head -n1 | cut -d'=' -f2 | xargs)
            CLANG_VERSION="clang-$CLANG_VERSION"
          else
            echo "No clang version found in config, will auto-detect in prebuilts."
          fi
          if [ -z "$CLANG_VERSION" ]; then
            if [ -d "$KERNEL_PATH/prebuilts/clang/host/linux-x86" ]; then
              CLANG_VERSION=$(ls -d "$KERNEL_PATH"/prebuilts/clang/host/linux-x86/clang-r*/ | tail -n 1 | xargs basename)
              CLANG_BIN_PATH="$KERNEL_PATH/prebuilts/clang/host/linux-x86/$CLANG_VERSION/bin"
            elif [ -d "$KERNEL_PATH/prebuilts-master/clang/host/linux-x86" ]; then
              CLANG_VERSION=$(ls -d "$KERNEL_PATH"/prebuilts-master/clang/host/linux-x86/clang-r*/ | tail -n 1 | xargs basename)
              CLANG_BIN_PATH="$KERNEL_PATH/prebuilts-master/clang/host/linux-x86/$CLANG_VERSION/bin"
            else
              CLANG_VERSION="clang"
              CLANG_BIN_PATH="$KERNEL_PATH/prebuilts/clang/host/linux-x86/$CLANG_VERSION/bin" # dummy
            fi
          else
            if [ -d "$KERNEL_PATH/prebuilts/clang/host/linux-x86" ]; then
              CLANG_BIN_PATH="$KERNEL_PATH/prebuilts/clang/host/linux-x86/$CLANG_VERSION/bin"
            else
              CLANG_BIN_PATH="$KERNEL_PATH/prebuilts-master/clang/host/linux-x86/$CLANG_VERSION/bin"
            fi
          fi
          echo "CLANG_VERSION=$CLANG_VERSION" >> $GITHUB_ENV
          echo "CLANG_BIN_PATH=$CLANG_BIN_PATH" >> $GITHUB_ENV

      - name: Check and Add Image.lz4 Build Rule
        run: |
          KERNEL_PATH="$GITHUB_WORKSPACE/$CONFIG"
          MAKEFILE_PATH="$KERNEL_PATH/common/arch/arm64/boot/Makefile"
          
          if [ -f "$MAKEFILE_PATH" ]; then
            # Check if Image.lz4 is in targets
            if ! grep -q "Image.lz4" "$MAKEFILE_PATH" | grep -q "targets"; then
              sed -i 's/targets := Image Image.bz2 Image.gz Image.lzma Image.lzo \\/targets := Image Image.bz2 Image.gz Image.lz4 Image.lzma Image.lzo \\/' "$MAKEFILE_PATH"
            fi
            
            # Check if Image.lz4 build rule exists
            if ! grep -q "\$(obj)/Image.lz4: \$(obj)/Image FORCE" "$MAKEFILE_PATH"; then
              # Add the Image.lz4 build rule
              cat >> "$MAKEFILE_PATH" << 'EOF'

              $(obj)/Image.lz4: $(obj)/Image FORCE
              $(call if_changed,lz4)
              EOF
            fi
          fi

      - name: Build Kernel
        run: |
          KERNEL_PATH="$GITHUB_WORKSPACE/$CONFIG"
          CLANG_BIN_PATH="${{ env.CLANG_BIN_PATH }}"
          CLANG_VERSION="${{ env.CLANG_VERSION }}"
          
          if [ -d "$CLANG_BIN_PATH" ] && [ -x "$CLANG_BIN_PATH/clang" ]; then
            export PATH="$CLANG_BIN_PATH:$PATH"
            SELECTED_CLANG="$CLANG_BIN_PATH/clang"
          elif command -v clang >/dev/null 2>&1; then
            SELECTED_CLANG="$(command -v clang)"
            exit 1
          else
            exit 1
          fi
          
          LLVM_TOOLS="clang ld.lld llvm-ar llvm-objcopy llvm-objdump llvm-nm"
          MISSING_TOOLS=""
          for tool in $LLVM_TOOLS; do
            if ! command -v $tool >/dev/null 2>&1; then
              MISSING_TOOLS="$MISSING_TOOLS $tool"
            fi
          done
          
          if [ -n "$MISSING_TOOLS" ]; then
            sudo apt-get update
            sudo apt-get install -yq --no-install-recommends llvm
            for tool in $MISSING_TOOLS; do
              if ! command -v $tool >/dev/null 2>&1; then
                exit 1
              fi
            done
          fi
          
          KERNEL_VERSION="${{ inputs.kernel_version }}"
          if [[ "$KERNEL_VERSION" == "5.10" ]]; then
            USE_LLVM_IAS=true
          fi
          
          cd "$KERNEL_PATH/common" || exit 1
          
          MAKE_ARGS="LLVM=1 ARCH=arm64 CROSS_COMPILE=aarch64-linux-android- \
            RUSTC=$KERNEL_PATH/prebuilts/rust/linux-x86/1.73.0b/bin/rustc \
            PAHOLE=$KERNEL_PATH/prebuilts/kernel-build-tools/linux-x86/bin/pahole \
            LD=ld.lld HOSTLD=ld.lld"
          if [[ -v USE_LLVM_IAS ]]; then
            MAKE_ARGS="LLVM_IAS=1 $MAKE_ARGS"
          fi
          
          make -j$(nproc --all) O=out $MAKE_ARGS KCFLAGS+="-Wno-error -O2 -flto=thin -fno-stack-protector" gki_defconfig || exit 1
          
          make -j$(nproc --all) O=out $MAKE_ARGS KCFLAGS+="-Wno-error -O2 -flto=thin -fno-stack-protector" || exit 1

      - name: Create Kernel ZIP
        run: |
          cp $CONFIG/common/out/arch/arm64/boot/Image AnyKernel3/Image

          cd AnyKernel3
          
          # Use actual sublevel for LTS builds if available
          SUBLEVEL_FOR_NAME="${{ inputs.sub_level }}"
          if [ -n "$ACTUAL_SUBLEVEL" ]; then
            SUBLEVEL_FOR_NAME="$ACTUAL_SUBLEVEL"
          fi
          
          ZIP_NAME="WKSU-$KSUVER-${{ inputs.android_version }}-${{ inputs.kernel_version }}.$SUBLEVEL_FOR_NAME-${{ inputs.os_patch_level }}-AnyKernel3.zip"
          
          zip -r "../$ZIP_NAME" ./*
          
          cd ..

      - name: Create Bootimgs Folder and Copy Images
        run: |
          mkdir bootimgs

          SUBLEVEL_FOR_NAME="${{ inputs.sub_level }}"
          if [ -n "$ACTUAL_SUBLEVEL" ]; then
            SUBLEVEL_FOR_NAME="$ACTUAL_SUBLEVEL"
          fi
            
          for img_type in "" ".lz4" ".gz"; do
            src_file="$CONFIG/common/out/arch/arm64/boot/Image${img_type}"
            dest_file="./bootimgs/Image${img_type}"
            versioned_file="./WKSU-$KSUVER-${{ inputs.android_version }}-${{ inputs.kernel_version }}.$SUBLEVEL_FOR_NAME-${{ inputs.os_patch_level }}-Image${img_type}"
            
            if [ -f "$src_file" ]; then
              cp "$src_file" "$dest_file"
              cp "$src_file" "$versioned_file"
            fi
          done

      - name: Build Boot Images
        run: |
          cd bootimgs
          
          # Prepare sublevel for naming
          SUBLEVEL_FOR_NAME="${{ inputs.sub_level }}"
          if [ -n "$ACTUAL_SUBLEVEL" ]; then
            SUBLEVEL_FOR_NAME="$ACTUAL_SUBLEVEL"
          fi
          
          # Android 12 specific setup
          if [[ "${{ inputs.android_version }}" == "android12" ]]; then
            # Download and setup GKI kernel with improved error handling
            GKI_URL="https://dl.google.com/android/gki/gki-certified-boot-android12-5.10-${{ inputs.os_patch_level }}_${{ inputs.revision }}.zip"
            FALLBACK_URL="https://dl.google.com/android/gki/gki-certified-boot-android12-5.10-2023-01_r1.zip"
            
            echo "Attempting to download GKI kernel from: $GKI_URL"
            if ! curl -fsSL --retry 3 --retry-delay 5 -o gki-kernel.zip "$GKI_URL"; then
              echo "Primary URL failed, trying fallback: $FALLBACK_URL"
              if ! curl -fsSL --retry 3 --retry-delay 5 -o gki-kernel.zip "$FALLBACK_URL"; then
                echo "Error: Failed to download GKI kernel from both URLs"
                exit 1
              fi
            fi
            
            if ! unzip -q gki-kernel.zip; then
              echo "Error: Failed to extract GKI kernel"
              exit 1
            fi
            rm -f gki-kernel.zip
            
            FULL_PATH=$(pwd)/boot-5.10.img
            if ! $UNPACK_BOOTIMG --boot_img="$FULL_PATH"; then
              echo "Error: Failed to unpack boot image"
              exit 1
            fi
            
            RAMDISK_ARG="--ramdisk out/ramdisk --os_version 12.0.0 --os_patch_level ${{ inputs.os_patch_level }}"
          else
            RAMDISK_ARG=""
          fi
          
          # Function to build a single boot image
          build_boot_image() {
            local kernel_type="$1"
            local kernel_file="Image${kernel_type}"
            local output_file="boot${kernel_type}.img"
            local final_name="../WKSU-$KSUVER-${{ inputs.android_version }}-${{ inputs.kernel_version }}.$SUBLEVEL_FOR_NAME-${{ inputs.os_patch_level }}-boot${kernel_type}.img"
            
            echo "Building $output_file with kernel $kernel_file"
            
            # Check if kernel file exists
            if [ ! -f "$kernel_file" ]; then
              echo "Warning: Kernel file $kernel_file not found, skipping"
              return 0
            fi
            
            # Build boot image
            if ! $MKBOOTIMG --header_version 4 --kernel "$kernel_file" --output "$output_file" $RAMDISK_ARG; then
              echo "Error: Failed to create $output_file"
              return 1
            fi
            
            # Add AVB hash footer
            if ! $AVBTOOL add_hash_footer --partition_name boot --partition_size $((64 * 1024 * 1024)) --image "$output_file" --algorithm SHA256_RSA2048 --key $BOOT_SIGN_KEY_PATH; then
              echo "Error: Failed to add AVB hash footer to $output_file"
              return 1
            fi
            
            # Copy to final location
            if ! cp "$output_file" "$final_name"; then
              echo "Error: Failed to copy $output_file to $final_name"
              return 1
            fi
            
            echo "Successfully built $final_name"
          }
          
          # Build all boot images in parallel with error handling
          declare -a pids=()
          declare -a kernel_types=("" "-gz" "-lz4")
          
          for kernel_type in "${kernel_types[@]}"; do
            build_boot_image "$kernel_type" &
            pids+=("$!")
          done
          
          # Wait for all background jobs and check their exit status
          failed_jobs=0
          for i in "${!pids[@]}"; do
            if ! wait "${pids[$i]}"; then
              echo "Error: Build job for kernel type '${kernel_types[$i]}' failed"
              failed_jobs=$((failed_jobs + 1))
            fi
          done
          
          if [ $failed_jobs -gt 0 ]; then
            echo "Error: $failed_jobs build job(s) failed"
            exit 1
          fi
          
          echo "All boot images built successfully"
          
      - name: Upload Build Artifacts
        run: |
          # Prepare sublevel for naming
          SUBLEVEL_FOR_NAME="${{ inputs.sub_level }}"
          if [ -n "$ACTUAL_SUBLEVEL" ]; then
            SUBLEVEL_FOR_NAME="$ACTUAL_SUBLEVEL"
          fi
          
      - name: Upload Build Artifacts
        uses: actions/upload-artifact@v4
        with:
          name: WKSU-${{ env.KSUVER }}-${{ inputs.android_version }}-${{ inputs.kernel_version }}.${{ env.ACTUAL_SUBLEVEL || inputs.sub_level }}-${{ inputs.os_patch_level }}
          path: |
            *.zip
            *.img
            *Image*