kernel-build.yml

name: Reusable build workflow

on:
  workflow_call:
    inputs:
      arch:
        required: true
        type: string
        description: The architecture to build against, e.g x86_64, aarch64, s390x...
      toolchain_full:
        required: true
        type: string
        description: The toolchain and for llvm, its version, e.g gcc, llvm-15
      toolchain:
        required: true
        type: string
        description: The toolchain, e.g gcc, llvm
      runs_on:
        required: true
        type: string
        description: The runners to run the test on. This is a json string representing an array of labels.
      llvm-version:
        required: true
        type: string
        description: The version of LLVM used to build selftest.... for llvm toolchain, this should match the one from toolchain_full, for gcc it is an arbritrary version we decide to build selftests against.
      kernel:
        required: true
        type: string
        description: The kernel to run the test against. For KPD this is always LATEST, which runs against a newly built kernel.
      download_sources:
        required: true
        type: boolean
        description: Whether to download the linux sources into the working directory.
        default: false
      release:
        required: false
        type: boolean
        description: Build selftest with -O2 optimization
        default: false

jobs:
  build:
    name: build for ${{ inputs.arch }} with ${{ inputs.toolchain_full }}${{ inputs.release && '-O2' || '' }}
    # To run on CodeBuild, runs-on value must correspond to the AWS
    # CodeBuild project associated with the kernel-patches webhook
    # However matrix.py passes just a 'codebuild' string
    runs-on: >-
      ${{
          contains(fromJSON(inputs.runs_on), 'codebuild')
          && format('codebuild-bpf-ci-{0}-{1}', github.run_id, github.run_attempt)
          || fromJSON(inputs.runs_on)
      }}
    env:
        ARTIFACTS_ARCHIVE: "vmlinux-${{ inputs.arch }}-${{ inputs.toolchain_full }}.tar.zst"
        BPF_NEXT_BASE_BRANCH: 'master'
        BPF_NEXT_FETCH_DEPTH: 64 # A bit of history is needed to facilitate incremental builds
        CROSS_COMPILE: ${{ inputs.arch != 'x86_64' && 'true' || '' }}
        # BUILD_SCHED_EXT_SELFTESTS: ${{ inputs.arch == 'x86_64' || inputs.arch == 'aarch64' && 'true' || '' }}
        KBUILD_OUTPUT: ${{ github.workspace }}/kbuild-output
        KERNEL: ${{ inputs.kernel }}
        KERNEL_ROOT: ${{ github.workspace }}
        REPO_PATH: ""
        REPO_ROOT: ${{ github.workspace }}
        RUNNER_TYPE: ${{ contains(fromJSON(inputs.runs_on), 'codebuild') && 'codebuild' || 'default' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: ${{ inputs.download_sources && 1 || env.BPF_NEXT_FETCH_DEPTH }}

      - if: ${{ env.RUNNER_TYPE == 'codebuild' }}
        shell: bash
        run: .github/scripts/tmpfsify-workspace.sh

      - if: ${{ inputs.download_sources }}
        name: Download bpf-next tree
        env:
          FETCH_DEPTH: ${{ env.BPF_NEXT_FETCH_DEPTH }}
        uses: libbpf/ci/get-linux-source@v3
        with:
          dest: '.kernel'
          rev: ${{ env.BPF_NEXT_BASE_BRANCH }}
      - uses: libbpf/ci/prepare-incremental-build@v3
        with:
          repo-root: ${{ inputs.download_sources && '.kernel' || env.REPO_ROOT }}
          base-branch: >-
            ${{    inputs.download_sources && env.BPF_NEXT_BASE_BRANCH
                || github.event_name == 'pull_request' && github.base_ref
                || github.ref_name
             }}
          arch: ${{ inputs.arch }}
          toolchain_full: ${{ inputs.toolchain_full }}
          kbuild-output: ${{ env.KBUILD_OUTPUT }}
      - if: ${{ inputs.download_sources }}
        name: Move linux source in place
        shell: bash
        run: |
          cd .kernel
          rm -rf .git
          mv -t .. $(ls -A)
          cd ..
          rmdir .kernel
      - uses:  libbpf/ci/patch-kernel@v3
        with:
          patches-root: '${{ github.workspace }}/ci/diffs'
          repo-root: ${{ env.REPO_ROOT }}

      - name: Setup build environment
        uses: libbpf/ci/setup-build-env@revert-libc-downgrade
        with:
          arch: ${{ inputs.arch }}
          llvm-version: ${{ inputs.llvm-version }}
          pahole: master

        # We have to setup qemu+binfmt in order to enable cross-compation of selftests.
        # During selftests build, freshly built bpftool is executed.
        # On self-hosted bare-metal hosts binfmt is pre-configured.
      - if: ${{ env.RUNNER_TYPE == 'codebuild' && env.CROSS_COMPILE }}
        name: Set up docker
        uses: docker/setup-docker-action@v4
      - if: ${{ env.RUNNER_TYPE == 'codebuild' && env.CROSS_COMPILE }}
        name: Setup binfmt and qemu
        uses: docker/setup-qemu-action@v3
        with:
          image: tonistiigi/binfmt:qemu-v9.2.0

      - name: Build kernel image
        uses: libbpf/ci/build-linux@v3
        with:
          arch: ${{ inputs.arch }}
          toolchain: ${{ inputs.toolchain }}
          kbuild-output: ${{ env.KBUILD_OUTPUT }}
          max-make-jobs: 32
          llvm-version: ${{ inputs.llvm-version }}

      - name: Build selftests/bpf
        uses: libbpf/ci/build-selftests@v3
        env:
          MAX_MAKE_JOBS: 32
          RELEASE: ${{ inputs.release && '1' || '' }}
        with:
          arch: ${{ inputs.arch }}
          kernel-root: ${{ env.KERNEL_ROOT }}
          llvm-version: ${{ inputs.llvm-version }}
          toolchain: ${{ inputs.toolchain }}

      - if: ${{ env.BUILD_SCHED_EXT_SELFTESTS }}
        name: Build selftests/sched_ext
        uses: libbpf/ci/build-scx-selftests@v3
        with:
          kbuild-output: ${{ env.KBUILD_OUTPUT }}
          repo-root: ${{ env.REPO_ROOT }}
          arch: ${{ inputs.arch }}
          toolchain: ${{ inputs.toolchain }}
          llvm-version: ${{ inputs.llvm-version }}
          max-make-jobs: 32

      - if: ${{ github.event_name != 'push' }}
        name: Build samples
        uses: libbpf/ci/build-samples@v3
        with:
          arch: ${{ inputs.arch }}
          toolchain: ${{ inputs.toolchain }}
          kbuild-output: ${{ env.KBUILD_OUTPUT }}
          max-make-jobs: 32
          llvm-version: ${{ inputs.llvm-version }}
      - name: Tar artifacts
        id: tar-artifacts
        uses: libbpf/ci/tar-artifacts@v3
        env:
          ARCHIVE_BPF_SELFTESTS: 'true'
          ARCHIVE_MAKE_HELPERS: 'true'
          ARCHIVE_SCHED_EXT_SELFTESTS: ${{ env.BUILD_SCHED_EXT_SELFTESTS }}
        with:
          arch: ${{ inputs.arch }}
          archive: ${{ env.ARTIFACTS_ARCHIVE }}
          kbuild-output: ${{ env.KBUILD_OUTPUT }}
          repo-root: ${{ env.REPO_ROOT }}
      - if: ${{ github.event_name != 'push' }}
        name: Remove KBUILD_OUTPUT content
        shell: bash
        run: |
          # Remove $KBUILD_OUTPUT to prevent cache creation for pull requests.
          # Only on pushed changes are build artifacts actually cached, because
          # of github.com/actions/cache's cache isolation logic.
          rm -rf "${KBUILD_OUTPUT}"
      - uses: actions/upload-artifact@v4
        with:
          name: vmlinux-${{ inputs.arch }}-${{ inputs.toolchain_full }}${{ inputs.release && '-release' || '' }}
          if-no-files-found: error
          path: ${{ env.ARTIFACTS_ARCHIVE }}