libbpf: Fix XDP program load regression for old kernels

Fix regression in libbpf, introduced by XDP link change, which causes XDP
programs to fail to be loaded into kernel due to specified BPF_XDP
expected_attach_type. While kernel doesn't enforce expected_attach_type for
BPF_PROG_TYPE_XDP, some old kernels already support XDP program, but they
don't yet recognize expected_attach_type field in bpf_attr, so setting it to
non-zero value causes program load to fail.

Luckily, libbpf already has a mechanism to deal with such cases, so just make
expected_attach_type optional for XDP programs.

Fixes: dc8698cac7aa ("libbpf: Add support for BPF XDP link")
Reported-by: Nikita Shirokov <tehnerd@tehnerd.com>
Reported-by: Udip Pant <udippant@fb.com>
Signed-off-by: Andrii Nakryiko <andriin@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20200924171705.3803628-1-andriin@fb.com
(cherry picked from commit 2200fefd87)

.gitattributes

@@ -1 +0,0 @@
-assets/** export-ignore

.github/actions/build-selftests/action.yml

@@ -1,36 +0,0 @@
-name: 'build-selftests'
-description: 'Build BPF selftests'
-inputs:
-  repo-path:
-    description: 'where is the source code'
-    required: true
-  kernel:
-    description: 'kernel version or LATEST'
-    required: true
-    default: 'LATEST'
-  vmlinux:
-    description: 'where is vmlinux file'
-    required: true
-    default: '${{ github.workspace }}/vmlinux'
-  llvm-version:
-    description: 'llvm version'
-    required: true
-
-runs:
-  using: "composite"
-  steps:
-    - shell: bash
-      run: |
-        source $GITHUB_ACTION_PATH/../../../ci/vmtest/helpers.sh
-        foldable start "Setup Env"
-        sudo apt-get install -y qemu-kvm zstd binutils-dev elfutils libcap-dev libelf-dev libdw-dev python3-docutils
-        foldable end
-    - shell: bash
-      run: |
-        export KERNEL=${{ inputs.kernel }}
-        export REPO_ROOT="${{ github.workspace }}"
-        export REPO_PATH="${{ inputs.repo-path }}"
-        export VMLINUX_BTF="${{ inputs.vmlinux }}"
-        export LLVM_VERSION="${{ inputs.llvm-version }}"
-
-        ${{ github.action_path }}/build_selftests.sh

.github/actions/build-selftests/build_selftests.sh

@@ -1,59 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-
-THISDIR="$(cd $(dirname $0) && pwd)"
-
-source ${THISDIR}/helpers.sh
-
-foldable start prepare_selftests "Building selftests"
-
-LIBBPF_PATH="${REPO_ROOT}"
-
-llvm_latest_version() {
-	echo "19"
-}
-
-if [[ "${LLVM_VERSION}" == $(llvm_latest_version) ]]; then
-	REPO_DISTRO_SUFFIX=""
-else
-	REPO_DISTRO_SUFFIX="-${LLVM_VERSION}"
-fi
-
-DISTRIB_CODENAME="noble"
-test -f /etc/lsb-release && . /etc/lsb-release
-echo "${DISTRIB_CODENAME}"
-
-echo "deb https://apt.llvm.org/${DISTRIB_CODENAME}/ llvm-toolchain-${DISTRIB_CODENAME}${REPO_DISTRO_SUFFIX} main" \
-	| sudo tee /etc/apt/sources.list.d/llvm.list
-
-PREPARE_SELFTESTS_SCRIPT=${THISDIR}/prepare_selftests-${KERNEL}.sh
-if [ -f "${PREPARE_SELFTESTS_SCRIPT}" ]; then
-	(cd "${REPO_ROOT}/${REPO_PATH}/tools/testing/selftests/bpf" && ${PREPARE_SELFTESTS_SCRIPT})
-fi
-
-if [[ "${KERNEL}" = 'LATEST' ]]; then
-	VMLINUX_H=
-else
-	VMLINUX_H=${THISDIR}/vmlinux.h
-fi
-
-cd ${REPO_ROOT}/${REPO_PATH}
-make headers
-make \
-	CLANG=clang-${LLVM_VERSION} \
-	LLC=llc-${LLVM_VERSION} \
-	LLVM_STRIP=llvm-strip-${LLVM_VERSION} \
-	VMLINUX_BTF="${VMLINUX_BTF}" \
-	VMLINUX_H=${VMLINUX_H} \
-	-C "${REPO_ROOT}/${REPO_PATH}/tools/testing/selftests/bpf" \
-	-j $((4*$(nproc))) > /dev/null
-cd -
-mkdir ${LIBBPF_PATH}/selftests
-cp -R "${REPO_ROOT}/${REPO_PATH}/tools/testing/selftests/bpf" \
-	${LIBBPF_PATH}/selftests
-cd ${LIBBPF_PATH}
-rm selftests/bpf/.gitignore
-git add selftests
-
-foldable end prepare_selftests

.github/actions/build-selftests/helpers.sh

@@ -1,38 +0,0 @@
-# shellcheck shell=bash
-
-# $1 - start or end
-# $2 - fold identifier, no spaces
-# $3 - fold section description
-foldable() {
-  local YELLOW='\033[1;33m'
-  local NOCOLOR='\033[0m'
-  if [ $1 = "start" ]; then
-    line="::group::$2"
-    if [ ! -z "${3:-}" ]; then
-      line="$line - ${YELLOW}$3${NOCOLOR}"
-    fi
-  else
-    line="::endgroup::"
-  fi
-  echo -e "$line"
-}
-
-__print() {
-  local TITLE=""
-  if [[ -n $2 ]]; then
-      TITLE=" title=$2"
-  fi
-  echo "::$1${TITLE}::$3"
-}
-
-# $1 - title
-# $2 - message
-print_error() {
-  __print error $1 $2
-}
-
-# $1 - title
-# $2 - message
-print_notice() {
-  __print notice $1 $2
-}

.github/actions/build-selftests/prepare_selftests-4.9.0.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-printf "all:\n\ttouch bpf_testmod.ko\n\nclean:\n" > bpf_testmod/Makefile
-printf "all:\n\ttouch bpf_test_no_cfi.ko\n\nclean:\n" > bpf_test_no_cfi/Makefile
-

.github/actions/build-selftests/prepare_selftests-5.5.0.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-printf "all:\n\ttouch bpf_testmod.ko\n\nclean:\n" > bpf_testmod/Makefile
-printf "all:\n\ttouch bpf_test_no_cfi.ko\n\nclean:\n" > bpf_test_no_cfi/Makefile
-

.github/actions/debian/action.yml

@@ -1,16 +0,0 @@
-name: 'debian'
-description: 'Build'
-inputs:
-  target:
-    description: 'Run target'
-    required: true
-runs:
-  using: "composite"
-  steps:
-    - run: |
-        source /tmp/ci_setup
-        bash -x $CI_ROOT/managers/debian.sh SETUP
-        bash -x $CI_ROOT/managers/debian.sh ${{ inputs.target }}
-        bash -x $CI_ROOT/managers/debian.sh CLEANUP
-      shell: bash
-

.github/actions/setup/action.yml

@@ -1,23 +0,0 @@
-name: 'setup'
-description: 'setup env, create /tmp/ci_setup'
-runs:
-  using: "composite"
-  steps:
-    - id: variables
-      run: |
-        export REPO_ROOT=$GITHUB_WORKSPACE
-        export CI_ROOT=$REPO_ROOT/ci
-        # this is somewhat ugly, but that is the easiest way to share this code with
-        # arch specific docker
-        echo 'echo ::group::Env setup' > /tmp/ci_setup
-        echo export DEBIAN_FRONTEND=noninteractive >> /tmp/ci_setup
-        echo sudo apt-get update >> /tmp/ci_setup
-        echo sudo apt-get install -y aptitude qemu-kvm zstd binutils-dev elfutils libcap-dev libelf-dev libdw-dev libguestfs-tools >> /tmp/ci_setup
-        echo export PROJECT_NAME='libbpf' >> /tmp/ci_setup
-        echo export AUTHOR_EMAIL="$(git log -1 --pretty=\"%aE\")" >> /tmp/ci_setup
-        echo export REPO_ROOT=$GITHUB_WORKSPACE >> /tmp/ci_setup
-        echo export CI_ROOT=$REPO_ROOT/ci >> /tmp/ci_setup
-        echo export VMTEST_ROOT=$CI_ROOT/vmtest >> /tmp/ci_setup
-        echo 'echo ::endgroup::' >> /tmp/ci_setup
-      shell: bash
-

.github/actions/vmtest/action.yml

@@ -1,124 +0,0 @@
-name: 'vmtest'
-description: 'Build + run vmtest'
-inputs:
-  kernel:
-    description: 'kernel version or LATEST'
-    required: true
-    default: 'LATEST'
-  arch:
-    description: 'what arch to test'
-    required: true
-    default: 'x86_64'
-  pahole:
-    description: 'pahole rev or master'
-    required: true
-    default: 'master'
-  llvm-version:
-    description: 'llvm version'
-    required: false
-    default: '17'
-runs:
-  using: "composite"
-  steps:
-    # Allow CI user to access /dev/kvm (via qemu) w/o group change/relogin
-    # by changing permissions set by udev.
-    - name: Set /dev/kvm permissions
-      shell: bash
-      run: |
-        if [ -e /dev/kvm ]; then
-          echo "/dev/kvm exists"
-          if [ $(id -u) != 0 ]; then
-            echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' \
-              | sudo tee /etc/udev/rules.d/99-kvm4all.rules > /dev/null
-            sudo udevadm control --reload-rules
-            sudo udevadm trigger --name-match=kvm
-          fi
-        else
-          echo "/dev/kvm does not exist"
-        fi
-    # setup environment
-    - name: Setup environment
-      uses: libbpf/ci/setup-build-env@main
-      with:
-        pahole: ${{ inputs.pahole }}
-        arch: ${{ inputs.arch }}
-        llvm-version: ${{ inputs.llvm-version }}
-    # 1. download CHECKPOINT kernel source
-    - name: Get checkpoint commit
-      shell: bash
-      run: |
-        cat CHECKPOINT-COMMIT
-        echo "CHECKPOINT=$(cat CHECKPOINT-COMMIT)" >> $GITHUB_ENV
-    - name: Get kernel source at checkpoint
-      uses: libbpf/ci/get-linux-source@main
-      with:
-        repo: 'https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git'
-        rev: ${{ env.CHECKPOINT }}
-        dest: '${{ github.workspace }}/.kernel'
-    - name: Patch kernel source
-      uses: libbpf/ci/patch-kernel@main
-      with:
-        patches-root: '${{ github.workspace }}/ci/diffs'
-        repo-root: '.kernel'
-    - name: Prepare to build BPF selftests
-      shell: bash
-      run: |
-        source $GITHUB_ACTION_PATH/../../../ci/vmtest/helpers.sh
-        foldable start "Prepare building selftest"
-        cd .kernel
-        cat tools/testing/selftests/bpf/config \
-            tools/testing/selftests/bpf/config.${{ inputs.arch }} > .config
-        # this file might or mihgt not exist depending on kernel version
-        cat tools/testing/selftests/bpf/config.vm >> .config || :
-        make olddefconfig && make prepare
-        cd -
-        foldable end
-    # 2. if kernel == LATEST, build kernel image from tree
-    - name: Build kernel image
-      if: ${{ inputs.kernel == 'LATEST' }}
-      shell: bash
-      run: |
-        source $GITHUB_ACTION_PATH/../../../ci/vmtest/helpers.sh
-        foldable start "Build Kernel Image"
-        cd .kernel
-        make -j $((4*$(nproc))) all > /dev/null
-        cp vmlinux ${{ github.workspace }}
-        cd -
-        foldable end
-    # else, just download prebuilt kernel image
-    - name: Download prebuilt kernel
-      if: ${{ inputs.kernel != 'LATEST' }}
-      uses: libbpf/ci/download-vmlinux@main
-      with:
-        kernel: ${{ inputs.kernel }}
-        arch: ${{ inputs.arch }}
-    # 3. build selftests
-    - name: Build BPF selftests
-      uses: ./.github/actions/build-selftests
-      with:
-        repo-path: '.kernel'
-        kernel: ${{ inputs.kernel }}
-        llvm-version: ${{ inputs.llvm-version }}
-    # 4. prepare rootfs
-    - name: prepare rootfs
-      uses: libbpf/ci/prepare-rootfs@main
-      env:
-        KBUILD_OUTPUT: '.kernel'
-      with:
-        project-name: 'libbpf'
-        arch: ${{ inputs.arch }}
-        kernel: ${{ inputs.kernel }}
-        kernel-root: '.kernel'
-        kbuild-output: ${{ env.KBUILD_OUTPUT }}
-        image-output: '/tmp/root.img'
-    # 5. run selftest in QEMU
-    - name: Run selftests
-      env:
-        KERNEL: ${{ inputs.kernel }}
-        REPO_ROOT: ${{ github.workspace }}
-      uses: libbpf/ci/run-qemu@main
-      with:
-        arch: ${{ inputs.arch }}
-        img: '/tmp/root.img'
-        vmlinuz: 'vmlinuz'
-        kernel-root: '.kernel'

.github/workflows/build.yml

@@ -1,91 +0,0 @@
-name: libbpf-build
-
-on:
-  pull_request:
-  push:
-  schedule:
-    - cron:  '0 18 * * *'
-
-concurrency:
-  group: ci-build-${{ github.head_ref }}
-  cancel-in-progress: true
-
-jobs:
-
-  debian:
-    runs-on: ubuntu-latest
-    name: Debian Build (${{ matrix.name }})
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - name: default
-            target: RUN
-          - name: ASan+UBSan
-            target: RUN_ASAN
-          - name: clang ASan+UBSan
-            target: RUN_CLANG_ASAN
-          - name: gcc-10 ASan+UBSan
-            target: RUN_GCC10_ASAN
-          - name: clang
-            target: RUN_CLANG
-          - name: clang-14
-            target: RUN_CLANG14
-          - name: clang-15
-            target: RUN_CLANG15
-          - name: clang-16
-            target: RUN_CLANG16
-          - name: gcc-10
-            target: RUN_GCC10
-          - name: gcc-11
-            target: RUN_GCC11
-          - name: gcc-12
-            target: RUN_GCC12
-    steps:
-      - uses: actions/checkout@v4
-        name: Checkout
-      - uses: ./.github/actions/setup
-        name: Setup
-      - uses: ./.github/actions/debian
-        name: Build
-        with:
-          target: ${{ matrix.target }}
-
-  ubuntu:
-    runs-on: ubuntu-latest
-    name: Ubuntu Build (${{ matrix.arch }})
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - arch: aarch64
-          - arch: ppc64le
-          - arch: s390x
-          - arch: x86
-    steps:
-      - uses: actions/checkout@v4
-        name: Checkout
-      - uses: ./.github/actions/setup
-        name: Pre-Setup
-      - run: source /tmp/ci_setup && sudo -E $CI_ROOT/managers/ubuntu.sh
-        if: matrix.arch == 'x86'
-        name: Setup
-      - uses: uraimo/run-on-arch-action@v2.7.1
-        name: Build in docker
-        if: matrix.arch != 'x86'
-        with:
-          distro:
-            ubuntu22.04
-          arch:
-            ${{ matrix.arch }}
-          setup:
-            cp /tmp/ci_setup $GITHUB_WORKSPACE
-          dockerRunArgs: |
-            --volume "${GITHUB_WORKSPACE}:${GITHUB_WORKSPACE}"
-          shell: /bin/bash
-          install: |
-            export DEBIAN_FRONTEND=noninteractive
-            export TZ="America/Los_Angeles"
-            apt-get update -y
-            apt-get install -y tzdata build-essential sudo
-          run: source ${GITHUB_WORKSPACE}/ci_setup && $CI_ROOT/managers/ubuntu.sh

.github/workflows/cifuzz.yml

@@ -1,40 +0,0 @@
----
-# https://google.github.io/oss-fuzz/getting-started/continuous-integration/
-name: CIFuzz
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-jobs:
-  Fuzzing:
-    runs-on: ubuntu-latest
-    if: github.repository == 'libbpf/libbpf'
-    strategy:
-      fail-fast: false
-      matrix:
-        sanitizer: [address, undefined, memory]
-    steps:
-      - name: Build Fuzzers (${{ matrix.sanitizer }})
-        id: build
-        uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
-        with:
-          oss-fuzz-project-name: 'libbpf'
-          dry-run: false
-          allowed-broken-targets-percentage: 0
-          sanitizer: ${{ matrix.sanitizer }}
-      - name: Run Fuzzers (${{ matrix.sanitizer }})
-        uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
-        with:
-          oss-fuzz-project-name: 'libbpf'
-          fuzz-seconds: 300
-          dry-run: false
-          sanitizer: ${{ matrix.sanitizer }}
-      - name: Upload Crash
-        uses: actions/upload-artifact@v1
-        if: failure() && steps.build.outcome == 'success'
-        with:
-          name: ${{ matrix.sanitizer }}-artifacts
-          path: ./out/artifacts

.github/workflows/codeql.yml

@@ -1,52 +0,0 @@
----
-# vi: ts=2 sw=2 et:
-
-name: "CodeQL"
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-permissions:
-  contents: read
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    concurrency:
-      group: ${{ github.workflow }}-${{ matrix.language }}-${{ github.ref }}
-      cancel-in-progress: true
-    permissions:
-      actions: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: ['cpp', 'python']
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
-        with:
-          languages: ${{ matrix.language }}
-          queries: +security-extended,security-and-quality
-
-      - name: Setup
-        uses: ./.github/actions/setup
-
-      - name: Build
-        run: |
-          source /tmp/ci_setup
-          make -C ./src
-
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2

.github/workflows/coverity.yml

@@ -1,32 +0,0 @@
-name: libbpf-ci-coverity
-
-on:
-  schedule:
-    - cron:  '0 18 * * *'
-
-
-jobs:
-  coverity:
-    runs-on: ubuntu-latest
-    if: github.repository == 'libbpf/libbpf'
-    name: Coverity
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/setup
-      - name: Run coverity
-        run: |
-          source "${GITHUB_WORKSPACE}"/ci/vmtest/helpers.sh
-          foldable start "Setup CI env"
-          source /tmp/ci_setup
-          export COVERITY_SCAN_NOTIFICATION_EMAIL="${AUTHOR_EMAIL}"
-          export COVERITY_SCAN_BRANCH_PATTERN=${GITHUB_REF##refs/*/}
-          export TRAVIS_BRANCH=${COVERITY_SCAN_BRANCH_PATTERN}
-          foldable end
-          scripts/coverity.sh
-        env:
-          COVERITY_SCAN_TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}
-          COVERITY_SCAN_PROJECT_NAME: libbpf
-          COVERITY_SCAN_BUILD_COMMAND_PREPEND: 'cd src/'
-          COVERITY_SCAN_BUILD_COMMAND: 'make'
-      - name: SCM log
-        run: cat /home/runner/work/libbpf/libbpf/src/cov-int/scm_log.txt

.github/workflows/lint.yml

@@ -1,19 +0,0 @@
-name: "lint"
-
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-
-jobs:
-  shellcheck:
-    name: ShellCheck
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Run ShellCheck
-        uses: ludeeus/action-shellcheck@master
-        env:
-          SHELLCHECK_OPTS: --severity=error

.github/workflows/ondemand.yml

@@ -1,36 +0,0 @@
-name: ondemand
-
-on:
-  workflow_dispatch:
-    inputs:
-      kernel-origin:
-        description: 'git repo for linux kernel'
-        default: 'https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git'
-        required: true
-      kernel-rev:
-        description: 'rev/tag/branch for linux kernel'
-        default: "master"
-        required: true
-      pahole-origin:
-        description: 'git repo for pahole'
-        default: 'https://git.kernel.org/pub/scm/devel/pahole/pahole.git'
-        required: true
-      pahole-rev:
-        description: 'ref/tag/branch for pahole'
-        default: "master"
-        required: true
-
-jobs:
-  vmtest:
-    runs-on: ubuntu-latest
-    name: vmtest with customized pahole/Kernel
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/setup
-      - uses: ./.github/actions/vmtest
-        with:
-          kernel: 'LATEST'
-          kernel-rev: ${{ github.event.inputs.kernel-rev }}
-          kernel-origin: ${{ github.event.inputs.kernel-origin }}
-          pahole: ${{ github.event.inputs.pahole-rev }}
-          pahole-origin: ${{ github.event.inputs.pahole-origin }}

.github/workflows/pahole.yml

@@ -1,20 +0,0 @@
-name: pahole-staging
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron:  '0 18 * * *'
-
-jobs:
-  vmtest:
-    runs-on: ubuntu-20.04
-    name: Kernel LATEST + staging pahole
-    env:
-      STAGING: tmp.master
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/setup
-      - uses: ./.github/actions/vmtest
-        with:
-          kernel: LATEST
-          pahole: $STAGING

.github/workflows/test.yml

@@ -1,42 +0,0 @@
-name: libbpf-ci
-
-on: 
-  pull_request:
-  push:
-  schedule:
-    - cron:  '0 18 * * *'
-
-concurrency: 
-  group: ci-test-${{ github.head_ref }}
-  cancel-in-progress: true
-
-jobs:
-  vmtest:
-    runs-on: ${{ matrix.runs_on }}
-    name: Kernel ${{ matrix.kernel }} on ${{ matrix.arch }} + selftests
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - kernel: 'LATEST'
-            runs_on: ubuntu-24.04
-            arch: 'x86_64'
-          - kernel: '5.5.0'
-            runs_on: ubuntu-24.04
-            arch: 'x86_64'
-          - kernel: '4.9.0'
-            runs_on: ubuntu-24.04
-            arch: 'x86_64'
-          - kernel: 'LATEST'
-            runs_on: ["s390x", "docker-noble-main"]
-            arch: 's390x'
-    steps:
-      - uses: actions/checkout@v4
-        name: Checkout
-      - uses: ./.github/actions/setup
-        name: Setup
-      - uses: ./.github/actions/vmtest
-        name: vmtest
-        with:
-          kernel: ${{ matrix.kernel }}
-          arch: ${{ matrix.arch }}

.lgtm.yml

@@ -0,0 +1,14 @@
+# vi: set ts=2 sw=2:
+extraction:
+  cpp:
+    prepare:
+      packages:
+        - libelf-dev
+        - pkg-config
+    after_prepare:
+      # As the buildsystem detection by LGTM is performed _only_ during the
+      # 'configure' phase, we need to trick LGTM we use a supported build
+      # system (configure, meson, cmake, etc.). This way LGTM correctly detects
+      # that our sources are in the src/ subfolder.
+      - touch src/configure
+      - chmod +x src/configure

.mailmap

@@ -1,21 +0,0 @@
-Alexei Starovoitov <ast@kernel.org> <alexei.starovoitov@gmail.com>
-Antoine Tenart <atenart@kernel.org> <antoine.tenart@bootlin.com>
-Benjamin Tissoires <bentiss@kernel.org> <benjamin.tissoires@redhat.com>
-Björn Töpel <bjorn@kernel.org> <bjorn.topel@intel.com>
-Changbin Du <changbin.du@intel.com> <changbin.du@gmail.com>
-Colin Ian King <colin.i.king@gmail.com> <colin.king@canonical.com>
-Dan Carpenter <error27@gmail.com> <dan.carpenter@oracle.com>
-Geliang Tang <geliang@kernel.org> <geliang.tang@suse.com>
-Herbert Xu <herbert@gondor.apana.org.au>
-Jakub Kicinski <kuba@kernel.org> <jakub.kicinski@netronome.com>
-Kees Cook <kees@kernel.org> <keescook@chromium.org>
-Leo Yan <leo.yan@linux.dev> <leo.yan@linaro.org>
-Mark Starovoytov <mstarovo@pm.me> <mstarovoitov@marvell.com>
-Maxim Mikityanskiy <maxtram95@gmail.com> <maximmi@mellanox.com>
-Maxim Mikityanskiy <maxtram95@gmail.com> <maximmi@nvidia.com>
-Puranjay Mohan <puranjay@kernel.org> <puranjay12@gmail.com>
-Quentin Monnet <qmo@kernel.org> <quentin@isovalent.com>
-Quentin Monnet <qmo@kernel.org> <quentin.monnet@netronome.com>
-Stanislav Fomichev <sdf@fomichev.me> <sdf@google.com>
-Vadim Fedorenko <vadim.fedorenko@linux.dev> <vadfed@meta.com>
-Vadim Fedorenko <vadim.fedorenko@linux.dev> <vfedorenko@novek.ru>

.readthedocs.yaml

@@ -1,26 +0,0 @@
-# .readthedocs.yaml
-# Read the Docs configuration file
-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-
-# Required
-version: 2
-
-build:
-  os: "ubuntu-22.04"
-  tools:
-    python: "3.11"
-
-# Build documentation in the docs/ directory with Sphinx
-sphinx:
-  builder: html
-  configuration: docs/conf.py
-
-formats:
-  - htmlzip
-  - pdf
-  - epub
-
-# Optionally set the version of Python and requirements required to build your docs
-python:
-   install:
-   - requirements: docs/sphinx/requirements.txt

.travis.yml

@@ -0,0 +1,130 @@
+sudo: required
+language: bash
+dist: bionic
+services:
+    - docker
+
+env:
+    global:
+        - PROJECT_NAME='libbpf'
+        - AUTHOR_EMAIL="$(git log -1 --pretty=\"%aE\")"
+        - REPO_ROOT="$TRAVIS_BUILD_DIR"
+        - CI_ROOT="$REPO_ROOT/travis-ci"
+        - VMTEST_ROOT="$CI_ROOT/vmtest"
+
+addons:
+    apt:
+        packages:
+            - qemu-kvm
+            - zstd
+            - binutils-dev
+            - elfutils
+            - libcap-dev
+            - libelf-dev
+            - libdw-dev
+
+stages:
+    # Run Coverity periodically instead of for each PR for following reasons:
+    # 1) Coverity jobs are heavily rate-limited
+    # 2) Due to security restrictions of encrypted environment variables
+    #    in Travis CI, pull requests made from forks can't access encrypted
+    #    env variables, making Coverity unusable
+    #    See: https://docs.travis-ci.com/user/pull-requests#pull-requests-and-security-restrictions
+    - name: Coverity
+      if: type = cron
+
+jobs:
+    include:
+        - stage: Builds & Tests
+          name: Kernel LATEST + selftests
+          language: bash
+          env: KERNEL=LATEST
+          script:  $CI_ROOT/vmtest/run_vmtest.sh || travis_terminate 1
+
+        - name: Kernel 4.9.0 + selftests
+          language: bash
+          env: KERNEL=4.9.0
+          script:  $CI_ROOT/vmtest/run_vmtest.sh || travis_terminate 1
+
+        - name: Kernel 5.5.0 + selftests
+          language: bash
+          env: KERNEL=5.5.0
+          script:  $CI_ROOT/vmtest/run_vmtest.sh || travis_terminate 1
+
+        - name: Debian Build
+          language: bash
+          install:        $CI_ROOT/managers/debian.sh SETUP
+          script:         $CI_ROOT/managers/debian.sh RUN || travis_terminate 1
+          after_script:   $CI_ROOT/managers/debian.sh CLEANUP
+
+        - name: Debian Build (ASan+UBSan)
+          language: bash
+          install:        $CI_ROOT/managers/debian.sh SETUP
+          script:         $CI_ROOT/managers/debian.sh RUN_ASAN || travis_terminate 1
+          after_script:   $CI_ROOT/managers/debian.sh CLEANUP
+
+        - name: Debian Build (clang)
+          language: bash
+          install:        $CI_ROOT/managers/debian.sh SETUP
+          script:         $CI_ROOT/managers/debian.sh RUN_CLANG || travis_terminate 1
+          after_script:   $CI_ROOT/managers/debian.sh CLEANUP
+
+        - name: Debian Build (clang ASan+UBSan)
+          language: bash
+          install:        $CI_ROOT/managers/debian.sh SETUP
+          script:         $CI_ROOT/managers/debian.sh RUN_CLANG_ASAN || travis_terminate 1
+          after_script:   $CI_ROOT/managers/debian.sh CLEANUP
+
+        - name: Debian Build (gcc-8)
+          language: bash
+          install:        $CI_ROOT/managers/debian.sh SETUP
+          script:         $CI_ROOT/managers/debian.sh RUN_GCC8 || travis_terminate 1
+          after_script:   $CI_ROOT/managers/debian.sh CLEANUP
+
+        - name: Debian Build (gcc-8 ASan+UBSan)
+          language: bash
+          install:        $CI_ROOT/managers/debian.sh SETUP
+          script:         $CI_ROOT/managers/debian.sh RUN_GCC8_ASAN || travis_terminate 1
+          after_script:   $CI_ROOT/managers/debian.sh CLEANUP
+
+        - name: Ubuntu Bionic Build
+          language: bash
+          script: sudo $CI_ROOT/managers/ubuntu.sh || travis_terminate 1
+
+        - name: Ubuntu Bionic Build (arm)
+          arch: arm64
+          language: bash
+          script: sudo $CI_ROOT/managers/ubuntu.sh || travis_terminate 1
+
+        - name: Ubuntu Bionic Build (s390x)
+          arch: s390x
+          language: bash
+          script: sudo $CI_ROOT/managers/ubuntu.sh || travis_terminate 1
+
+        - name: Ubuntu Bionic Build (ppc64le)
+          arch: ppc64le
+          language: bash
+          script: sudo $CI_ROOT/managers/ubuntu.sh || travis_terminate 1
+
+        - stage: Coverity
+          language: bash
+          env:
+              # Coverity configuration
+              # COVERITY_SCAN_TOKEN=xxx
+              # Encrypted using `travis encrypt --repo libbpf/libbpf COVERITY_SCAN_TOKEN=xxx`
+              - secure: "I9OsMRHbb82IUivDp+I+w/jEQFOJgBDAqYqf1ollqCM1QhocxMcS9bwIAgfPhdXi2hohV7sRrVMZstahY67FAvJLGxNopi4tAPDIAaIFxgO0yDxMhaTMx5xDfMwlIm2FOP/9gB9BQsd6M7CmoQZgXYwBIv7xd1ooxoQrh2rOK1YrRl7UQu3+c3zPTjDfIYZzR3bFttMqZ9/c4U0v8Ry5IFXrel3hCshndHA1TtttJrUSrILlZcmVc1ch7JIy6zCbCU/2lGv0B/7rWXfF8MT7O9jPtFOhJ1DEcd2zhw2n4j9YT3a8OhtnM61LA6ask632mwCOsxpFLTun7AzuR1Cb5mdPHsxhxnCHcXXARa2mJjem0QG1NhwxwJE8sbRDapojexxCvweYlEN40ofwMDSnj/qNt95XIcrk0tiIhGFx0gVNWvAdmZwx+N4mwGPMTAN0AEOFjpgI+ZdB89m+tL/CbEgE1flc8QxUxJhcp5OhH6yR0z9qYOp0nXIbHsIaCiRvt/7LqFRQfheifztWVz4mdQlCdKS9gcOQ09oKicPevKO1L0Ue3cb7Ug7jOpMs+cdh3XokJtUeYEr1NijMHT9+CTAhhO5RToWXIZRon719z3fwoUBNDREATwVFMlVxqSO/pbYgaKminigYbl785S89YYaZ6E5UvaKRHM6KHKMDszs="
+              - COVERITY_SCAN_PROJECT_NAME="libbpf"
+              - COVERITY_SCAN_NOTIFICATION_EMAIL="${AUTHOR_EMAIL}"
+              - COVERITY_SCAN_BRANCH_PATTERN="$TRAVIS_BRANCH"
+              # Note: `make -C src/` as a BUILD_COMMAND will not work here
+              - COVERITY_SCAN_BUILD_COMMAND_PREPEND="cd src/"
+              - COVERITY_SCAN_BUILD_COMMAND="make"
+          install:
+              - sudo echo 'deb-src http://archive.ubuntu.com/ubuntu/ bionic main restricted universe multiverse' >>/etc/apt/sources.list
+              - sudo apt-get update
+              - sudo apt-get -y build-dep libelf-dev
+              - sudo apt-get install -y libelf-dev pkg-config
+          script:
+              - scripts/coverity.sh || travis_terminate 1
+    allow_failures:
+        - env: KERNEL=x.x.x

BPF-CHECKPOINT-COMMIT

@@ -1 +1 @@
-b408473ea01b2e499d23503e2bf898416da9d7ac
+3fb1a96a91120877488071a167d26d76be4be977

CHECKPOINT-COMMIT

@@ -1 +1 @@
-2ad6d23f465a4f851e3bcf6d74c315ce7b2c205b
+06a4ec1d9dc652e17ee3ac2ceb6c7cf6c2b75cdd

LICENSE.BSD-2-Clause

@@ -7,7 +7,7 @@ Usage-Guide:
     SPDX-License-Identifier: BSD-2-Clause
 License-Text:
 
-Copyright (c) 2015 The Libbpf Authors. All rights reserved.
+Copyright (c) <year> <owner> . All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

README.md

@@ -1,44 +1,17 @@
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="assets/libbpf-logo-sideways-darkbg.png" width="40%">
-  <img src="assets/libbpf-logo-sideways.png" width="40%">
-</picture>
+This is a mirror of [bpf-next Linux source
+tree](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next)'s
+`tools/lib/bpf` directory plus its supporting header files.
 
-libbpf
-[![Github Actions Builds & Tests](https://github.com/libbpf/libbpf/actions/workflows/test.yml/badge.svg)](https://github.com/libbpf/libbpf/actions/workflows/test.yml)
-[![Coverity](https://img.shields.io/coverity/scan/18195.svg)](https://scan.coverity.com/projects/libbpf)
-[![CodeQL](https://github.com/libbpf/libbpf/workflows/CodeQL/badge.svg?branch=master)](https://github.com/libbpf/libbpf/actions?query=workflow%3ACodeQL+branch%3Amaster)
-[![OSS-Fuzz Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/libbpf.svg)](https://oss-fuzz-build-logs.storage.googleapis.com/index.html#libbpf)
-[![Read the Docs](https://readthedocs.org/projects/libbpf/badge/?version=latest)](https://libbpf.readthedocs.io/en/latest/)
-======
+All the gory details of syncing can be found in `scripts/sync-kernel.sh`
+script.
 
-**This is the official home of the libbpf library.**
+Some header files in this repo (`include/linux/*.h`) are reduced versions of
+their counterpart files at
+[bpf-next](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/)'s
+`tools/include/linux/*.h` to make compilation successful.
 
-*Please use this Github repository for building and packaging libbpf
-and when using it in your projects through Git submodule.*
-
-Libbpf *authoritative source code* is developed as part of [bpf-next Linux source
-tree](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next) under
-`tools/lib/bpf` subdirectory and is periodically synced to Github. As such, all the
-libbpf changes should be sent to [BPF mailing list](http://vger.kernel.org/vger-lists.html#bpf),
-please don't open PRs here unless you are changing Github-specific parts of libbpf
-(e.g., Github-specific Makefile).
-
-Libbpf and general BPF usage questions
-======================================
-
-Libbpf documentation can be found [here](https://libbpf.readthedocs.io/en/latest/api.html).
-It's an ongoing effort and has ways to go, but please take a look and consider contributing as well.
-
-Please check out [libbpf-bootstrap](https://github.com/libbpf/libbpf-bootstrap)
-and [the companion blog post](https://nakryiko.com/posts/libbpf-bootstrap/) for
-the examples of building BPF applications with libbpf.
-[libbpf-tools](https://github.com/iovisor/bcc/tree/master/libbpf-tools) are also
-a good source of the real-world libbpf-based tracing tools.
-
-See also ["BPF CO-RE reference guide"](https://nakryiko.com/posts/bpf-core-reference-guide/)
-for the coverage of practical aspects of building BPF CO-RE applications and
-["BPF CO-RE"](https://nakryiko.com/posts/bpf-portability-and-co-re/) for
-general introduction into BPF portability issues and BPF CO-RE origins.
+BPF questions
+=============
 
 All general BPF questions, including kernel functionality, libbpf APIs and
 their application, should be sent to bpf@vger.kernel.org mailing list. You can
@@ -52,8 +25,11 @@ to help you with whatever issue you have. This repository's PRs and issues
 should be opened only for dealing with issues pertaining to specific way this
 libbpf mirror repo is set up and organized.
 
-Building libbpf
-===============
+Build
+[![Build Status](https://travis-ci.org/libbpf/libbpf.svg?branch=master)](https://travis-ci.org/libbpf/libbpf)
+[![Total alerts](https://img.shields.io/lgtm/alerts/g/libbpf/libbpf.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/libbpf/libbpf/alerts/)
+[![Coverity](https://img.shields.io/coverity/scan/18195.svg)](https://scan.coverity.com/projects/libbpf)
+=====
 libelf is an internal dependency of libbpf and thus it is required to link
 against and must be installed on the system for applications to work.
 pkg-config is used by default to find libelf, and the program called can be
@@ -85,6 +61,32 @@ $ cd src
 $ PKG_CONFIG_PATH=/build/root/lib64/pkgconfig DESTDIR=/build/root make install
 ```
 
+Distributions
+=============
+
+Distributions packaging libbpf from this mirror:
+  - [Fedora](https://src.fedoraproject.org/rpms/libbpf)
+  - [Gentoo](https://packages.gentoo.org/packages/dev-libs/libbpf)
+  - [Debian](https://packages.debian.org/sid/libbpf-dev)
+  - [Arch](https://www.archlinux.org/packages/extra/x86_64/libbpf/)
+
+Benefits of packaging from the mirror over packaging from kernel sources:
+  - Consistent versioning across distributions.
+  - No ties to any specific kernel, transparent handling of older kernels.
+    Libbpf is designed to be kernel-agnostic and work across multitude of
+    kernel versions. It has built-in mechanisms to gracefully handle older
+    kernels, that are missing some of the features, by working around or
+    gracefully degrading functionality. Thus libbpf is not tied to a specific
+    kernel version and can/should be packaged and versioned independently.
+  - Continuous integration testing via
+    [TravisCI](https://travis-ci.org/libbpf/libbpf).
+  - Static code analysis via [LGTM](https://lgtm.com/projects/g/libbpf/libbpf)
+    and [Coverity](https://scan.coverity.com/projects/libbpf).
+
+Package dependencies of libbpf, package names may vary across distros:
+  - zlib
+  - libelf
+
 BPF CO-RE (Compile Once – Run Everywhere)
 =========================================
 
@@ -100,9 +102,6 @@ Some major Linux distributions come with kernel BTF already built in:
   - RHEL 8.2+
   - OpenSUSE Tumbleweed (in the next release, as of 2020-06-04)
   - Arch Linux (from kernel 5.7.1.arch1-1)
-  - Manjaro (from kernel 5.4 if compiled after 2021-06-18)
-  - Ubuntu 20.10
-  - Debian 11 (amd64/arm64)
 
 If your kernel doesn't come with BTF built-in, you'll need to build custom
 kernel. You'll need:
@@ -122,64 +121,18 @@ distributions have Clang/LLVM 10+ packaged by default:
   - Fedora 32+
   - Ubuntu 20.04+
   - Arch Linux
-  - Ubuntu 20.10 (LLVM 11)
-  - Debian 11 (LLVM 11)
-  - Alpine 3.13+
 
 Otherwise, please make sure to update it on your system.
 
 The following resources are useful to understand what BPF CO-RE is and how to
 use it:
-- [BPF CO-RE reference guide](https://nakryiko.com/posts/bpf-core-reference-guide/)
-- [BPF Portability and CO-RE](https://nakryiko.com/posts/bpf-portability-and-co-re/)
-- [HOWTO: BCC to libbpf conversion](https://nakryiko.com/posts/bcc-to-libbpf-howto-guide/)
+- [BPF Portability and CO-RE](https://facebookmicrosites.github.io/bpf/blog/2020/02/19/bpf-portability-and-co-re.html)
+- [HOWTO: BCC to libbpf conversion](https://facebookmicrosites.github.io/bpf/blog/2020/02/20/bcc-to-libbpf-howto-guide.html)
 - [libbpf-tools in BCC repo](https://github.com/iovisor/bcc/tree/master/libbpf-tools)
   contain lots of real-world tools converted from BCC to BPF CO-RE. Consider
   converting some more to both contribute to the BPF community and gain some
   more experience with it.
 
-Distributions
-=============
-
-Distributions packaging libbpf from this mirror:
-  - [Fedora](https://src.fedoraproject.org/rpms/libbpf)
-  - [Gentoo](https://packages.gentoo.org/packages/dev-libs/libbpf)
-  - [Debian](https://packages.debian.org/source/sid/libbpf)
-  - [Arch](https://archlinux.org/packages/core/x86_64/libbpf/)
-  - [Ubuntu](https://packages.ubuntu.com/source/jammy/libbpf)
-  - [Alpine](https://pkgs.alpinelinux.org/packages?name=libbpf)
-
-Benefits of packaging from the mirror over packaging from kernel sources:
-  - Consistent versioning across distributions.
-  - No ties to any specific kernel, transparent handling of older kernels.
-    Libbpf is designed to be kernel-agnostic and work across multitude of
-    kernel versions. It has built-in mechanisms to gracefully handle older
-    kernels, that are missing some of the features, by working around or
-    gracefully degrading functionality. Thus libbpf is not tied to a specific
-    kernel version and can/should be packaged and versioned independently.
-  - Continuous integration testing via
-    [GitHub Actions](https://github.com/libbpf/libbpf/actions).
-  - Static code analysis via [LGTM](https://lgtm.com/projects/g/libbpf/libbpf)
-    and [Coverity](https://scan.coverity.com/projects/libbpf).
-
-Package dependencies of libbpf, package names may vary across distros:
-  - zlib
-  - libelf
-
-[![libbpf distro packaging status](https://repology.org/badge/vertical-allrepos/libbpf.svg)](https://repology.org/project/libbpf/versions)
-
-
-bpf-next to Github sync
-=======================
-
-All the gory details of syncing can be found in `scripts/sync-kernel.sh`
-script. See [SYNC.md](SYNC.md) for instruction.
-
-Some header files in this repo (`include/linux/*.h`) are reduced versions of
-their counterpart files at
-[bpf-next](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/)'s
-`tools/include/linux/*.h` to make compilation successful.
-
 License
 =======
 

SYNC.md

@@ -1,281 +0,0 @@
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="assets/libbpf-logo-sideways-darkbg.png" width="40%">
-  <img src="assets/libbpf-logo-sideways.png" width="40%">
-</picture>
-
-Libbpf sync
-===========
-
-Libbpf *authoritative source code* is developed as part of [bpf-next Linux source
-tree](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next) under
-`tools/lib/bpf` subdirectory and is periodically synced to Github.
-
-Most of the mundane mechanical things like bpf and bpf-next tree merge, Git
-history transformation, cherry-picking relevant commits, re-generating
-auto-generated headers, etc. are taken care by
-[sync-kernel.sh script](https://github.com/libbpf/libbpf/blob/master/scripts/sync-kernel.sh).
-But occasionally human needs to do few extra things to make everything work
-nicely.
-
-This document goes over the process of syncing libbpf sources from Linux repo
-to this Github repository. Feel free to contribute fixes and additions if you
-run into new problems not outlined here.
-
-Setup expectations
-------------------
-
-Sync script has particular expectation of upstream Linux repo setup. It
-expects that current HEAD of that repo points to bpf-next's master branch and
-that there is a separate local branch pointing to bpf tree's master branch.
-This is important, as the script will automatically merge their histories for
-the purpose of libbpf sync.
-
-Below, we assume that Linux repo is located at `~/linux`, it's current head is
-at latest `bpf-next/master`, and libbpf's Github repo is located at
-`~/libbpf`, checked out to latest commit on `master` branch. It doesn't matter
-from where to run `sync-kernel.sh` script, but we'll be running it from inside
-`~/libbpf`.
-
-```
-$ cd ~/linux && git remote -v | grep -E '^(bpf|bpf-next)'
-bpf     https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf.git (fetch)
-bpf     ssh://git@gitolite.kernel.org/pub/scm/linux/kernel/git/bpf/bpf.git
-(push)
-bpf-next
-https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git (fetch)
-bpf-next
-ssh://git@gitolite.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git (push)
-$ git branch -vv | grep -E '^? (master|bpf-master)'
-* bpf-master                               2d311f480b52 [bpf/master] riscv, bpf: Fix patch_text implicit declaration
-  master                                   c8ee37bde402 [bpf-next/master] libbpf: Fix bpf_xdp_query() in old kernels
-$ git checkout bpf-master && git pull && git checkout master && git pull
-...
-$ git log --oneline -n1
-c8ee37bde402 (HEAD -> master, bpf-next/master) libbpf: Fix bpf_xdp_query() in old kernels
-$ cd ~/libbpf && git checkout master && git pull
-Your branch is up to date with 'libbpf/master'.
-Already up to date.
-```
-
-Running setup script
---------------------
-
-First step is to always run `sync-kernel.sh` script. It expects three arguments:
-
-```
-$ scripts/sync-kernel.sh <libbpf-repo> <kernel-repo> <bpf-branch>
-```
-
-Note, that we'll store script's entire output in `/tmp/libbpf-sync.txt` and
-put it into PR summary later on. **Please store scripts output and include it
-in PR summary for others to check for anything unexpected and suspicious.**
-
-```
-$ scripts/sync-kernel.sh ~/libbpf ~/linux bpf-master | tee /tmp/libbpf-sync.txt
-Dumping existing libbpf commit signatures...
-WORKDIR:          /home/andriin/libbpf
-LINUX REPO:       /home/andriin/linux
-LIBBPF REPO:      /home/andriin/libbpf
-...
-```
-
-Most of the time this will go very uneventful. One expected case when sync
-script might require user intervention is if `bpf` tree has some libbpf fixes,
-which is nowadays not a very frequent occurence. But if that happens, script
-will show you a diff between expected state as of latest bpf-next and synced
-Github repo state. And will ask if these changes look good. Please use your
-best judgement to verify that differences are indeed from expected `bpf` tree
-fixes. E.g., it might look like below:
-
-```
-Comparing list of files...
-Comparing file contents...
---- /home/andriin/linux/include/uapi/linux/netdev.h     2023-02-27 16:54:42.270583372 -0800
-+++ /home/andriin/libbpf/include/uapi/linux/netdev.h    2023-02-27 16:54:34.615530796 -0800
-@@ -19,7 +19,7 @@
-  * @NETDEV_XDP_ACT_XSK_ZEROCOPY: This feature informs if netdev supports AF_XDP
-  *   in zero copy mode.
-  * @NETDEV_XDP_ACT_HW_OFFLOAD: This feature informs if netdev supports XDP hw
-- *   oflloading.
-+ *   offloading.
-  * @NETDEV_XDP_ACT_RX_SG: This feature informs if netdev implements non-linear
-  *   XDP buffer support in the driver napi callback.
-  * @NETDEV_XDP_ACT_NDO_XMIT_SG: This feature informs if netdev implements
-/home/andriin/linux/include/uapi/linux/netdev.h and /home/andriin/libbpf/include/uapi/linux/netdev.h are different!
-Unfortunately, there are some inconsistencies, please double check.
-Does everything look good? [y/N]:
-```
-
-If it looks sensible and expected, type `y` and script will proceed.
-
-If sync is successful, your `~/linux` repo will be left in original state on
-the original HEAD commit. `~/libbpf` repo will now be on a new branch, named
-`libbpf-sync-<timestamp>` (e.g., `libbpf-sync-2023-02-28T00-53-40.072Z`).
-
-Push this branch into your fork of `libbpf/libbpf` Github repo and create a PR:
-
-```
-$ git push --set-upstream origin libbpf-sync-2023-02-28T00-53-40.072Z
-Enumerating objects: 130, done.
-Counting objects: 100% (115/115), done.
-Delta compression using up to 80 threads
-Compressing objects: 100% (28/28), done.
-Writing objects: 100% (32/32), 5.57 KiB | 1.86 MiB/s, done.
-Total 32 (delta 21), reused 0 (delta 0), pack-reused 0
-remote: Resolving deltas: 100% (21/21), completed with 9 local objects.
-remote:
-remote: Create a pull request for 'libbpf-sync-2023-02-28T00-53-40.072Z' on GitHub by visiting:
-remote:      https://github.com/anakryiko/libbpf/pull/new/libbpf-sync-2023-02-28T00-53-40.072Z
-remote:
-To github.com:anakryiko/libbpf.git
- * [new branch]                libbpf-sync-2023-02-28T00-53-40.072Z -> libbpf-sync-2023-02-28T00-53-40.072Z
-Branch 'libbpf-sync-2023-02-28T00-53-40.072Z' set up to track remote branch 'libbpf-sync-2023-02-28T00-53-40.072Z' from 'origin'.
-```
-
-**Please, adjust PR name to have a properly looking timestamp. Libbpf
-maintainers will be very thankful for that!**
-
-By default Github will turn above branch name into PR with subject "Libbpf sync
-2023 02 28 t00 53 40.072 z". Please fix this into a proper timestamp, e.g.:
-"Libbpf sync 2023-02-28T00:53:40.072Z". Thank you!
-
-**Please don't forget to paste contents of /tmp/libbpf-sync.txt into PR
-summary!**
-
-Once PR is created, libbpf CI will run a bunch of tests to check that
-everything is good. In simple cases that would be all you'd need to do. In more
-complicated cases some extra adjustments might be necessary.
-
-**Please, keep naming and style consistent.** Prefix CI-related fixes with `ci: `
-prefix. If you had to modify sync script, prefix it with `sync: `. Also make
-sure that each such commit has `Signed-off-by: Your Full Name <your@email.com>`,
-just like you'd do that for Linux upstream patch. Libbpf closely follows kernel
-conventions and styling, so please help maintaining that.
-
-Including new sources
----------------------
-
-If entirely new source files (typically `*.c`) were added to the library in the
-kernel repository, it may be necessary to add these to the build system
-manually (you may notice linker errors otherwise), because the script cannot
-handle such changes automatically. To that end, edit `src/Makefile` as
-necessary. Commit
-[c2495832ced4](https://github.com/libbpf/libbpf/commit/c2495832ced4239bcd376b9954db38a6addd89ca)
-is an example of how to go about doing that.
-
-Similarly, if new public API header files were added, the `Makefile` will need
-to be adjusted as well.
-
-Updating allow/deny lists
--------------------------
-
-Libbpf CI intentionally runs a subset of latest BPF selftests on old kernel
-(4.9 and 5.5, currently). It happens from time to time that some tests that
-previously were successfully running on old kernels now don't, typically due to
-reliance on some freshly added kernel feature. It might look something like this in [CI logs](https://github.com/libbpf/libbpf/actions/runs/4206303272/jobs/7299609578#step:4:2733):
-
-```
-  All error logs:
-  serial_test_xdp_info:FAIL:get_xdp_none errno=2
-  #283     xdp_info:FAIL
-  Summary: 49/166 PASSED, 5 SKIPPED, 1 FAILED
-```
-
-In such case we can either work with upstream to fix test to be compatible with
-old kernels, or we'll have to add a test into a denylist (or remove it from
-allowlist, like was [done](https://github.com/libbpf/libbpf/commit/ea284299025bf85b85b4923191de6463cd43ccd6)
-for the case above).
-
-```
-$ find . -name '*LIST*'
-./ci/vmtest/configs/ALLOWLIST-4.9.0
-./ci/vmtest/configs/DENYLIST-5.5.0
-./ci/vmtest/configs/DENYLIST-latest.s390x
-./ci/vmtest/configs/DENYLIST-latest
-./ci/vmtest/configs/ALLOWLIST-5.5.0
-```
-
-Please determine which tests need to be added/removed from which list. And then
-add that as a separate commit. **Please keep using the same branch name, so
-that the same PR can be updated.** There is no need to open new PRs for each
-such fix.
-
-Regenerating vmlinux.h header
------------------------------
-
-To compile latest BPF selftests against old kernels, we check in pre-generated
-[vmlinux.h](https://github.com/libbpf/libbpf/blob/master/.github/actions/build-selftests/vmlinux.h)
-header file, located at `.github/actions/build-selftests/vmlinux.h`, which
-contains type definitions from latest upstream kernel. When after libbpf sync
-upstream BPF selftests require new kernel types, we'd need to regenerate
-`vmlinux.h` and check it in as well.
-
-This will looks something like this in [CI logs](https://github.com/libbpf/libbpf/actions/runs/4198939244/jobs/7283214243#step:4:1903):
-
-```
-  In file included from progs/test_spin_lock_fail.c:5:
-  /home/runner/work/libbpf/libbpf/.kernel/tools/testing/selftests/bpf/bpf_experimental.h:73:53: error: declaration of 'struct bpf_rb_root' will not be visible outside of this function [-Werror,-Wvisibility]
-  extern struct bpf_rb_node *bpf_rbtree_remove(struct bpf_rb_root *root,
-                                                      ^
-  /home/runner/work/libbpf/libbpf/.kernel/tools/testing/selftests/bpf/bpf_experimental.h:81:35: error: declaration of 'struct bpf_rb_root' will not be visible outside of this function [-Werror,-Wvisibility]
-  extern void bpf_rbtree_add(struct bpf_rb_root *root, struct bpf_rb_node *node,
-                                    ^
-  /home/runner/work/libbpf/libbpf/.kernel/tools/testing/selftests/bpf/bpf_experimental.h:90:52: error: declaration of 'struct bpf_rb_root' will not be visible outside of this function [-Werror,-Wvisibility]
-  extern struct bpf_rb_node *bpf_rbtree_first(struct bpf_rb_root *root) __ksym;
-                                                     ^
-  3 errors generated.
-  make: *** [Makefile:572: /home/runner/work/libbpf/libbpf/.kernel/tools/testing/selftests/bpf/test_spin_lock_fail.bpf.o] Error 1
-  make: *** Waiting for unfinished jobs....
-  Error: Process completed with exit code 2.
-```
-
-You'll need to build latest upstream kernel from `bpf-next` tree, using BPF
-selftest configs. Concat arch-agnostic and arch-specific configs, build kernel,
-then use bpftool to dump `vmlinux.h`:
-
-```
-$ cd ~/linux
-$ cat tools/testing/selftests/bpf/config \
-   tools/testing/selftests/bpf/config.x86_64 > .config
-$ make -j$(nproc) olddefconfig all
-...
-$ bpftool btf dump file ~/linux/vmlinux format c > ~/libbpf/.github/actions/build-selftests/vmlinux.h
-$ cd ~/libbpf && git add . && git commit -s
-```
-
-Check in generated `vmlinux.h`, don't forget to use `ci: ` commit prefix, add
-it on top of sync commits. Push to Github and let libbpf CI do the checking for
-you. See [this commit](https://github.com/libbpf/libbpf/commit/34212c94a64df8eeb1dd5d064630a65e1dfd4c20)
-for reference.
-
-Troubleshooting
----------------
-
-If something goes wrong and sync script exits early or is terminated early by
-user, you might end up with `~/linux` repo on temporary sync-related branch.
-Don't worry, though, sync script never destroys repo state, it follows
-"copy-on-write" philosophy and creates new branches where necessary. So it's
-very easy to restore previous state. So if anything goes wrong, it's easy to
-start fresh:
-
-```
-$ git branch | grep -E 'libbpf-.*Z'
-  libbpf-baseline-2023-02-28T00-43-35.146Z
-  libbpf-bpf-baseline-2023-02-28T00-43-35.146Z
-  libbpf-bpf-tip-2023-02-28T00-43-35.146Z
-  libbpf-squash-base-2023-02-28T00-43-35.146Z
-* libbpf-squash-tip-2023-02-28T00-43-35.146Z
-$ git cherry-pick --abort
-$ git checkout master && git branch | grep -E 'libbpf-.*Z' | xargs git br -D
-Switched to branch 'master'
-Your branch is up to date with 'bpf-next/master'.
-Deleted branch libbpf-baseline-2023-02-28T00-43-35.146Z (was 951bce29c898).
-Deleted branch libbpf-bpf-baseline-2023-02-28T00-43-35.146Z (was 3a70e0d4c9d7).
-Deleted branch libbpf-bpf-tip-2023-02-28T00-43-35.146Z (was 2d311f480b52).
-Deleted branch libbpf-squash-base-2023-02-28T00-43-35.146Z (was 957f109ef883).
-Deleted branch libbpf-squash-tip-2023-02-28T00-43-35.146Z (was be66130d2339).
-Deleted branch libbpf-tip-2023-02-28T00-43-35.146Z (was 2d311f480b52).
-```
-
-You might need to do the same for your `~/libbpf` repo sometimes, depending at
-which stage sync script was terminated.

ci/diffs/0001-arch-Kconfig-Move-SPECULATION_MITIGATIONS-to-arch-Kc.patch

@@ -1,69 +0,0 @@
-From c71766e8ff7a7f950522d25896fba758585500df Mon Sep 17 00:00:00 2001
-From: Song Liu <song@kernel.org>
-Date: Mon, 22 Apr 2024 21:14:40 -0700
-Subject: [PATCH] arch/Kconfig: Move SPECULATION_MITIGATIONS to arch/Kconfig
-
-SPECULATION_MITIGATIONS is currently defined only for x86. As a result,
-IS_ENABLED(CONFIG_SPECULATION_MITIGATIONS) is always false for other
-archs. f337a6a21e2f effectively set "mitigations=off" by default on
-non-x86 archs, which is not desired behavior. Jakub observed this
-change when running bpf selftests on s390 and arm64.
-
-Fix this by moving SPECULATION_MITIGATIONS to arch/Kconfig so that it is
-available in all archs and thus can be used safely in kernel/cpu.c
-
-Fixes: f337a6a21e2f ("x86/cpu: Actually turn off mitigations by default for SPECULATION_MITIGATIONS=n")
-Cc: stable@vger.kernel.org
-Cc: Sean Christopherson <seanjc@google.com>
-Cc: Ingo Molnar <mingo@kernel.org>
-Cc: Daniel Sneddon <daniel.sneddon@linux.intel.com>
-Cc: Jakub Kicinski <kuba@kernel.org>
-Signed-off-by: Song Liu <song@kernel.org>
----
- arch/Kconfig     | 10 ++++++++++
- arch/x86/Kconfig | 10 ----------
- 2 files changed, 10 insertions(+), 10 deletions(-)
-
-diff --git a/arch/Kconfig b/arch/Kconfig
-index 9f066785bb71..8f4af75005f8 100644
---- a/arch/Kconfig
-+++ b/arch/Kconfig
-@@ -1609,4 +1609,14 @@ config CC_HAS_SANE_FUNCTION_ALIGNMENT
- 	# strict alignment always, even with -falign-functions.
- 	def_bool CC_HAS_MIN_FUNCTION_ALIGNMENT || CC_IS_CLANG
- 
-+menuconfig SPECULATION_MITIGATIONS
-+	bool "Mitigations for speculative execution vulnerabilities"
-+	default y
-+	help
-+	  Say Y here to enable options which enable mitigations for
-+	  speculative execution hardware vulnerabilities.
-+
-+	  If you say N, all mitigations will be disabled. You really
-+	  should know what you are doing to say so.
-+
- endmenu
-diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
-index 39886bab943a..50c890fce5e0 100644
---- a/arch/x86/Kconfig
-+++ b/arch/x86/Kconfig
-@@ -2486,16 +2486,6 @@ config PREFIX_SYMBOLS
- 	def_bool y
- 	depends on CALL_PADDING && !CFI_CLANG
- 
--menuconfig SPECULATION_MITIGATIONS
--	bool "Mitigations for speculative execution vulnerabilities"
--	default y
--	help
--	  Say Y here to enable options which enable mitigations for
--	  speculative execution hardware vulnerabilities.
--
--	  If you say N, all mitigations will be disabled. You really
--	  should know what you are doing to say so.
--
- if SPECULATION_MITIGATIONS
- 
- config MITIGATION_PAGE_TABLE_ISOLATION
--- 
-2.43.0
-

ci/diffs/0001-selftests-bpf-fix-inet_csk_accept-prototype-in-test_.patch

@@ -1,32 +0,0 @@
-From 0daad0a615e687e1247230f3d0c31ae60ba32314 Mon Sep 17 00:00:00 2001
-From: Andrii Nakryiko <andrii@kernel.org>
-Date: Tue, 28 May 2024 15:29:38 -0700
-Subject: [PATCH bpf-next] selftests/bpf: fix inet_csk_accept prototype in
- test_sk_storage_tracing.c
-
-Recent kernel change ([0]) changed inet_csk_accept() prototype. Adapt
-progs/test_sk_storage_tracing.c to take that into account.
-
-  [0] 92ef0fd55ac8 ("net: change proto and proto_ops accept type")
-
-Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
----
- tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c b/tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c
-index 02e718f06e0f..40531e56776e 100644
---- a/tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c
-+++ b/tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c
-@@ -84,7 +84,7 @@ int BPF_PROG(trace_tcp_connect, struct sock *sk)
- }
- 
- SEC("fexit/inet_csk_accept")
--int BPF_PROG(inet_csk_accept, struct sock *sk, int flags, int *err, bool kern,
-+int BPF_PROG(inet_csk_accept, struct sock *sk, struct proto_accept_arg *arg,
- 	     struct sock *accepted_sk)
- {
- 	set_task_info(accepted_sk);
--- 
-2.43.0
-

ci/diffs/0002-xdp-bonding-Fix-feature-flags-when-there-are-no-slav.patch

@@ -1,56 +0,0 @@
-From f267f262815033452195f46c43b572159262f533 Mon Sep 17 00:00:00 2001
-From: Daniel Borkmann <daniel@iogearbox.net>
-Date: Tue, 5 Mar 2024 10:08:28 +0100
-Subject: [PATCH 2/2] xdp, bonding: Fix feature flags when there are no slave
- devs anymore
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-Commit 9b0ed890ac2a ("bonding: do not report NETDEV_XDP_ACT_XSK_ZEROCOPY")
-changed the driver from reporting everything as supported before a device
-was bonded into having the driver report that no XDP feature is supported
-until a real device is bonded as it seems to be more truthful given
-eventually real underlying devices decide what XDP features are supported.
-
-The change however did not take into account when all slave devices get
-removed from the bond device. In this case after 9b0ed890ac2a, the driver
-keeps reporting a feature mask of 0x77, that is, NETDEV_XDP_ACT_MASK &
-~NETDEV_XDP_ACT_XSK_ZEROCOPY whereas it should have reported a feature
-mask of 0.
-
-Fix it by resetting XDP feature flags in the same way as if no XDP program
-is attached to the bond device. This was uncovered by the XDP bond selftest
-which let BPF CI fail. After adjusting the starting masks on the latter
-to 0 instead of NETDEV_XDP_ACT_MASK the test passes again together with
-this fix.
-
-Fixes: 9b0ed890ac2a ("bonding: do not report NETDEV_XDP_ACT_XSK_ZEROCOPY")
-Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
-Cc: Magnus Karlsson <magnus.karlsson@intel.com>
-Cc: Prashant Batra <prbatra.mail@gmail.com>
-Cc: Toke Høiland-Jørgensen <toke@redhat.com>
-Cc: Jakub Kicinski <kuba@kernel.org>
-Reviewed-by: Toke Høiland-Jørgensen <toke@redhat.com>
-Message-ID: <20240305090829.17131-1-daniel@iogearbox.net>
-Signed-off-by: Alexei Starovoitov <ast@kernel.org>
----
- drivers/net/bonding/bond_main.c | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
-index a11748b8d69b..cd0683bcca03 100644
---- a/drivers/net/bonding/bond_main.c
-+++ b/drivers/net/bonding/bond_main.c
-@@ -1811,7 +1811,7 @@ void bond_xdp_set_features(struct net_device *bond_dev)
- 
- 	ASSERT_RTNL();
- 
--	if (!bond_xdp_check(bond)) {
-+	if (!bond_xdp_check(bond) || !bond_has_slaves(bond)) {
- 		xdp_clear_features_flag(bond_dev);
- 		return;
- 	}
--- 
-2.43.0
-

ci/managers/test_compile.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-set -euox pipefail
-
-EXTRA_CFLAGS=${EXTRA_CFLAGS:-}
-EXTRA_LDFLAGS=${EXTRA_LDFLAGS:-}
-
-cat << EOF > main.c
-#include <bpf/libbpf.h>
-int main() {
-  return bpf_object__open(0) < 0;
-}
-EOF
-
-# static linking
-${CC:-cc} ${EXTRA_CFLAGS} ${EXTRA_LDFLAGS} -o main -I./include/uapi -I./install/usr/include main.c ./build/libbpf.a -lelf -lz

ci/managers/ubuntu.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-set -eux
-
-RELEASE="focal"
-
-apt-get update
-apt-get install -y pkg-config
-
-source "$(dirname $0)/travis_wait.bash"
-
-cd $REPO_ROOT
-
-EXTRA_CFLAGS="-Werror -Wall -fsanitize=address,undefined"
-EXTRA_LDFLAGS="-Werror -Wall -fsanitize=address,undefined"
-mkdir build install
-cc --version
-make -j$((4*$(nproc))) EXTRA_CFLAGS="${EXTRA_CFLAGS}" EXTRA_LDFLAGS="${EXTRA_LDFLAGS}" -C ./src -B OBJDIR=../build
-ldd build/libbpf.so
-if ! ldd build/libbpf.so | grep -q libelf; then
-    echo "FAIL: No reference to libelf.so in libbpf.so!"
-    exit 1
-fi
-make -j$((4*$(nproc))) -C src OBJDIR=../build DESTDIR=../install install
-EXTRA_CFLAGS=${EXTRA_CFLAGS} EXTRA_LDFLAGS=${EXTRA_LDFLAGS} $(dirname $0)/test_compile.sh

ci/vmtest/configs/ALLOWLIST-4.9.0

@@ -1,8 +0,0 @@
-# btf_dump -- need to disable data dump sub-tests
-core_retro
-cpu_mask
-hashmap
-legacy_printk
-perf_buffer
-section_names
-

ci/vmtest/configs/ALLOWLIST-5.5.0

@@ -1,49 +0,0 @@
-# attach_probe
-autoload
-bpf_verif_scale
-cgroup_attach_autodetach
-cgroup_attach_override
-core_autosize
-core_extern
-core_read_macros
-core_reloc
-core_retro
-cpu_mask
-endian
-get_branch_snapshot
-get_stackid_cannot_attach
-global_data
-global_data_init
-global_func_args
-hashmap
-legacy_printk
-linked_funcs
-linked_maps
-map_lock
-obj_name
-perf_buffer
-perf_event_stackmap
-pinning
-pkt_md_access
-probe_user
-queue_stack_map
-raw_tp_writable_reject_nbd_invalid
-raw_tp_writable_test_run
-rdonly_maps
-section_names
-signal_pending
-sockmap_ktls
-spinlock
-stacktrace_map
-stacktrace_map_raw_tp
-static_linked
-task_fd_query_rawtp
-task_fd_query_tp
-tc_bpf
-tcp_estats
-test_global_funcs/arg_tag_ctx*
-tp_attach_query
-usdt/urand_pid_attach
-xdp
-xdp_noinline
-xdp_perf

ci/vmtest/configs/DENYLIST

@@ -1,15 +0,0 @@
-# TEMPORARY
-btf_dump/btf_dump: syntax
-kprobe_multi_bench_attach
-core_reloc/enum64val
-core_reloc/size___diff_sz
-core_reloc/type_based___diff_sz
-test_ima	# All of CI is broken on it following 6.3-rc1 merge
-
-lwt_reroute      # crashes kernel after netnext merge from 2ab1efad60ad "net/sched: cls_api: complement tcf_tfilter_dump_policy"
-tc_links_ingress # started failing after net-next merge from 2ab1efad60ad "net/sched: cls_api: complement tcf_tfilter_dump_policy"
-xdp_bonding/xdp_bonding_features     # started failing after net merge from 359e54a93ab4 "l2tp: pass correct message length to ip6_append_data"
-tc_redirect/tc_redirect_dtime # uapi breakage after net-next commit 885c36e59f46 ("net: Re-use and set mono_delivery_time bit for userspace tstamp packets")
-migrate_reuseport/IPv4 TCP_NEW_SYN_RECV reqsk_timer_handler # flaky, under investigation
-migrate_reuseport/IPv6 TCP_NEW_SYN_RECV reqsk_timer_handler # flaky, under investigation
-verify_pkcs7_sig # keeps failing

ci/vmtest/configs/DENYLIST-5.5.0

@@ -1,5 +0,0 @@
-# This complements ALLOWLIST-5.5.0 but excludes subtest that can't work on 5.5
-
-btf			# "size check test", "func (Non zero vlen)"
-tailcalls		# tailcall_bpf2bpf_1, tailcall_bpf2bpf_2, tailcall_bpf2bpf_3
-tc_bpf/tc_bpf_non_root

ci/vmtest/configs/DENYLIST-latest

@@ -1,13 +0,0 @@
-decap_sanity  # weird failure with decap_sanity_ns netns already existing, TBD
-empty_skb # waiting the fix in bpf tree to make it to bpf-next
-bpf_nf/tc-bpf-ct # test consistently failing on x86: https://github.com/libbpf/libbpf/pull/698#issuecomment-1590341200
-bpf_nf/xdp-ct   # test consistently failing on x86: https://github.com/libbpf/libbpf/pull/698#issuecomment-1590341200
-kprobe_multi_bench_attach # suspected to cause crashes in CI
-find_vma # test consistently fails on latest kernel, see https://github.com/libbpf/libbpf/issues/754 for details
-bpf_cookie/perf_event
-send_signal/send_signal_nmi
-send_signal/send_signal_nmi_thread
-
-lwt_reroute # crashes kernel, fix pending upstream
-tc_links_ingress # fails, same fix is pending upstream
-tc_redirect		  # enough is enough, banned for life for flakiness

ci/vmtest/configs/DENYLIST-latest.s390x

@@ -1,17 +0,0 @@
-# TEMPORARY
-sockmap_listen/sockhash VSOCK test_vsock_redir
-usdt/basic                               # failing verifier due to bounds check after LLVM update
-usdt/multispec                           # same as above
-
-deny_namespace                           # not yet in bpf denylist
-tc_redirect/tc_redirect_dtime            # very flaky
-lru_bug                                  # not yet in bpf-next denylist
-
-# Disabled temporarily for a crash.
-# https://lore.kernel.org/bpf/c9923c1d-971d-4022-8dc8-1364e929d34c@gmail.com/
-dummy_st_ops/dummy_init_ptr_arg
-fexit_bpf2bpf
-tailcalls
-trace_ext
-xdp_bpf2bpf
-xdp_metadata

ci/vmtest/helpers.sh

@@ -1,38 +0,0 @@
-# shellcheck shell=bash
-
-# $1 - start or end
-# $2 - fold identifier, no spaces
-# $3 - fold section description
-foldable() {
-  local YELLOW='\033[1;33m'
-  local NOCOLOR='\033[0m'
-  if [ $1 = "start" ]; then
-    line="::group::$2"
-    if [ ! -z "${3:-}" ]; then
-      line="$line - ${YELLOW}$3${NOCOLOR}"
-    fi
-  else
-    line="::endgroup::"
-  fi
-  echo -e "$line"
-}
-
-__print() {
-  local TITLE=""
-  if [[ -n $2 ]]; then
-      TITLE=" title=$2"
-  fi
-  echo "::$1${TITLE}::$3"
-}
-
-# $1 - title
-# $2 - message
-print_error() {
-  __print error $1 $2
-}
-
-# $1 - title
-# $2 - message
-print_notice() {
-  __print notice $1 $2
-}

ci/vmtest/run_selftests.sh

@@ -1,96 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-
-source $(cd $(dirname $0) && pwd)/helpers.sh
-
-ARCH=$(uname -m)
-
-STATUS_FILE=/exitstatus
-
-read_lists() {
-	(for path in "$@"; do
-		if [[ -s "$path" ]]; then
-			cat "$path"
-		fi;
-	done) | cut -d'#' -f1 | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' | tr -s '\n' ','
-}
-
-test_progs() {
-	if [[ "${KERNEL}" != '4.9.0' ]]; then
-		foldable start test_progs "Testing test_progs"
-		# "&& true" does not change the return code (it is not executed
-		# if the Python script fails), but it prevents exiting on a
-		# failure due to the "set -e".
-		./test_progs ${DENYLIST:+-d"$DENYLIST"} ${ALLOWLIST:+-a"$ALLOWLIST"} && true
-		echo "test_progs:$?" >> "${STATUS_FILE}"
-		foldable end test_progs
-	fi
-}
-
-test_progs_no_alu32() {
-	foldable start test_progs-no_alu32 "Testing test_progs-no_alu32"
-	./test_progs-no_alu32 ${DENYLIST:+-d"$DENYLIST"} ${ALLOWLIST:+-a"$ALLOWLIST"} && true
-	echo "test_progs-no_alu32:$?" >> "${STATUS_FILE}"
-	foldable end test_progs-no_alu32
-}
-
-test_maps() {
-	if [[ "${KERNEL}" == 'latest' ]]; then
-		foldable start test_maps "Testing test_maps"
-		./test_maps && true
-		echo "test_maps:$?" >> "${STATUS_FILE}"
-		foldable end test_maps
-	fi
-}
-
-test_verifier() {
-	if [[ "${KERNEL}" == 'latest' ]]; then
-		foldable start test_verifier "Testing test_verifier"
-		./test_verifier && true
-		echo "test_verifier:$?" >> "${STATUS_FILE}"
-		foldable end test_verifier
-	fi
-}
-
-foldable end vm_init
-
-foldable start kernel_config "Kconfig"
-
-zcat /proc/config.gz
-
-foldable end kernel_config
-
-
-configs_path=/${PROJECT_NAME}/selftests/bpf
-local_configs_path=${PROJECT_NAME}/vmtest/configs
-DENYLIST=$(read_lists \
-	"$configs_path/DENYLIST" \
-	"$configs_path/DENYLIST.${ARCH}" \
-	"$local_configs_path/DENYLIST" \
-	"$local_configs_path/DENYLIST-${KERNEL}" \
-	"$local_configs_path/DENYLIST-${KERNEL}.${ARCH}" \
-)
-ALLOWLIST=$(read_lists \
-	"$configs_path/ALLOWLIST" \
-	"$configs_path/ALLOWLIST.${ARCH}" \
-	"$local_configs_path/ALLOWLIST" \
-	"$local_configs_path/ALLOWLIST-${KERNEL}" \
-	"$local_configs_path/ALLOWLIST-${KERNEL}.${ARCH}" \
-)
-
-echo "DENYLIST: ${DENYLIST}"
-echo "ALLOWLIST: ${ALLOWLIST}"
-
-cd ${PROJECT_NAME}/selftests/bpf
-
-if [ $# -eq 0 ]; then
-	test_progs
-	test_progs_no_alu32
-	# test_maps
-	test_verifier
-else
-	for test_name in "$@"; do
-		"${test_name}"
-	done
-fi

docs/.gitignore

@@ -1,2 +0,0 @@
-sphinx/build
-sphinx/doxygen/build

docs/api.rst

@@ -1,93 +0,0 @@
-.. SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
-
-.. _api:
-
-.. toctree:: Table of Contents
-
-
-LIBBPF API
-==========
-
-Error Handling
---------------
-
-When libbpf is used in "libbpf 1.0 mode", API functions can return errors in one of two ways.
-
-You can set "libbpf 1.0" mode with the following line:
-
-.. code-block::
-
-    libbpf_set_strict_mode(LIBBPF_STRICT_DIRECT_ERRS | LIBBPF_STRICT_CLEAN_PTRS);
-
-If the function returns an error code directly, it uses 0 to indicate success
-and a negative error code to indicate what caused the error. In this case the
-error code should be checked directly from the return, you do not need to check
-errno.
-
-For example:
-
-.. code-block::
-
-    err = some_libbpf_api_with_error_return(...);
-    if (err < 0) {
-        /* Handle error accordingly */
-    }
-
-If the function returns a pointer, it will return NULL to indicate there was
-an error. In this case errno should be checked for the error code.
-
-For example:
-
-.. code-block::
-
-    ptr = some_libbpf_api_returning_ptr();
-    if (!ptr) {
-        /* note no minus sign for EINVAL and E2BIG below */
-        if (errno == EINVAL) {
-           /* handle EINVAL error */
-        } else if (errno == E2BIG) {
-           /* handle E2BIG error */
-        }
-    }
-
-libbpf.h
---------
-.. doxygenfile:: libbpf.h
-   :project: libbpf
-   :sections: func define public-type enum
-
-bpf.h
------
-.. doxygenfile:: bpf.h
-   :project: libbpf
-   :sections: func define public-type enum
-
-btf.h
------
-.. doxygenfile:: btf.h
-   :project: libbpf
-   :sections: func define public-type enum
-
-xsk.h
------
-.. doxygenfile:: xsk.h
-   :project: libbpf
-   :sections: func define public-type enum
-
-bpf_tracing.h
--------------
-.. doxygenfile:: bpf_tracing.h
-   :project: libbpf
-   :sections: func define public-type enum
-
-bpf_core_read.h
----------------
-.. doxygenfile:: bpf_core_read.h
-   :project: libbpf
-   :sections: func define public-type enum
-
-bpf_endian.h
-------------
-.. doxygenfile:: bpf_endian.h
-   :project: libbpf
-   :sections: func define public-type enum

docs/conf.py

@@ -1,41 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: GPL-2.0
-# Configuration file for the Sphinx documentation builder.
-#
-# This file only contains a selection of the most common options. For a full
-# list see the documentation:
-# https://www.sphinx-doc.org/en/master/usage/configuration.html
-
-import os
-import subprocess
-
-project = "libbpf"
-
-extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.doctest',
-    'sphinx.ext.mathjax',
-    'sphinx.ext.viewcode',
-    'sphinx.ext.imgmath',
-    'sphinx.ext.todo',
-    'sphinx_rtd_theme',
-    'breathe',
-]
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = []
-
-read_the_docs_build = os.environ.get('READTHEDOCS', None) == 'True'
-
-if read_the_docs_build:
-    subprocess.call('cd sphinx ; make clean', shell=True)
-    subprocess.call('cd sphinx/doxygen ; doxygen', shell=True)
-
-html_theme = 'sphinx_rtd_theme'
-
-breathe_projects = { "libbpf": "./sphinx/doxygen/build/xml/" }
-breathe_default_project = "libbpf"
-breathe_show_define_initializer = True
-breathe_show_enumvalue_initializer = True

docs/index.rst

@@ -1,33 +0,0 @@
-.. SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
-
-.. _libbpf:
-
-======
-libbpf
-======
-
-If you are looking to develop BPF applications using the libbpf library, this
-directory contains important documentation that you should read.
-
-To get started, it is recommended to begin with the :doc:`libbpf Overview
-<libbpf_overview>` document, which provides a high-level understanding of the
-libbpf APIs and their usage. This will give you a solid foundation to start
-exploring and utilizing the various features of libbpf to develop your BPF
-applications.
-
-.. toctree::
-   :maxdepth: 1
-
-   libbpf_overview
-   API Documentation <https://libbpf.readthedocs.io/en/latest/api.html>
-   program_types
-   libbpf_naming_convention
-   libbpf_build
-
-
-All general BPF questions, including kernel functionality, libbpf APIs and their
-application, should be sent to bpf@vger.kernel.org mailing list.  You can
-`subscribe <http://vger.kernel.org/vger-lists.html#bpf>`_ to the mailing list
-search its `archive <https://lore.kernel.org/bpf/>`_.  Please search the archive
-before asking new questions. It may be that this was already addressed or
-answered before.

docs/libbpf_build.rst

@@ -1,37 +0,0 @@
-.. SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
-
-Building libbpf
-===============
-
-libelf and zlib are internal dependencies of libbpf and thus are required to link
-against and must be installed on the system for applications to work.
-pkg-config is used by default to find libelf, and the program called
-can be overridden with PKG_CONFIG.
-
-If using pkg-config at build time is not desired, it can be disabled by
-setting NO_PKG_CONFIG=1 when calling make.
-
-To build both static libbpf.a and shared libbpf.so:
-
-.. code-block:: bash
-
-    $ cd src
-    $ make
-
-To build only static libbpf.a library in directory build/ and install them
-together with libbpf headers in a staging directory root/:
-
-.. code-block:: bash
-
-    $ cd src
-    $ mkdir build root
-    $ BUILD_STATIC_ONLY=y OBJDIR=build DESTDIR=root make install
-
-To build both static libbpf.a and shared libbpf.so against a custom libelf
-dependency installed in /build/root/ and install them together with libbpf
-headers in a build directory /build/root/:
-
-.. code-block:: bash
-
-    $ cd src
-    $ PKG_CONFIG_PATH=/build/root/lib64/pkgconfig DESTDIR=/build/root make

docs/libbpf_overview.rst

@@ -1,236 +0,0 @@
-.. SPDX-License-Identifier: GPL-2.0
-
-===============
-libbpf Overview
-===============
-
-libbpf is a C-based library containing a BPF loader that takes compiled BPF
-object files and prepares and loads them into the Linux kernel. libbpf takes the
-heavy lifting of loading, verifying, and attaching BPF programs to various
-kernel hooks, allowing BPF application developers to focus only on BPF program
-correctness and performance.
-
-The following are the high-level features supported by libbpf:
-
-* Provides high-level and low-level APIs for user space programs to interact
-  with BPF programs. The low-level APIs wrap all the bpf system call
-  functionality, which is useful when users need more fine-grained control
-  over the interactions between user space and BPF programs.
-* Provides overall support for the BPF object skeleton generated by bpftool.
-  The skeleton file simplifies the process for the user space programs to access
-  global variables and work with BPF programs.
-* Provides BPF-side APIS, including BPF helper definitions, BPF maps support,
-  and tracing helpers, allowing developers to simplify BPF code writing.
-* Supports BPF CO-RE mechanism, enabling BPF developers to write portable
-  BPF programs that can be compiled once and run across different kernel
-  versions.
-
-This document will delve into the above concepts in detail, providing a deeper
-understanding of the capabilities and advantages of libbpf and how it can help
-you develop BPF applications efficiently.
-
-BPF App Lifecycle and libbpf APIs
-==================================
-
-A BPF application consists of one or more BPF programs (either cooperating or
-completely independent), BPF maps, and global variables. The global
-variables are shared between all BPF programs, which allows them to cooperate on
-a common set of data. libbpf provides APIs that user space programs can use to
-manipulate the BPF programs by triggering different phases of a BPF application
-lifecycle.
-
-The following section provides a brief overview of each phase in the BPF life
-cycle:
-
-* **Open phase**: In this phase, libbpf parses the BPF
-  object file and discovers BPF maps, BPF programs, and global variables. After
-  a BPF app is opened, user space apps can make additional adjustments
-  (setting BPF program types, if necessary; pre-setting initial values for
-  global variables, etc.) before all the entities are created and loaded.
-
-* **Load phase**: In the load phase, libbpf creates BPF
-  maps, resolves various relocations, and verifies and loads BPF programs into
-  the kernel. At this point, libbpf validates all the parts of a BPF application
-  and loads the BPF program into the kernel, but no BPF program has yet been
-  executed. After the load phase, it’s possible to set up the initial BPF map
-  state without racing with the BPF program code execution.
-
-* **Attachment phase**: In this phase, libbpf
-  attaches BPF programs to various BPF hook points (e.g., tracepoints, kprobes,
-  cgroup hooks, network packet processing pipeline, etc.). During this
-  phase, BPF programs perform useful work such as processing
-  packets, or updating BPF maps and global variables that can be read from user
-  space.
-
-* **Tear down phase**: In the tear down phase,
-  libbpf detaches BPF programs and unloads them from the kernel. BPF maps are
-  destroyed, and all the resources used by the BPF app are freed.
-
-BPF Object Skeleton File
-========================
-
-BPF skeleton is an alternative interface to libbpf APIs for working with BPF
-objects. Skeleton code abstract away generic libbpf APIs to significantly
-simplify code for manipulating BPF programs from user space. Skeleton code
-includes a bytecode representation of the BPF object file, simplifying the
-process of distributing your BPF code. With BPF bytecode embedded, there are no
-extra files to deploy along with your application binary.
-
-You can generate the skeleton header file ``(.skel.h)`` for a specific object
-file by passing the BPF object to the bpftool. The generated BPF skeleton
-provides the following custom functions that correspond to the BPF lifecycle,
-each of them prefixed with the specific object name:
-
-* ``<name>__open()`` – creates and opens BPF application (``<name>`` stands for
-  the specific bpf object name)
-* ``<name>__load()`` – instantiates, loads,and verifies BPF application parts
-* ``<name>__attach()`` – attaches all auto-attachable BPF programs (it’s
-  optional, you can have more control by using libbpf APIs directly)
-* ``<name>__destroy()`` – detaches all BPF programs and
-  frees up all used resources
-
-Using the skeleton code is the recommended way to work with bpf programs. Keep
-in mind, BPF skeleton provides access to the underlying BPF object, so whatever
-was possible to do with generic libbpf APIs is still possible even when the BPF
-skeleton is used. It's an additive convenience feature, with no syscalls, and no
-cumbersome code.
-
-Other Advantages of Using Skeleton File
----------------------------------------
-
-* BPF skeleton provides an interface for user space programs to work with BPF
-  global variables. The skeleton code memory maps global variables as a struct
-  into user space. The struct interface allows user space programs to initialize
-  BPF programs before the BPF load phase and fetch and update data from user
-  space afterward.
-
-* The ``skel.h`` file reflects the object file structure by listing out the
-  available maps, programs, etc. BPF skeleton provides direct access to all the
-  BPF maps and BPF programs as struct fields. This eliminates the need for
-  string-based lookups with ``bpf_object_find_map_by_name()`` and
-  ``bpf_object_find_program_by_name()`` APIs, reducing errors due to BPF source
-  code and user-space code getting out of sync.
-
-* The embedded bytecode representation of the object file ensures that the
-  skeleton and the BPF object file are always in sync.
-
-BPF Helpers
-===========
-
-libbpf provides BPF-side APIs that BPF programs can use to interact with the
-system. The BPF helpers definition allows developers to use them in BPF code as
-any other plain C function. For example, there are helper functions to print
-debugging messages, get the time since the system was booted, interact with BPF
-maps, manipulate network packets, etc.
-
-For a complete description of what the helpers do, the arguments they take, and
-the return value, see the `bpf-helpers
-<https://man7.org/linux/man-pages/man7/bpf-helpers.7.html>`_ man page.
-
-BPF CO-RE (Compile Once – Run Everywhere)
-=========================================
-
-BPF programs work in the kernel space and have access to kernel memory and data
-structures. One limitation that BPF applications come across is the lack of
-portability across different kernel versions and configurations. `BCC
-<https://github.com/iovisor/bcc/>`_ is one of the solutions for BPF
-portability. However, it comes with runtime overhead and a large binary size
-from embedding the compiler with the application.
-
-libbpf steps up the BPF program portability by supporting the BPF CO-RE concept.
-BPF CO-RE brings together BTF type information, libbpf, and the compiler to
-produce a single executable binary that you can run on multiple kernel versions
-and configurations.
-
-To make BPF programs portable libbpf relies on the BTF type information of the
-running kernel. Kernel also exposes this self-describing authoritative BTF
-information through ``sysfs`` at ``/sys/kernel/btf/vmlinux``.
-
-You can generate the BTF information for the running kernel with the following
-command:
-
-::
-
-  $ bpftool btf dump file /sys/kernel/btf/vmlinux format c > vmlinux.h
-
-The command generates a ``vmlinux.h`` header file with all kernel types
-(:doc:`BTF types <../btf>`) that the running kernel uses. Including
-``vmlinux.h`` in your BPF program eliminates dependency on system-wide kernel
-headers.
-
-libbpf enables portability of BPF programs by looking at the BPF program’s
-recorded BTF type and relocation information and matching them to BTF
-information (vmlinux) provided by the running kernel. libbpf then resolves and
-matches all the types and fields, and updates necessary offsets and other
-relocatable data to ensure that BPF program’s logic functions correctly for a
-specific kernel on the host. BPF CO-RE concept thus eliminates overhead
-associated with BPF development and allows developers to write portable BPF
-applications without modifications and runtime source code compilation on the
-target machine.
-
-The following code snippet shows how to read the parent field of a kernel
-``task_struct`` using BPF CO-RE and libbf. The basic helper to read a field in a
-CO-RE relocatable manner is ``bpf_core_read(dst, sz, src)``, which will read
-``sz`` bytes from the field referenced by ``src`` into the memory pointed to by
-``dst``.
-
-.. code-block:: C
-   :emphasize-lines: 6
-
-    //...
-    struct task_struct *task = (void *)bpf_get_current_task();
-    struct task_struct *parent_task;
-    int err;
-
-    err = bpf_core_read(&parent_task, sizeof(void *), &task->parent);
-    if (err) {
-      /* handle error */
-    }
-
-    /* parent_task contains the value of task->parent pointer */
-
-In the code snippet, we first get a pointer to the current ``task_struct`` using
-``bpf_get_current_task()``.  We then use ``bpf_core_read()`` to read the parent
-field of task struct into the ``parent_task`` variable. ``bpf_core_read()`` is
-just like ``bpf_probe_read_kernel()`` BPF helper, except it records information
-about the field that should be relocated on the target kernel. i.e, if the
-``parent`` field gets shifted to a different offset within
-``struct task_struct`` due to some new field added in front of it, libbpf will
-automatically adjust the actual offset to the proper value.
-
-Getting Started with libbpf
-===========================
-
-Check out the `libbpf-bootstrap <https://github.com/libbpf/libbpf-bootstrap>`_
-repository with simple examples of using libbpf to build various BPF
-applications.
-
-See also `libbpf API documentation
-<https://libbpf.readthedocs.io/en/latest/api.html>`_.
-
-libbpf and Rust
-===============
-
-If you are building BPF applications in Rust, it is recommended to use the
-`Libbpf-rs <https://github.com/libbpf/libbpf-rs>`_ library instead of bindgen
-bindings directly to libbpf. Libbpf-rs wraps libbpf functionality in
-Rust-idiomatic interfaces and provides libbpf-cargo plugin to handle BPF code
-compilation and skeleton generation. Using Libbpf-rs will make building user
-space part of the BPF application easier. Note that the BPF program themselves
-must still be written in plain C.
-
-libbpf logging
-==============
-
-By default, libbpf logs informational and warning messages to stderr. The
-verbosity of these messages can be controlled by setting the environment
-variable LIBBPF_LOG_LEVEL to either warn, info, or debug. A custom log
-callback can be set using ``libbpf_set_print()``.
-
-Additional Documentation
-========================
-
-* `Program types and ELF Sections <https://libbpf.readthedocs.io/en/latest/program_types.html>`_
-* `API naming convention <https://libbpf.readthedocs.io/en/latest/libbpf_naming_convention.html>`_
-* `Building libbpf <https://libbpf.readthedocs.io/en/latest/libbpf_build.html>`_
-* `API documentation Convention <https://libbpf.readthedocs.io/en/latest/libbpf_naming_convention.html#api-documentation-convention>`_

docs/program_types.rst

@@ -1,213 +0,0 @@
-.. SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
-
-.. _program_types_and_elf:
-
-Program Types and ELF Sections
-==============================
-
-The table below lists the program types, their attach types where relevant and the ELF section
-names supported by libbpf for them. The ELF section names follow these rules:
-
-- ``type`` is an exact match, e.g. ``SEC("socket")``
-- ``type+`` means it can be either exact ``SEC("type")`` or well-formed ``SEC("type/extras")``
-  with a '``/``' separator between ``type`` and ``extras``.
-
-When ``extras`` are specified, they provide details of how to auto-attach the BPF program.  The
-format of ``extras`` depends on the program type, e.g. ``SEC("tracepoint/<category>/<name>")``
-for tracepoints or ``SEC("usdt/<path>:<provider>:<name>")`` for USDT probes. The extras are
-described in more detail in the footnotes.
-
-
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| Program Type                              | Attach Type                            | ELF Section Name                 | Sleepable |
-+===========================================+========================================+==================================+===========+
-| ``BPF_PROG_TYPE_CGROUP_DEVICE``           | ``BPF_CGROUP_DEVICE``                  | ``cgroup/dev``                   |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_CGROUP_SKB``              |                                        | ``cgroup/skb``                   |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET_EGRESS``             | ``cgroup_skb/egress``            |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET_INGRESS``            | ``cgroup_skb/ingress``           |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_CGROUP_SOCKOPT``          | ``BPF_CGROUP_GETSOCKOPT``              | ``cgroup/getsockopt``            |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_SETSOCKOPT``              | ``cgroup/setsockopt``            |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_CGROUP_SOCK_ADDR``        | ``BPF_CGROUP_INET4_BIND``              | ``cgroup/bind4``                 |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET4_CONNECT``           | ``cgroup/connect4``              |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET4_GETPEERNAME``       | ``cgroup/getpeername4``          |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET4_GETSOCKNAME``       | ``cgroup/getsockname4``          |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET6_BIND``              | ``cgroup/bind6``                 |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET6_CONNECT``           | ``cgroup/connect6``              |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET6_GETPEERNAME``       | ``cgroup/getpeername6``          |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET6_GETSOCKNAME``       | ``cgroup/getsockname6``          |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_UDP4_RECVMSG``            | ``cgroup/recvmsg4``              |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_UDP4_SENDMSG``            | ``cgroup/sendmsg4``              |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_UDP6_RECVMSG``            | ``cgroup/recvmsg6``              |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_UDP6_SENDMSG``            | ``cgroup/sendmsg6``              |           |
-|                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_UNIX_CONNECT``            | ``cgroup/connect_unix``          |           |
-|                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_UNIX_SENDMSG``            | ``cgroup/sendmsg_unix``          |           |
-|                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_UNIX_RECVMSG``            | ``cgroup/recvmsg_unix``          |           |
-|                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_UNIX_GETPEERNAME``        | ``cgroup/getpeername_unix``      |           |
-|                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_UNIX_GETSOCKNAME``        | ``cgroup/getsockname_unix``      |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_CGROUP_SOCK``             | ``BPF_CGROUP_INET4_POST_BIND``         | ``cgroup/post_bind4``            |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET6_POST_BIND``         | ``cgroup/post_bind6``            |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET_SOCK_CREATE``        | ``cgroup/sock_create``           |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``cgroup/sock``                  |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_CGROUP_INET_SOCK_RELEASE``       | ``cgroup/sock_release``          |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_CGROUP_SYSCTL``           | ``BPF_CGROUP_SYSCTL``                  | ``cgroup/sysctl``                |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_EXT``                     |                                        | ``freplace+`` [#fentry]_         |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_FLOW_DISSECTOR``          | ``BPF_FLOW_DISSECTOR``                 | ``flow_dissector``               |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_KPROBE``                  |                                        | ``kprobe+`` [#kprobe]_           |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``kretprobe+`` [#kprobe]_        |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``ksyscall+`` [#ksyscall]_       |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        |  ``kretsyscall+`` [#ksyscall]_   |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``uprobe+`` [#uprobe]_           |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``uprobe.s+`` [#uprobe]_         | Yes       |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``uretprobe+`` [#uprobe]_        |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``uretprobe.s+`` [#uprobe]_      | Yes       |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``usdt+`` [#usdt]_               |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_TRACE_KPROBE_MULTI``             | ``kprobe.multi+`` [#kpmulti]_    |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``kretprobe.multi+`` [#kpmulti]_ |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_LIRC_MODE2``              | ``BPF_LIRC_MODE2``                     | ``lirc_mode2``                   |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_LSM``                     | ``BPF_LSM_CGROUP``                     | ``lsm_cgroup+``                  |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_LSM_MAC``                        | ``lsm+`` [#lsm]_                 |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``lsm.s+`` [#lsm]_               | Yes       |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_LWT_IN``                  |                                        | ``lwt_in``                       |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_LWT_OUT``                 |                                        | ``lwt_out``                      |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_LWT_SEG6LOCAL``           |                                        | ``lwt_seg6local``                |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_LWT_XMIT``                |                                        | ``lwt_xmit``                     |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_PERF_EVENT``              |                                        | ``perf_event``                   |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE`` |                                        | ``raw_tp.w+`` [#rawtp]_          |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``raw_tracepoint.w+``            |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_RAW_TRACEPOINT``          |                                        | ``raw_tp+`` [#rawtp]_            |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``raw_tracepoint+``              |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_SCHED_ACT``               |                                        | ``action``                       |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_SCHED_CLS``               |                                        | ``classifier``                   |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``tc``                           |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_SK_LOOKUP``               | ``BPF_SK_LOOKUP``                      | ``sk_lookup``                    |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_SK_MSG``                  | ``BPF_SK_MSG_VERDICT``                 | ``sk_msg``                       |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_SK_REUSEPORT``            | ``BPF_SK_REUSEPORT_SELECT_OR_MIGRATE`` | ``sk_reuseport/migrate``         |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_SK_REUSEPORT_SELECT``            | ``sk_reuseport``                 |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_SK_SKB``                  |                                        | ``sk_skb``                       |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_SK_SKB_STREAM_PARSER``           | ``sk_skb/stream_parser``         |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_SK_SKB_STREAM_VERDICT``          | ``sk_skb/stream_verdict``        |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_SOCKET_FILTER``           |                                        | ``socket``                       |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_SOCK_OPS``                | ``BPF_CGROUP_SOCK_OPS``                | ``sockops``                      |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_STRUCT_OPS``              |                                        | ``struct_ops+``                  |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_SYSCALL``                 |                                        | ``syscall``                      | Yes       |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_TRACEPOINT``              |                                        | ``tp+`` [#tp]_                   |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``tracepoint+`` [#tp]_           |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_TRACING``                 | ``BPF_MODIFY_RETURN``                  | ``fmod_ret+`` [#fentry]_         |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``fmod_ret.s+`` [#fentry]_       | Yes       |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_TRACE_FENTRY``                   | ``fentry+`` [#fentry]_           |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``fentry.s+`` [#fentry]_         | Yes       |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_TRACE_FEXIT``                    | ``fexit+`` [#fentry]_            |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``fexit.s+`` [#fentry]_          | Yes       |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_TRACE_ITER``                     | ``iter+`` [#iter]_               |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``iter.s+`` [#iter]_             | Yes       |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_TRACE_RAW_TP``                   | ``tp_btf+`` [#fentry]_           |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-| ``BPF_PROG_TYPE_XDP``                     | ``BPF_XDP_CPUMAP``                     | ``xdp.frags/cpumap``             |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``xdp/cpumap``                   |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_XDP_DEVMAP``                     | ``xdp.frags/devmap``             |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``xdp/devmap``                   |           |
-+                                           +----------------------------------------+----------------------------------+-----------+
-|                                           | ``BPF_XDP``                            | ``xdp.frags``                    |           |
-+                                           +                                        +----------------------------------+-----------+
-|                                           |                                        | ``xdp``                          |           |
-+-------------------------------------------+----------------------------------------+----------------------------------+-----------+
-
-
-.. rubric:: Footnotes
-
-.. [#fentry] The ``fentry`` attach format is ``fentry[.s]/<function>``.
-.. [#kprobe] The ``kprobe`` attach format is ``kprobe/<function>[+<offset>]``. Valid
-             characters for ``function`` are ``a-zA-Z0-9_.`` and ``offset`` must be a valid
-             non-negative integer.
-.. [#ksyscall] The ``ksyscall`` attach format is ``ksyscall/<syscall>``.
-.. [#uprobe] The ``uprobe`` attach format is ``uprobe[.s]/<path>:<function>[+<offset>]``.
-.. [#usdt] The ``usdt`` attach format is ``usdt/<path>:<provider>:<name>``.
-.. [#kpmulti] The ``kprobe.multi`` attach format is ``kprobe.multi/<pattern>`` where ``pattern``
-              supports ``*`` and ``?`` wildcards. Valid characters for pattern are
-              ``a-zA-Z0-9_.*?``.
-.. [#lsm] The ``lsm`` attachment format is ``lsm[.s]/<hook>``.
-.. [#rawtp] The ``raw_tp`` attach format is ``raw_tracepoint[.w]/<tracepoint>``.
-.. [#tp] The ``tracepoint`` attach format is ``tracepoint/<category>/<name>``.
-.. [#iter] The ``iter`` attach format is ``iter[.s]/<struct-name>``.

docs/sphinx/Makefile

@@ -1,9 +0,0 @@
-SPHINXBUILD   ?= sphinx-build
-SOURCEDIR     = ../src
-BUILDDIR      = build
-
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)"
-
-%:
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)"

docs/sphinx/doxygen/Doxyfile

@@ -1,277 +0,0 @@
-DOXYFILE_ENCODING      = UTF-8
-PROJECT_NAME           = "libbpf"
-PROJECT_NUMBER         =
-PROJECT_BRIEF          =
-PROJECT_LOGO           =
-OUTPUT_DIRECTORY       = ./build
-CREATE_SUBDIRS         = NO
-ALLOW_UNICODE_NAMES    = NO
-OUTPUT_LANGUAGE        = English
-OUTPUT_TEXT_DIRECTION  = None
-BRIEF_MEMBER_DESC      = YES
-REPEAT_BRIEF           = YES
-ALWAYS_DETAILED_SEC    = NO
-INLINE_INHERITED_MEMB  = NO
-FULL_PATH_NAMES        = YES
-STRIP_FROM_PATH        =
-STRIP_FROM_INC_PATH    =
-SHORT_NAMES            = NO
-JAVADOC_AUTOBRIEF      = NO
-JAVADOC_BANNER         = NO
-QT_AUTOBRIEF           = NO
-MULTILINE_CPP_IS_BRIEF = NO
-PYTHON_DOCSTRING       = NO
-INHERIT_DOCS           = YES
-SEPARATE_MEMBER_PAGES  = NO
-TAB_SIZE               = 4
-ALIASES                =
-OPTIMIZE_OUTPUT_FOR_C  = YES
-OPTIMIZE_OUTPUT_JAVA   = NO
-OPTIMIZE_FOR_FORTRAN   = NO
-OPTIMIZE_OUTPUT_VHDL   = NO
-OPTIMIZE_OUTPUT_SLICE  = NO
-EXTENSION_MAPPING      =
-MARKDOWN_SUPPORT       = YES
-TOC_INCLUDE_HEADINGS   = 5
-AUTOLINK_SUPPORT       = YES
-BUILTIN_STL_SUPPORT    = NO
-CPP_CLI_SUPPORT        = NO
-SIP_SUPPORT            = NO
-IDL_PROPERTY_SUPPORT   = YES
-DISTRIBUTE_GROUP_DOC   = NO
-GROUP_NESTED_COMPOUNDS = NO
-SUBGROUPING            = YES
-INLINE_GROUPED_CLASSES = NO
-INLINE_SIMPLE_STRUCTS  = NO
-TYPEDEF_HIDES_STRUCT   = NO
-LOOKUP_CACHE_SIZE      = 0
-NUM_PROC_THREADS       = 1
-EXTRACT_ALL            = NO
-EXTRACT_PRIVATE        = NO
-EXTRACT_PRIV_VIRTUAL   = NO
-EXTRACT_PACKAGE        = NO
-EXTRACT_STATIC         = NO
-EXTRACT_LOCAL_CLASSES  = YES
-EXTRACT_LOCAL_METHODS  = NO
-EXTRACT_ANON_NSPACES   = NO
-RESOLVE_UNNAMED_PARAMS = YES
-HIDE_UNDOC_MEMBERS     = NO
-HIDE_UNDOC_CLASSES     = NO
-HIDE_FRIEND_COMPOUNDS  = NO
-HIDE_IN_BODY_DOCS      = NO
-INTERNAL_DOCS          = NO
-CASE_SENSE_NAMES       = YES
-HIDE_SCOPE_NAMES       = NO
-HIDE_COMPOUND_REFERENCE= NO
-SHOW_INCLUDE_FILES     = YES
-SHOW_GROUPED_MEMB_INC  = NO
-FORCE_LOCAL_INCLUDES   = NO
-INLINE_INFO            = YES
-SORT_MEMBER_DOCS       = YES
-SORT_BRIEF_DOCS        = NO
-SORT_MEMBERS_CTORS_1ST = NO
-SORT_GROUP_NAMES       = NO
-SORT_BY_SCOPE_NAME     = NO
-STRICT_PROTO_MATCHING  = NO
-GENERATE_TODOLIST      = YES
-GENERATE_TESTLIST      = YES
-GENERATE_BUGLIST       = YES
-GENERATE_DEPRECATEDLIST= YES
-ENABLED_SECTIONS       =
-MAX_INITIALIZER_LINES  = 30
-SHOW_USED_FILES        = YES
-SHOW_FILES             = YES
-SHOW_NAMESPACES        = YES
-FILE_VERSION_FILTER    =
-LAYOUT_FILE            =
-CITE_BIB_FILES         =
-QUIET                  = NO
-WARNINGS               = YES
-WARN_IF_UNDOCUMENTED   = YES
-WARN_IF_DOC_ERROR      = YES
-WARN_NO_PARAMDOC       = NO
-WARN_AS_ERROR          = NO
-WARN_FORMAT            = "$file:$line: $text"
-WARN_LOGFILE           =
-INPUT                  = ../../../src
-INPUT_ENCODING         = UTF-8
-FILE_PATTERNS          = *.c \
-                         *.h
-RECURSIVE              = NO
-EXCLUDE                =
-EXCLUDE_SYMLINKS       = NO
-EXCLUDE_PATTERNS       =
-EXCLUDE_SYMBOLS        = ___*
-EXAMPLE_PATH           =
-EXAMPLE_PATTERNS       = *
-EXAMPLE_RECURSIVE      = NO
-IMAGE_PATH             =
-INPUT_FILTER           =
-FILTER_PATTERNS        =
-FILTER_SOURCE_FILES    = NO
-FILTER_SOURCE_PATTERNS =
-USE_MDFILE_AS_MAINPAGE = YES
-SOURCE_BROWSER         = NO
-INLINE_SOURCES         = NO
-STRIP_CODE_COMMENTS    = YES
-REFERENCED_BY_RELATION = NO
-REFERENCES_RELATION    = NO
-REFERENCES_LINK_SOURCE = YES
-SOURCE_TOOLTIPS        = YES
-USE_HTAGS              = NO
-VERBATIM_HEADERS       = YES
-ALPHABETICAL_INDEX     = YES
-IGNORE_PREFIX          =
-GENERATE_HTML          = NO
-HTML_OUTPUT            = html
-HTML_FILE_EXTENSION    = .html
-HTML_HEADER            =
-HTML_FOOTER            =
-HTML_STYLESHEET        =
-HTML_EXTRA_STYLESHEET  =
-HTML_EXTRA_FILES       =
-HTML_COLORSTYLE_HUE    = 220
-HTML_COLORSTYLE_SAT    = 100
-HTML_COLORSTYLE_GAMMA  = 80
-HTML_TIMESTAMP         = NO
-HTML_DYNAMIC_MENUS     = YES
-HTML_DYNAMIC_SECTIONS  = NO
-HTML_INDEX_NUM_ENTRIES = 100
-GENERATE_DOCSET        = NO
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-DOCSET_PUBLISHER_NAME  = Publisher
-GENERATE_HTMLHELP      = NO
-CHM_FILE               =
-HHC_LOCATION           =
-GENERATE_CHI           = NO
-CHM_INDEX_ENCODING     =
-BINARY_TOC             = NO
-TOC_EXPAND             = NO
-GENERATE_QHP           = NO
-QCH_FILE               =
-QHP_NAMESPACE          = org.doxygen.Project
-QHP_VIRTUAL_FOLDER     = doc
-QHP_CUST_FILTER_NAME   =
-QHP_CUST_FILTER_ATTRS  =
-QHP_SECT_FILTER_ATTRS  =
-QHG_LOCATION           =
-GENERATE_ECLIPSEHELP   = NO
-ECLIPSE_DOC_ID         = org.doxygen.Project
-DISABLE_INDEX          = NO
-GENERATE_TREEVIEW      = NO
-ENUM_VALUES_PER_LINE   = 4
-TREEVIEW_WIDTH         = 250
-EXT_LINKS_IN_WINDOW    = NO
-HTML_FORMULA_FORMAT    = png
-FORMULA_FONTSIZE       = 10
-FORMULA_TRANSPARENT    = YES
-FORMULA_MACROFILE      =
-USE_MATHJAX            = NO
-MATHJAX_FORMAT         = HTML-CSS
-MATHJAX_RELPATH        = https://cdn.jsdelivr.net/npm/mathjax@2
-MATHJAX_EXTENSIONS     =
-MATHJAX_CODEFILE       =
-SEARCHENGINE           = YES
-SERVER_BASED_SEARCH    = NO
-EXTERNAL_SEARCH        = NO
-SEARCHENGINE_URL       =
-SEARCHDATA_FILE        = searchdata.xml
-EXTERNAL_SEARCH_ID     =
-EXTRA_SEARCH_MAPPINGS  =
-GENERATE_LATEX         = NO
-LATEX_OUTPUT           = latex
-LATEX_CMD_NAME         =
-MAKEINDEX_CMD_NAME     = makeindex
-LATEX_MAKEINDEX_CMD    = makeindex
-COMPACT_LATEX          = NO
-PAPER_TYPE             = a4
-EXTRA_PACKAGES         =
-LATEX_HEADER           =
-LATEX_FOOTER           =
-LATEX_EXTRA_STYLESHEET =
-LATEX_EXTRA_FILES      =
-PDF_HYPERLINKS         = YES
-USE_PDFLATEX           = YES
-LATEX_BATCHMODE        = NO
-LATEX_HIDE_INDICES     = NO
-LATEX_SOURCE_CODE      = NO
-LATEX_BIB_STYLE        = plain
-LATEX_TIMESTAMP        = NO
-LATEX_EMOJI_DIRECTORY  =
-GENERATE_RTF           = NO
-RTF_OUTPUT             = rtf
-COMPACT_RTF            = NO
-RTF_HYPERLINKS         = NO
-RTF_STYLESHEET_FILE    =
-RTF_EXTENSIONS_FILE    =
-RTF_SOURCE_CODE        = NO
-GENERATE_MAN           = NO
-MAN_OUTPUT             = man
-MAN_EXTENSION          = .3
-MAN_SUBDIR             =
-MAN_LINKS              = NO
-GENERATE_XML           = YES
-XML_OUTPUT             = xml
-XML_PROGRAMLISTING     = YES
-XML_NS_MEMB_FILE_SCOPE = NO
-GENERATE_DOCBOOK       = NO
-DOCBOOK_OUTPUT         = docbook
-DOCBOOK_PROGRAMLISTING = NO
-GENERATE_AUTOGEN_DEF   = NO
-GENERATE_PERLMOD       = NO
-PERLMOD_LATEX          = NO
-PERLMOD_PRETTY         = YES
-PERLMOD_MAKEVAR_PREFIX =
-ENABLE_PREPROCESSING   = YES
-MACRO_EXPANSION        = NO
-EXPAND_ONLY_PREDEF     = YES
-SEARCH_INCLUDES        = YES
-INCLUDE_PATH           =
-INCLUDE_FILE_PATTERNS  =
-PREDEFINED             =
-EXPAND_AS_DEFINED      =
-SKIP_FUNCTION_MACROS   = NO
-TAGFILES               =
-GENERATE_TAGFILE       =
-ALLEXTERNALS           = NO
-EXTERNAL_GROUPS        = YES
-EXTERNAL_PAGES         = YES
-CLASS_DIAGRAMS         = YES
-DIA_PATH               =
-HIDE_UNDOC_RELATIONS   = YES
-HAVE_DOT               = NO
-DOT_NUM_THREADS        = 0
-DOT_FONTNAME           = Helvetica
-DOT_FONTSIZE           = 10
-DOT_FONTPATH           =
-CLASS_GRAPH            = YES
-COLLABORATION_GRAPH    = YES
-GROUP_GRAPHS           = YES
-UML_LOOK               = NO
-UML_LIMIT_NUM_FIELDS   = 10
-DOT_UML_DETAILS        = NO
-DOT_WRAP_THRESHOLD     = 17
-TEMPLATE_RELATIONS     = NO
-INCLUDE_GRAPH          = YES
-INCLUDED_BY_GRAPH      = YES
-CALL_GRAPH             = NO
-CALLER_GRAPH           = NO
-GRAPHICAL_HIERARCHY    = YES
-DIRECTORY_GRAPH        = YES
-DOT_IMAGE_FORMAT       = png
-INTERACTIVE_SVG        = NO
-DOT_PATH               =
-DOTFILE_DIRS           =
-MSCFILE_DIRS           =
-DIAFILE_DIRS           =
-PLANTUML_JAR_PATH      =
-PLANTUML_CFG_FILE      =
-PLANTUML_INCLUDE_PATH  =
-DOT_GRAPH_MAX_NODES    = 50
-MAX_DOT_GRAPH_DEPTH    = 0
-DOT_TRANSPARENT        = NO
-DOT_MULTI_TARGETS      = NO
-GENERATE_LEGEND        = YES
-DOT_CLEANUP            = YES

docs/sphinx/requirements.txt

@@ -1,2 +0,0 @@
-breathe
-sphinx_rtd_theme

fuzz/bpf-object-fuzzer.c

@@ -1,23 +0,0 @@
-#include "libbpf.h"
-
-static int libbpf_print_fn(enum libbpf_print_level level, const char *format, va_list args)
-{
-	return 0;
-}
-
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-	struct bpf_object *obj = NULL;
-	DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts);
-	int err;
-
-	libbpf_set_print(libbpf_print_fn);
-
-	opts.object_name = "fuzz-object";
-	obj = bpf_object__open_mem(data, size, &opts);
-	err = libbpf_get_error(obj);
-	if (err)
-		return 0;
-
-	bpf_object__close(obj);
-	return 0;
-}

include/linux/filter.h

@@ -5,22 +5,6 @@
 
 #include <linux/bpf.h>
 
-#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM)			\
-	((struct bpf_insn) {					\
-		.code = CODE,					\
-		.dst_reg = DST,					\
-		.src_reg = SRC,					\
-		.off = OFF,					\
-		.imm = IMM })
-
-#define BPF_ALU32_IMM(OP, DST, IMM)				\
-	((struct bpf_insn) {					\
-		.code  = BPF_ALU | BPF_OP(OP) | BPF_K,		\
-		.dst_reg = DST,					\
-		.src_reg = 0,					\
-		.off   = 0,					\
-		.imm   = IMM })
-
 #define BPF_ALU64_IMM(OP, DST, IMM)				\
 	((struct bpf_insn) {					\
 		.code  = BPF_ALU64 | BPF_OP(OP) | BPF_K,	\
@@ -37,14 +21,6 @@
 		.off   = 0,					\
 		.imm   = IMM })
 
-#define BPF_CALL_REL(DST)					\
-	((struct bpf_insn) {					\
-		.code = BPF_JMP | BPF_CALL,			\
-		.dst_reg = 0,					\
-		.src_reg = BPF_PSEUDO_CALL,			\
-		.off = 0,					\
-		.imm = DST })
-
 #define BPF_EXIT_INSN()						\
 	((struct bpf_insn) {					\
 		.code  = BPF_JMP | BPF_EXIT,			\

include/linux/kernel.h

@@ -3,8 +3,6 @@
 #ifndef __LINUX_KERNEL_H
 #define __LINUX_KERNEL_H
 
-#include <linux/compiler.h>
-
 #ifndef offsetof
 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
 #endif

include/linux/list.h

@@ -72,20 +72,11 @@ static inline void list_del(struct list_head *entry)
         entry->prev = LIST_POISON2;
 }
 
-static inline int list_empty(const struct list_head *head)
-{
-	return head->next == head;
-}
-
 #define list_entry(ptr, type, member) \
         container_of(ptr, type, member)
 #define list_first_entry(ptr, type, member) \
         list_entry((ptr)->next, type, member)
 #define list_next_entry(pos, member) \
         list_entry((pos)->member.next, typeof(*(pos)), member)
-#define list_for_each_entry(pos, head, member) \
-	for (pos = list_first_entry(head, typeof(*pos), member); \
-	     &pos->member != (head); \
-	     pos = list_next_entry(pos, member))
 
 #endif

include/linux/types.h

@@ -7,8 +7,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <linux/stddef.h>
-
 #include <asm/types.h>
 #include <asm/posix_types.h>
 

include/tools/libc_compat.h

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: (LGPL-2.0+ OR BSD-2-Clause)
+/* Copyright (C) 2018 Netronome Systems, Inc. */
+
+#ifndef __TOOLS_LIBC_COMPAT_H
+#define __TOOLS_LIBC_COMPAT_H
+
+#include <stdlib.h>
+#include <linux/overflow.h>
+
+#ifdef COMPAT_NEED_REALLOCARRAY
+static inline void *reallocarray(void *ptr, size_t nmemb, size_t size)
+{
+	size_t bytes;
+
+	if (unlikely(check_mul_overflow(nmemb, size, &bytes)))
+		return NULL;
+	return realloc(ptr, bytes);
+}
+#endif
+#endif

include/uapi/linux/btf.h

@@ -33,17 +33,17 @@ struct btf_type {
 	/* "info" bits arrangement
 	 * bits  0-15: vlen (e.g. # of struct's members)
 	 * bits 16-23: unused
-	 * bits 24-28: kind (e.g. int, ptr, array...etc)
-	 * bits 29-30: unused
+	 * bits 24-27: kind (e.g. int, ptr, array...etc)
+	 * bits 28-30: unused
 	 * bit     31: kind_flag, currently used by
-	 *             struct, union, enum, fwd and enum64
+	 *             struct, union and fwd
 	 */
 	__u32 info;
-	/* "size" is used by INT, ENUM, STRUCT, UNION, DATASEC and ENUM64.
+	/* "size" is used by INT, ENUM, STRUCT, UNION and DATASEC.
 	 * "size" tells the size of the type it is describing.
 	 *
 	 * "type" is used by PTR, TYPEDEF, VOLATILE, CONST, RESTRICT,
-	 * FUNC, FUNC_PROTO, VAR, DECL_TAG and TYPE_TAG.
+	 * FUNC, FUNC_PROTO and VAR.
 	 * "type" is a type_id referring to another type.
 	 */
 	union {
@@ -52,35 +52,28 @@ struct btf_type {
 	};
 };
 
-#define BTF_INFO_KIND(info)	(((info) >> 24) & 0x1f)
+#define BTF_INFO_KIND(info)	(((info) >> 24) & 0x0f)
 #define BTF_INFO_VLEN(info)	((info) & 0xffff)
 #define BTF_INFO_KFLAG(info)	((info) >> 31)
 
-enum {
-	BTF_KIND_UNKN		= 0,	/* Unknown	*/
-	BTF_KIND_INT		= 1,	/* Integer	*/
-	BTF_KIND_PTR		= 2,	/* Pointer	*/
-	BTF_KIND_ARRAY		= 3,	/* Array	*/
-	BTF_KIND_STRUCT		= 4,	/* Struct	*/
-	BTF_KIND_UNION		= 5,	/* Union	*/
-	BTF_KIND_ENUM		= 6,	/* Enumeration up to 32-bit values */
-	BTF_KIND_FWD		= 7,	/* Forward	*/
-	BTF_KIND_TYPEDEF	= 8,	/* Typedef	*/
-	BTF_KIND_VOLATILE	= 9,	/* Volatile	*/
-	BTF_KIND_CONST		= 10,	/* Const	*/
-	BTF_KIND_RESTRICT	= 11,	/* Restrict	*/
-	BTF_KIND_FUNC		= 12,	/* Function	*/
-	BTF_KIND_FUNC_PROTO	= 13,	/* Function Proto	*/
-	BTF_KIND_VAR		= 14,	/* Variable	*/
-	BTF_KIND_DATASEC	= 15,	/* Section	*/
-	BTF_KIND_FLOAT		= 16,	/* Floating point	*/
-	BTF_KIND_DECL_TAG	= 17,	/* Decl Tag */
-	BTF_KIND_TYPE_TAG	= 18,	/* Type Tag */
-	BTF_KIND_ENUM64		= 19,	/* Enumeration up to 64-bit values */
-
-	NR_BTF_KINDS,
-	BTF_KIND_MAX		= NR_BTF_KINDS - 1,
-};
+#define BTF_KIND_UNKN		0	/* Unknown	*/
+#define BTF_KIND_INT		1	/* Integer	*/
+#define BTF_KIND_PTR		2	/* Pointer	*/
+#define BTF_KIND_ARRAY		3	/* Array	*/
+#define BTF_KIND_STRUCT		4	/* Struct	*/
+#define BTF_KIND_UNION		5	/* Union	*/
+#define BTF_KIND_ENUM		6	/* Enumeration	*/
+#define BTF_KIND_FWD		7	/* Forward	*/
+#define BTF_KIND_TYPEDEF	8	/* Typedef	*/
+#define BTF_KIND_VOLATILE	9	/* Volatile	*/
+#define BTF_KIND_CONST		10	/* Const	*/
+#define BTF_KIND_RESTRICT	11	/* Restrict	*/
+#define BTF_KIND_FUNC		12	/* Function	*/
+#define BTF_KIND_FUNC_PROTO	13	/* Function Proto	*/
+#define BTF_KIND_VAR		14	/* Variable	*/
+#define BTF_KIND_DATASEC	15	/* Section	*/
+#define BTF_KIND_MAX		BTF_KIND_DATASEC
+#define NR_BTF_KINDS		(BTF_KIND_MAX + 1)
 
 /* For some specific BTF_KIND, "struct btf_type" is immediately
  * followed by extra data.
@@ -176,25 +169,4 @@ struct btf_var_secinfo {
 	__u32	size;
 };
 
-/* BTF_KIND_DECL_TAG is followed by a single "struct btf_decl_tag" to describe
- * additional information related to the tag applied location.
- * If component_idx == -1, the tag is applied to a struct, union,
- * variable or function. Otherwise, it is applied to a struct/union
- * member or a func argument, and component_idx indicates which member
- * or argument (0 ... vlen-1).
- */
-struct btf_decl_tag {
-       __s32   component_idx;
-};
-
-/* BTF_KIND_ENUM64 is followed by multiple "struct btf_enum64".
- * The exact number of btf_enum64 is stored in the vlen (of the
- * info in "struct btf_type").
- */
-struct btf_enum64 {
-	__u32	name_off;
-	__u32	val_lo32;
-	__u32	val_hi32;
-};
-
 #endif /* _UAPI__LINUX_BTF_H__ */

include/uapi/linux/if_link.h

@@ -7,23 +7,24 @@
 
 /* This struct should be in sync with struct rtnl_link_stats64 */
 struct rtnl_link_stats {
-	__u32	rx_packets;
-	__u32	tx_packets;
-	__u32	rx_bytes;
-	__u32	tx_bytes;
-	__u32	rx_errors;
-	__u32	tx_errors;
-	__u32	rx_dropped;
-	__u32	tx_dropped;
-	__u32	multicast;
+	__u32	rx_packets;		/* total packets received	*/
+	__u32	tx_packets;		/* total packets transmitted	*/
+	__u32	rx_bytes;		/* total bytes received 	*/
+	__u32	tx_bytes;		/* total bytes transmitted	*/
+	__u32	rx_errors;		/* bad packets received		*/
+	__u32	tx_errors;		/* packet transmit problems	*/
+	__u32	rx_dropped;		/* no space in linux buffers	*/
+	__u32	tx_dropped;		/* no space available in linux	*/
+	__u32	multicast;		/* multicast packets received	*/
 	__u32	collisions;
+
 	/* detailed rx_errors: */
 	__u32	rx_length_errors;
-	__u32	rx_over_errors;
-	__u32	rx_crc_errors;
-	__u32	rx_frame_errors;
-	__u32	rx_fifo_errors;
-	__u32	rx_missed_errors;
+	__u32	rx_over_errors;		/* receiver ring buff overflow	*/
+	__u32	rx_crc_errors;		/* recved pkt with crc error	*/
+	__u32	rx_frame_errors;	/* recv'd frame alignment error */
+	__u32	rx_fifo_errors;		/* recv'r fifo overrun		*/
+	__u32	rx_missed_errors;	/* receiver missed packet	*/
 
 	/* detailed tx_errors */
 	__u32	tx_aborted_errors;
@@ -36,204 +37,29 @@ struct rtnl_link_stats {
 	__u32	rx_compressed;
 	__u32	tx_compressed;
 
-	__u32	rx_nohandler;
+	__u32	rx_nohandler;		/* dropped, no handler found	*/
 };
 
-/**
- * struct rtnl_link_stats64 - The main device statistics structure.
- *
- * @rx_packets: Number of good packets received by the interface.
- *   For hardware interfaces counts all good packets received from the device
- *   by the host, including packets which host had to drop at various stages
- *   of processing (even in the driver).
- *
- * @tx_packets: Number of packets successfully transmitted.
- *   For hardware interfaces counts packets which host was able to successfully
- *   hand over to the device, which does not necessarily mean that packets
- *   had been successfully transmitted out of the device, only that device
- *   acknowledged it copied them out of host memory.
- *
- * @rx_bytes: Number of good received bytes, corresponding to @rx_packets.
- *
- *   For IEEE 802.3 devices should count the length of Ethernet Frames
- *   excluding the FCS.
- *
- * @tx_bytes: Number of good transmitted bytes, corresponding to @tx_packets.
- *
- *   For IEEE 802.3 devices should count the length of Ethernet Frames
- *   excluding the FCS.
- *
- * @rx_errors: Total number of bad packets received on this network device.
- *   This counter must include events counted by @rx_length_errors,
- *   @rx_crc_errors, @rx_frame_errors and other errors not otherwise
- *   counted.
- *
- * @tx_errors: Total number of transmit problems.
- *   This counter must include events counter by @tx_aborted_errors,
- *   @tx_carrier_errors, @tx_fifo_errors, @tx_heartbeat_errors,
- *   @tx_window_errors and other errors not otherwise counted.
- *
- * @rx_dropped: Number of packets received but not processed,
- *   e.g. due to lack of resources or unsupported protocol.
- *   For hardware interfaces this counter may include packets discarded
- *   due to L2 address filtering but should not include packets dropped
- *   by the device due to buffer exhaustion which are counted separately in
- *   @rx_missed_errors (since procfs folds those two counters together).
- *
- * @tx_dropped: Number of packets dropped on their way to transmission,
- *   e.g. due to lack of resources.
- *
- * @multicast: Multicast packets received.
- *   For hardware interfaces this statistic is commonly calculated
- *   at the device level (unlike @rx_packets) and therefore may include
- *   packets which did not reach the host.
- *
- *   For IEEE 802.3 devices this counter may be equivalent to:
- *
- *    - 30.3.1.1.21 aMulticastFramesReceivedOK
- *
- * @collisions: Number of collisions during packet transmissions.
- *
- * @rx_length_errors: Number of packets dropped due to invalid length.
- *   Part of aggregate "frame" errors in `/proc/net/dev`.
- *
- *   For IEEE 802.3 devices this counter should be equivalent to a sum
- *   of the following attributes:
- *
- *    - 30.3.1.1.23 aInRangeLengthErrors
- *    - 30.3.1.1.24 aOutOfRangeLengthField
- *    - 30.3.1.1.25 aFrameTooLongErrors
- *
- * @rx_over_errors: Receiver FIFO overflow event counter.
- *
- *   Historically the count of overflow events. Such events may be
- *   reported in the receive descriptors or via interrupts, and may
- *   not correspond one-to-one with dropped packets.
- *
- *   The recommended interpretation for high speed interfaces is -
- *   number of packets dropped because they did not fit into buffers
- *   provided by the host, e.g. packets larger than MTU or next buffer
- *   in the ring was not available for a scatter transfer.
- *
- *   Part of aggregate "frame" errors in `/proc/net/dev`.
- *
- *   This statistics was historically used interchangeably with
- *   @rx_fifo_errors.
- *
- *   This statistic corresponds to hardware events and is not commonly used
- *   on software devices.
- *
- * @rx_crc_errors: Number of packets received with a CRC error.
- *   Part of aggregate "frame" errors in `/proc/net/dev`.
- *
- *   For IEEE 802.3 devices this counter must be equivalent to:
- *
- *    - 30.3.1.1.6 aFrameCheckSequenceErrors
- *
- * @rx_frame_errors: Receiver frame alignment errors.
- *   Part of aggregate "frame" errors in `/proc/net/dev`.
- *
- *   For IEEE 802.3 devices this counter should be equivalent to:
- *
- *    - 30.3.1.1.7 aAlignmentErrors
- *
- * @rx_fifo_errors: Receiver FIFO error counter.
- *
- *   Historically the count of overflow events. Those events may be
- *   reported in the receive descriptors or via interrupts, and may
- *   not correspond one-to-one with dropped packets.
- *
- *   This statistics was used interchangeably with @rx_over_errors.
- *   Not recommended for use in drivers for high speed interfaces.
- *
- *   This statistic is used on software devices, e.g. to count software
- *   packet queue overflow (can) or sequencing errors (GRE).
- *
- * @rx_missed_errors: Count of packets missed by the host.
- *   Folded into the "drop" counter in `/proc/net/dev`.
- *
- *   Counts number of packets dropped by the device due to lack
- *   of buffer space. This usually indicates that the host interface
- *   is slower than the network interface, or host is not keeping up
- *   with the receive packet rate.
- *
- *   This statistic corresponds to hardware events and is not used
- *   on software devices.
- *
- * @tx_aborted_errors:
- *   Part of aggregate "carrier" errors in `/proc/net/dev`.
- *   For IEEE 802.3 devices capable of half-duplex operation this counter
- *   must be equivalent to:
- *
- *    - 30.3.1.1.11 aFramesAbortedDueToXSColls
- *
- *   High speed interfaces may use this counter as a general device
- *   discard counter.
- *
- * @tx_carrier_errors: Number of frame transmission errors due to loss
- *   of carrier during transmission.
- *   Part of aggregate "carrier" errors in `/proc/net/dev`.
- *
- *   For IEEE 802.3 devices this counter must be equivalent to:
- *
- *    - 30.3.1.1.13 aCarrierSenseErrors
- *
- * @tx_fifo_errors: Number of frame transmission errors due to device
- *   FIFO underrun / underflow. This condition occurs when the device
- *   begins transmission of a frame but is unable to deliver the
- *   entire frame to the transmitter in time for transmission.
- *   Part of aggregate "carrier" errors in `/proc/net/dev`.
- *
- * @tx_heartbeat_errors: Number of Heartbeat / SQE Test errors for
- *   old half-duplex Ethernet.
- *   Part of aggregate "carrier" errors in `/proc/net/dev`.
- *
- *   For IEEE 802.3 devices possibly equivalent to:
- *
- *    - 30.3.2.1.4 aSQETestErrors
- *
- * @tx_window_errors: Number of frame transmission errors due
- *   to late collisions (for Ethernet - after the first 64B of transmission).
- *   Part of aggregate "carrier" errors in `/proc/net/dev`.
- *
- *   For IEEE 802.3 devices this counter must be equivalent to:
- *
- *    - 30.3.1.1.10 aLateCollisions
- *
- * @rx_compressed: Number of correctly received compressed packets.
- *   This counters is only meaningful for interfaces which support
- *   packet compression (e.g. CSLIP, PPP).
- *
- * @tx_compressed: Number of transmitted compressed packets.
- *   This counters is only meaningful for interfaces which support
- *   packet compression (e.g. CSLIP, PPP).
- *
- * @rx_nohandler: Number of packets received on the interface
- *   but dropped by the networking stack because the device is
- *   not designated to receive packets (e.g. backup link in a bond).
- *
- * @rx_otherhost_dropped: Number of packets dropped due to mismatch
- *   in destination MAC address.
- */
+/* The main device statistics structure */
 struct rtnl_link_stats64 {
-	__u64	rx_packets;
-	__u64	tx_packets;
-	__u64	rx_bytes;
-	__u64	tx_bytes;
-	__u64	rx_errors;
-	__u64	tx_errors;
-	__u64	rx_dropped;
-	__u64	tx_dropped;
-	__u64	multicast;
+	__u64	rx_packets;		/* total packets received	*/
+	__u64	tx_packets;		/* total packets transmitted	*/
+	__u64	rx_bytes;		/* total bytes received 	*/
+	__u64	tx_bytes;		/* total bytes transmitted	*/
+	__u64	rx_errors;		/* bad packets received		*/
+	__u64	tx_errors;		/* packet transmit problems	*/
+	__u64	rx_dropped;		/* no space in linux buffers	*/
+	__u64	tx_dropped;		/* no space available in linux	*/
+	__u64	multicast;		/* multicast packets received	*/
 	__u64	collisions;
 
 	/* detailed rx_errors: */
 	__u64	rx_length_errors;
-	__u64	rx_over_errors;
-	__u64	rx_crc_errors;
-	__u64	rx_frame_errors;
-	__u64	rx_fifo_errors;
-	__u64	rx_missed_errors;
+	__u64	rx_over_errors;		/* receiver ring buff overflow	*/
+	__u64	rx_crc_errors;		/* recved pkt with crc error	*/
+	__u64	rx_frame_errors;	/* recv'd frame alignment error */
+	__u64	rx_fifo_errors;		/* recv'r fifo overrun		*/
+	__u64	rx_missed_errors;	/* receiver missed packet	*/
 
 	/* detailed tx_errors */
 	__u64	tx_aborted_errors;
@@ -245,24 +71,8 @@ struct rtnl_link_stats64 {
 	/* for cslip etc */
 	__u64	rx_compressed;
 	__u64	tx_compressed;
-	__u64	rx_nohandler;
 
-	__u64	rx_otherhost_dropped;
-};
-
-/* Subset of link stats useful for in-HW collection. Meaning of the fields is as
- * for struct rtnl_link_stats64.
- */
-struct rtnl_hw_stats64 {
-	__u64	rx_packets;
-	__u64	tx_packets;
-	__u64	rx_bytes;
-	__u64	tx_bytes;
-	__u64	rx_errors;
-	__u64	tx_errors;
-	__u64	rx_dropped;
-	__u64	tx_dropped;
-	__u64	multicast;
+	__u64	rx_nohandler;		/* dropped, no handler found	*/
 };
 
 /* The struct should be in sync with struct ifmap */
@@ -360,38 +170,12 @@ enum {
 	IFLA_PROP_LIST,
 	IFLA_ALT_IFNAME, /* Alternative ifname */
 	IFLA_PERM_ADDRESS,
-	IFLA_PROTO_DOWN_REASON,
-
-	/* device (sysfs) name as parent, used instead
-	 * of IFLA_LINK where there's no parent netdev
-	 */
-	IFLA_PARENT_DEV_NAME,
-	IFLA_PARENT_DEV_BUS_NAME,
-	IFLA_GRO_MAX_SIZE,
-	IFLA_TSO_MAX_SIZE,
-	IFLA_TSO_MAX_SEGS,
-	IFLA_ALLMULTI,		/* Allmulti count: > 0 means acts ALLMULTI */
-
-	IFLA_DEVLINK_PORT,
-
-	IFLA_GSO_IPV4_MAX_SIZE,
-	IFLA_GRO_IPV4_MAX_SIZE,
-	IFLA_DPLL_PIN,
 	__IFLA_MAX
 };
 
 
 #define IFLA_MAX (__IFLA_MAX - 1)
 
-enum {
-	IFLA_PROTO_DOWN_REASON_UNSPEC,
-	IFLA_PROTO_DOWN_REASON_MASK,	/* u32, mask for reason bits */
-	IFLA_PROTO_DOWN_REASON_VALUE,   /* u32, reason bit value */
-
-	__IFLA_PROTO_DOWN_REASON_CNT,
-	IFLA_PROTO_DOWN_REASON_MAX = __IFLA_PROTO_DOWN_REASON_CNT - 1
-};
-
 /* backwards compatibility for userspace */
 #ifndef __KERNEL__
 #define IFLA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ifinfomsg))))
@@ -446,7 +230,6 @@ enum {
 	IFLA_INET6_ICMP6STATS,	/* statistics (icmpv6)		*/
 	IFLA_INET6_TOKEN,	/* device token			*/
 	IFLA_INET6_ADDR_GEN_MODE, /* implicit address generator mode */
-	IFLA_INET6_RA_MTU,	/* mtu carried in the RA message */
 	__IFLA_INET6_MAX
 };
 
@@ -509,7 +292,6 @@ enum {
 	IFLA_BR_MCAST_MLD_VERSION,
 	IFLA_BR_VLAN_STATS_PER_PORT,
 	IFLA_BR_MULTI_BOOLOPT,
-	IFLA_BR_MCAST_QUERIER_STATE,
 	__IFLA_BR_MAX,
 };
 
@@ -563,14 +345,6 @@ enum {
 	IFLA_BRPORT_BACKUP_PORT,
 	IFLA_BRPORT_MRP_RING_OPEN,
 	IFLA_BRPORT_MRP_IN_OPEN,
-	IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT,
-	IFLA_BRPORT_MCAST_EHT_HOSTS_CNT,
-	IFLA_BRPORT_LOCKED,
-	IFLA_BRPORT_MAB,
-	IFLA_BRPORT_MCAST_N_GROUPS,
-	IFLA_BRPORT_MCAST_MAX_GROUPS,
-	IFLA_BRPORT_NEIGH_VLAN_SUPPRESS,
-	IFLA_BRPORT_BACKUP_NHID,
 	__IFLA_BRPORT_MAX
 };
 #define IFLA_BRPORT_MAX (__IFLA_BRPORT_MAX - 1)
@@ -635,9 +409,6 @@ enum {
 	IFLA_MACVLAN_MACADDR,
 	IFLA_MACVLAN_MACADDR_DATA,
 	IFLA_MACVLAN_MACADDR_COUNT,
-	IFLA_MACVLAN_BC_QUEUE_LEN,
-	IFLA_MACVLAN_BC_QUEUE_LEN_USED,
-	IFLA_MACVLAN_BC_CUTOFF,
 	__IFLA_MACVLAN_MAX,
 };
 
@@ -659,7 +430,6 @@ enum macvlan_macaddr_mode {
 };
 
 #define MACVLAN_FLAG_NOPROMISC	1
-#define MACVLAN_FLAG_NODST	2 /* skip dst macvlan if matching src macvlan */
 
 /* VRF section */
 enum {
@@ -706,7 +476,6 @@ enum {
 	IFLA_XFRM_UNSPEC,
 	IFLA_XFRM_LINK,
 	IFLA_XFRM_IF_ID,
-	IFLA_XFRM_COLLECT_METADATA,
 	__IFLA_XFRM_MAX
 };
 
@@ -748,79 +517,7 @@ enum ipvlan_mode {
 #define IPVLAN_F_PRIVATE	0x01
 #define IPVLAN_F_VEPA		0x02
 
-/* Tunnel RTM header */
-struct tunnel_msg {
-	__u8 family;
-	__u8 flags;
-	__u16 reserved2;
-	__u32 ifindex;
-};
-
-/* netkit section */
-enum netkit_action {
-	NETKIT_NEXT	= -1,
-	NETKIT_PASS	= 0,
-	NETKIT_DROP	= 2,
-	NETKIT_REDIRECT	= 7,
-};
-
-enum netkit_mode {
-	NETKIT_L2,
-	NETKIT_L3,
-};
-
-enum {
-	IFLA_NETKIT_UNSPEC,
-	IFLA_NETKIT_PEER_INFO,
-	IFLA_NETKIT_PRIMARY,
-	IFLA_NETKIT_POLICY,
-	IFLA_NETKIT_PEER_POLICY,
-	IFLA_NETKIT_MODE,
-	__IFLA_NETKIT_MAX,
-};
-#define IFLA_NETKIT_MAX	(__IFLA_NETKIT_MAX - 1)
-
 /* VXLAN section */
-
-/* include statistics in the dump */
-#define TUNNEL_MSG_FLAG_STATS	0x01
-
-#define TUNNEL_MSG_VALID_USER_FLAGS TUNNEL_MSG_FLAG_STATS
-
-/* Embedded inside VXLAN_VNIFILTER_ENTRY_STATS */
-enum {
-	VNIFILTER_ENTRY_STATS_UNSPEC,
-	VNIFILTER_ENTRY_STATS_RX_BYTES,
-	VNIFILTER_ENTRY_STATS_RX_PKTS,
-	VNIFILTER_ENTRY_STATS_RX_DROPS,
-	VNIFILTER_ENTRY_STATS_RX_ERRORS,
-	VNIFILTER_ENTRY_STATS_TX_BYTES,
-	VNIFILTER_ENTRY_STATS_TX_PKTS,
-	VNIFILTER_ENTRY_STATS_TX_DROPS,
-	VNIFILTER_ENTRY_STATS_TX_ERRORS,
-	VNIFILTER_ENTRY_STATS_PAD,
-	__VNIFILTER_ENTRY_STATS_MAX
-};
-#define VNIFILTER_ENTRY_STATS_MAX (__VNIFILTER_ENTRY_STATS_MAX - 1)
-
-enum {
-	VXLAN_VNIFILTER_ENTRY_UNSPEC,
-	VXLAN_VNIFILTER_ENTRY_START,
-	VXLAN_VNIFILTER_ENTRY_END,
-	VXLAN_VNIFILTER_ENTRY_GROUP,
-	VXLAN_VNIFILTER_ENTRY_GROUP6,
-	VXLAN_VNIFILTER_ENTRY_STATS,
-	__VXLAN_VNIFILTER_ENTRY_MAX
-};
-#define VXLAN_VNIFILTER_ENTRY_MAX	(__VXLAN_VNIFILTER_ENTRY_MAX - 1)
-
-enum {
-	VXLAN_VNIFILTER_UNSPEC,
-	VXLAN_VNIFILTER_ENTRY,
-	__VXLAN_VNIFILTER_MAX
-};
-#define VXLAN_VNIFILTER_MAX	(__VXLAN_VNIFILTER_MAX - 1)
-
 enum {
 	IFLA_VXLAN_UNSPEC,
 	IFLA_VXLAN_ID,
@@ -852,8 +549,6 @@ enum {
 	IFLA_VXLAN_GPE,
 	IFLA_VXLAN_TTL_INHERIT,
 	IFLA_VXLAN_DF,
-	IFLA_VXLAN_VNIFILTER, /* only applicable with COLLECT_METADATA mode */
-	IFLA_VXLAN_LOCALBYPASS,
 	__IFLA_VXLAN_MAX
 };
 #define IFLA_VXLAN_MAX	(__IFLA_VXLAN_MAX - 1)
@@ -887,7 +582,6 @@ enum {
 	IFLA_GENEVE_LABEL,
 	IFLA_GENEVE_TTL_INHERIT,
 	IFLA_GENEVE_DF,
-	IFLA_GENEVE_INNER_PROTO_INHERIT,
 	__IFLA_GENEVE_MAX
 };
 #define IFLA_GENEVE_MAX	(__IFLA_GENEVE_MAX - 1)
@@ -900,18 +594,6 @@ enum ifla_geneve_df {
 	GENEVE_DF_MAX = __GENEVE_DF_END - 1,
 };
 
-/* Bareudp section  */
-enum {
-	IFLA_BAREUDP_UNSPEC,
-	IFLA_BAREUDP_PORT,
-	IFLA_BAREUDP_ETHERTYPE,
-	IFLA_BAREUDP_SRCPORT_MIN,
-	IFLA_BAREUDP_MULTIPROTO_MODE,
-	__IFLA_BAREUDP_MAX
-};
-
-#define IFLA_BAREUDP_MAX (__IFLA_BAREUDP_MAX - 1)
-
 /* PPP section */
 enum {
 	IFLA_PPP_UNSPEC,
@@ -933,8 +615,6 @@ enum {
 	IFLA_GTP_FD1,
 	IFLA_GTP_PDP_HASHSIZE,
 	IFLA_GTP_ROLE,
-	IFLA_GTP_CREATE_SOCKETS,
-	IFLA_GTP_RESTART_COUNT,
 	__IFLA_GTP_MAX,
 };
 #define IFLA_GTP_MAX (__IFLA_GTP_MAX - 1)
@@ -971,10 +651,6 @@ enum {
 	IFLA_BOND_AD_ACTOR_SYSTEM,
 	IFLA_BOND_TLB_DYNAMIC_LB,
 	IFLA_BOND_PEER_NOTIF_DELAY,
-	IFLA_BOND_AD_LACP_ACTIVE,
-	IFLA_BOND_MISSED_MAX,
-	IFLA_BOND_NS_IP6_TARGET,
-	IFLA_BOND_COUPLED_CONTROL,
 	__IFLA_BOND_MAX,
 };
 
@@ -1002,7 +678,6 @@ enum {
 	IFLA_BOND_SLAVE_AD_AGGREGATOR_ID,
 	IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE,
 	IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE,
-	IFLA_BOND_SLAVE_PRIO,
 	__IFLA_BOND_SLAVE_MAX,
 };
 
@@ -1220,14 +895,7 @@ enum {
 #define IFLA_IPOIB_MAX (__IFLA_IPOIB_MAX - 1)
 
 
-/* HSR/PRP section, both uses same interface */
-
-/* Different redundancy protocols for hsr device */
-enum {
-	HSR_PROTOCOL_HSR,
-	HSR_PROTOCOL_PRP,
-	HSR_PROTOCOL_MAX,
-};
+/* HSR section */
 
 enum {
 	IFLA_HSR_UNSPEC,
@@ -1237,9 +905,6 @@ enum {
 	IFLA_HSR_SUPERVISION_ADDR,	/* Supervision frame multicast addr */
 	IFLA_HSR_SEQ_NR,
 	IFLA_HSR_VERSION,		/* HSR version */
-	IFLA_HSR_PROTOCOL,		/* Indicate different protocol than
-					 * HSR. For example PRP.
-					 */
 	__IFLA_HSR_MAX,
 };
 
@@ -1272,17 +937,6 @@ enum {
 
 #define IFLA_STATS_FILTER_BIT(ATTR)	(1 << (ATTR - 1))
 
-enum {
-	IFLA_STATS_GETSET_UNSPEC,
-	IFLA_STATS_GET_FILTERS, /* Nest of IFLA_STATS_LINK_xxx, each a u32 with
-				 * a filter mask for the corresponding group.
-				 */
-	IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS, /* 0 or 1 as u8 */
-	__IFLA_STATS_GETSET_MAX,
-};
-
-#define IFLA_STATS_GETSET_MAX (__IFLA_STATS_GETSET_MAX - 1)
-
 /* These are embedded into IFLA_STATS_LINK_XSTATS:
  * [IFLA_STATS_LINK_XSTATS]
  * -> [LINK_XSTATS_TYPE_xxx]
@@ -1300,21 +954,10 @@ enum {
 enum {
 	IFLA_OFFLOAD_XSTATS_UNSPEC,
 	IFLA_OFFLOAD_XSTATS_CPU_HIT, /* struct rtnl_link_stats64 */
-	IFLA_OFFLOAD_XSTATS_HW_S_INFO,	/* HW stats info. A nest */
-	IFLA_OFFLOAD_XSTATS_L3_STATS,	/* struct rtnl_hw_stats64 */
 	__IFLA_OFFLOAD_XSTATS_MAX
 };
 #define IFLA_OFFLOAD_XSTATS_MAX (__IFLA_OFFLOAD_XSTATS_MAX - 1)
 
-enum {
-	IFLA_OFFLOAD_XSTATS_HW_S_INFO_UNSPEC,
-	IFLA_OFFLOAD_XSTATS_HW_S_INFO_REQUEST,		/* u8 */
-	IFLA_OFFLOAD_XSTATS_HW_S_INFO_USED,		/* u8 */
-	__IFLA_OFFLOAD_XSTATS_HW_S_INFO_MAX,
-};
-#define IFLA_OFFLOAD_XSTATS_HW_S_INFO_MAX \
-	(__IFLA_OFFLOAD_XSTATS_HW_S_INFO_MAX - 1)
-
 /* XDP section */
 
 #define XDP_FLAGS_UPDATE_IF_NOEXIST	(1U << 0)
@@ -1386,8 +1029,6 @@ enum {
 #define RMNET_FLAGS_INGRESS_MAP_COMMANDS          (1U << 1)
 #define RMNET_FLAGS_INGRESS_MAP_CKSUMV4           (1U << 2)
 #define RMNET_FLAGS_EGRESS_MAP_CKSUMV4            (1U << 3)
-#define RMNET_FLAGS_INGRESS_MAP_CKSUMV5           (1U << 4)
-#define RMNET_FLAGS_EGRESS_MAP_CKSUMV5            (1U << 5)
 
 enum {
 	IFLA_RMNET_UNSPEC,
@@ -1403,24 +1044,4 @@ struct ifla_rmnet_flags {
 	__u32	mask;
 };
 
-/* MCTP section */
-
-enum {
-	IFLA_MCTP_UNSPEC,
-	IFLA_MCTP_NET,
-	__IFLA_MCTP_MAX,
-};
-
-#define IFLA_MCTP_MAX (__IFLA_MCTP_MAX - 1)
-
-/* DSA section */
-
-enum {
-	IFLA_DSA_UNSPEC,
-	IFLA_DSA_MASTER,
-	__IFLA_DSA_MAX,
-};
-
-#define IFLA_DSA_MAX	(__IFLA_DSA_MAX - 1)
-
 #endif /* _UAPI_LINUX_IF_LINK_H */

include/uapi/linux/if_xdp.h

@@ -25,25 +25,9 @@
  * application.
  */
 #define XDP_USE_NEED_WAKEUP (1 << 3)
-/* By setting this option, userspace application indicates that it can
- * handle multiple descriptors per packet thus enabling AF_XDP to split
- * multi-buffer XDP frames into multiple Rx descriptors. Without this set
- * such frames will be dropped.
- */
-#define XDP_USE_SG	(1 << 4)
 
 /* Flags for xsk_umem_config flags */
-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG	(1 << 0)
-
-/* Force checksum calculation in software. Can be used for testing or
- * working around potential HW issues. This option causes performance
- * degradation and only works in XDP_COPY mode.
- */
-#define XDP_UMEM_TX_SW_CSUM		(1 << 1)
-
-/* Request to reserve tx_metadata_len bytes of per-chunk metadata.
- */
-#define XDP_UMEM_TX_METADATA_LEN	(1 << 2)
+#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0)
 
 struct sockaddr_xdp {
 	__u16 sxdp_family;
@@ -86,7 +70,6 @@ struct xdp_umem_reg {
 	__u32 chunk_size;
 	__u32 headroom;
 	__u32 flags;
-	__u32 tx_metadata_len;
 };
 
 struct xdp_statistics {
@@ -116,41 +99,6 @@ struct xdp_options {
 #define XSK_UNALIGNED_BUF_ADDR_MASK \
 	((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1)
 
-/* Request transmit timestamp. Upon completion, put it into tx_timestamp
- * field of union xsk_tx_metadata.
- */
-#define XDP_TXMD_FLAGS_TIMESTAMP		(1 << 0)
-
-/* Request transmit checksum offload. Checksum start position and offset
- * are communicated via csum_start and csum_offset fields of union
- * xsk_tx_metadata.
- */
-#define XDP_TXMD_FLAGS_CHECKSUM			(1 << 1)
-
-/* AF_XDP offloads request. 'request' union member is consumed by the driver
- * when the packet is being transmitted. 'completion' union member is
- * filled by the driver when the transmit completion arrives.
- */
-struct xsk_tx_metadata {
-	__u64 flags;
-
-	union {
-		struct {
-			/* XDP_TXMD_FLAGS_CHECKSUM */
-
-			/* Offset from desc->addr where checksumming should start. */
-			__u16 csum_start;
-			/* Offset from csum_start where checksum should be stored. */
-			__u16 csum_offset;
-		} request;
-
-		struct {
-			/* XDP_TXMD_FLAGS_TIMESTAMP */
-			__u64 tx_timestamp;
-		} completion;
-	};
-};
-
 /* Rx/Tx descriptor */
 struct xdp_desc {
 	__u64 addr;
@@ -160,14 +108,4 @@ struct xdp_desc {
 
 /* UMEM descriptor is __u64 */
 
-/* Flag indicating that the packet continues with the buffer pointed out by the
- * next frame in the ring. The end of the packet is signalled by setting this
- * bit to zero. For single buffer packets, every descriptor has 'options' set
- * to 0 and this maintains backward compatibility.
- */
-#define XDP_PKT_CONTD (1 << 0)
-
-/* TX packet carries valid metadata. */
-#define XDP_TX_METADATA (1 << 1)
-
 #endif /* _LINUX_IF_XDP_H */

include/uapi/linux/netdev.h

@@ -1,197 +0,0 @@
-/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
-/* Do not edit directly, auto-generated from: */
-/*	Documentation/netlink/specs/netdev.yaml */
-/* YNL-GEN uapi header */
-
-#ifndef _UAPI_LINUX_NETDEV_H
-#define _UAPI_LINUX_NETDEV_H
-
-#define NETDEV_FAMILY_NAME	"netdev"
-#define NETDEV_FAMILY_VERSION	1
-
-/**
- * enum netdev_xdp_act
- * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers
- *   (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX)
- * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT
- * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements
- *   ndo_xdp_xmit callback.
- * @NETDEV_XDP_ACT_XSK_ZEROCOPY: This feature informs if netdev supports AF_XDP
- *   in zero copy mode.
- * @NETDEV_XDP_ACT_HW_OFFLOAD: This feature informs if netdev supports XDP hw
- *   offloading.
- * @NETDEV_XDP_ACT_RX_SG: This feature informs if netdev implements non-linear
- *   XDP buffer support in the driver napi callback.
- * @NETDEV_XDP_ACT_NDO_XMIT_SG: This feature informs if netdev implements
- *   non-linear XDP buffer support in ndo_xdp_xmit callback.
- */
-enum netdev_xdp_act {
-	NETDEV_XDP_ACT_BASIC = 1,
-	NETDEV_XDP_ACT_REDIRECT = 2,
-	NETDEV_XDP_ACT_NDO_XMIT = 4,
-	NETDEV_XDP_ACT_XSK_ZEROCOPY = 8,
-	NETDEV_XDP_ACT_HW_OFFLOAD = 16,
-	NETDEV_XDP_ACT_RX_SG = 32,
-	NETDEV_XDP_ACT_NDO_XMIT_SG = 64,
-
-	/* private: */
-	NETDEV_XDP_ACT_MASK = 127,
-};
-
-/**
- * enum netdev_xdp_rx_metadata
- * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW
- *   timestamp via bpf_xdp_metadata_rx_timestamp().
- * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet
- *   hash via bpf_xdp_metadata_rx_hash().
- * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive
- *   packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag().
- */
-enum netdev_xdp_rx_metadata {
-	NETDEV_XDP_RX_METADATA_TIMESTAMP = 1,
-	NETDEV_XDP_RX_METADATA_HASH = 2,
-	NETDEV_XDP_RX_METADATA_VLAN_TAG = 4,
-};
-
-/**
- * enum netdev_xsk_flags
- * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported
- *   by the driver.
- * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the
- *   driver.
- */
-enum netdev_xsk_flags {
-	NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1,
-	NETDEV_XSK_FLAGS_TX_CHECKSUM = 2,
-};
-
-enum netdev_queue_type {
-	NETDEV_QUEUE_TYPE_RX,
-	NETDEV_QUEUE_TYPE_TX,
-};
-
-enum netdev_qstats_scope {
-	NETDEV_QSTATS_SCOPE_QUEUE = 1,
-};
-
-enum {
-	NETDEV_A_DEV_IFINDEX = 1,
-	NETDEV_A_DEV_PAD,
-	NETDEV_A_DEV_XDP_FEATURES,
-	NETDEV_A_DEV_XDP_ZC_MAX_SEGS,
-	NETDEV_A_DEV_XDP_RX_METADATA_FEATURES,
-	NETDEV_A_DEV_XSK_FEATURES,
-
-	__NETDEV_A_DEV_MAX,
-	NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1)
-};
-
-enum {
-	NETDEV_A_PAGE_POOL_ID = 1,
-	NETDEV_A_PAGE_POOL_IFINDEX,
-	NETDEV_A_PAGE_POOL_NAPI_ID,
-	NETDEV_A_PAGE_POOL_INFLIGHT,
-	NETDEV_A_PAGE_POOL_INFLIGHT_MEM,
-	NETDEV_A_PAGE_POOL_DETACH_TIME,
-
-	__NETDEV_A_PAGE_POOL_MAX,
-	NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1)
-};
-
-enum {
-	NETDEV_A_PAGE_POOL_STATS_INFO = 1,
-	NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8,
-	NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW,
-	NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER,
-	NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY,
-	NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL,
-	NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE,
-	NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED,
-	NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL,
-	NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING,
-	NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL,
-	NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT,
-
-	__NETDEV_A_PAGE_POOL_STATS_MAX,
-	NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1)
-};
-
-enum {
-	NETDEV_A_NAPI_IFINDEX = 1,
-	NETDEV_A_NAPI_ID,
-	NETDEV_A_NAPI_IRQ,
-	NETDEV_A_NAPI_PID,
-
-	__NETDEV_A_NAPI_MAX,
-	NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1)
-};
-
-enum {
-	NETDEV_A_QUEUE_ID = 1,
-	NETDEV_A_QUEUE_IFINDEX,
-	NETDEV_A_QUEUE_TYPE,
-	NETDEV_A_QUEUE_NAPI_ID,
-
-	__NETDEV_A_QUEUE_MAX,
-	NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1)
-};
-
-enum {
-	NETDEV_A_QSTATS_IFINDEX = 1,
-	NETDEV_A_QSTATS_QUEUE_TYPE,
-	NETDEV_A_QSTATS_QUEUE_ID,
-	NETDEV_A_QSTATS_SCOPE,
-	NETDEV_A_QSTATS_RX_PACKETS = 8,
-	NETDEV_A_QSTATS_RX_BYTES,
-	NETDEV_A_QSTATS_TX_PACKETS,
-	NETDEV_A_QSTATS_TX_BYTES,
-	NETDEV_A_QSTATS_RX_ALLOC_FAIL,
-	NETDEV_A_QSTATS_RX_HW_DROPS,
-	NETDEV_A_QSTATS_RX_HW_DROP_OVERRUNS,
-	NETDEV_A_QSTATS_RX_CSUM_COMPLETE,
-	NETDEV_A_QSTATS_RX_CSUM_UNNECESSARY,
-	NETDEV_A_QSTATS_RX_CSUM_NONE,
-	NETDEV_A_QSTATS_RX_CSUM_BAD,
-	NETDEV_A_QSTATS_RX_HW_GRO_PACKETS,
-	NETDEV_A_QSTATS_RX_HW_GRO_BYTES,
-	NETDEV_A_QSTATS_RX_HW_GRO_WIRE_PACKETS,
-	NETDEV_A_QSTATS_RX_HW_GRO_WIRE_BYTES,
-	NETDEV_A_QSTATS_RX_HW_DROP_RATELIMITS,
-	NETDEV_A_QSTATS_TX_HW_DROPS,
-	NETDEV_A_QSTATS_TX_HW_DROP_ERRORS,
-	NETDEV_A_QSTATS_TX_CSUM_NONE,
-	NETDEV_A_QSTATS_TX_NEEDS_CSUM,
-	NETDEV_A_QSTATS_TX_HW_GSO_PACKETS,
-	NETDEV_A_QSTATS_TX_HW_GSO_BYTES,
-	NETDEV_A_QSTATS_TX_HW_GSO_WIRE_PACKETS,
-	NETDEV_A_QSTATS_TX_HW_GSO_WIRE_BYTES,
-	NETDEV_A_QSTATS_TX_HW_DROP_RATELIMITS,
-	NETDEV_A_QSTATS_TX_STOP,
-	NETDEV_A_QSTATS_TX_WAKE,
-
-	__NETDEV_A_QSTATS_MAX,
-	NETDEV_A_QSTATS_MAX = (__NETDEV_A_QSTATS_MAX - 1)
-};
-
-enum {
-	NETDEV_CMD_DEV_GET = 1,
-	NETDEV_CMD_DEV_ADD_NTF,
-	NETDEV_CMD_DEV_DEL_NTF,
-	NETDEV_CMD_DEV_CHANGE_NTF,
-	NETDEV_CMD_PAGE_POOL_GET,
-	NETDEV_CMD_PAGE_POOL_ADD_NTF,
-	NETDEV_CMD_PAGE_POOL_DEL_NTF,
-	NETDEV_CMD_PAGE_POOL_CHANGE_NTF,
-	NETDEV_CMD_PAGE_POOL_STATS_GET,
-	NETDEV_CMD_QUEUE_GET,
-	NETDEV_CMD_NAPI_GET,
-	NETDEV_CMD_QSTATS_GET,
-
-	__NETDEV_CMD_MAX,
-	NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1)
-};
-
-#define NETDEV_MCGRP_MGMT	"mgmt"
-#define NETDEV_MCGRP_PAGE_POOL	"page-pool"
-
-#endif /* _UAPI_LINUX_NETDEV_H */

include/uapi/linux/pkt_cls.h

@@ -1,565 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
-#ifndef __LINUX_PKT_CLS_H
-#define __LINUX_PKT_CLS_H
-
-#include <linux/types.h>
-#include <linux/pkt_sched.h>
-
-#define TC_COOKIE_MAX_SIZE 16
-
-/* Action attributes */
-enum {
-	TCA_ACT_UNSPEC,
-	TCA_ACT_KIND,
-	TCA_ACT_OPTIONS,
-	TCA_ACT_INDEX,
-	TCA_ACT_STATS,
-	TCA_ACT_PAD,
-	TCA_ACT_COOKIE,
-	__TCA_ACT_MAX
-};
-
-#define TCA_ACT_MAX __TCA_ACT_MAX
-#define TCA_OLD_COMPAT (TCA_ACT_MAX+1)
-#define TCA_ACT_MAX_PRIO 32
-#define TCA_ACT_BIND	1
-#define TCA_ACT_NOBIND	0
-#define TCA_ACT_UNBIND	1
-#define TCA_ACT_NOUNBIND	0
-#define TCA_ACT_REPLACE		1
-#define TCA_ACT_NOREPLACE	0
-
-#define TC_ACT_UNSPEC	(-1)
-#define TC_ACT_OK		0
-#define TC_ACT_RECLASSIFY	1
-#define TC_ACT_SHOT		2
-#define TC_ACT_PIPE		3
-#define TC_ACT_STOLEN		4
-#define TC_ACT_QUEUED		5
-#define TC_ACT_REPEAT		6
-#define TC_ACT_REDIRECT		7
-#define TC_ACT_TRAP		8 /* For hw path, this means "trap to cpu"
-				   * and don't further process the frame
-				   * in hardware. For sw path, this is
-				   * equivalent of TC_ACT_STOLEN - drop
-				   * the skb and act like everything
-				   * is alright.
-				   */
-#define TC_ACT_VALUE_MAX	TC_ACT_TRAP
-
-/* There is a special kind of actions called "extended actions",
- * which need a value parameter. These have a local opcode located in
- * the highest nibble, starting from 1. The rest of the bits
- * are used to carry the value. These two parts together make
- * a combined opcode.
- */
-#define __TC_ACT_EXT_SHIFT 28
-#define __TC_ACT_EXT(local) ((local) << __TC_ACT_EXT_SHIFT)
-#define TC_ACT_EXT_VAL_MASK ((1 << __TC_ACT_EXT_SHIFT) - 1)
-#define TC_ACT_EXT_OPCODE(combined) ((combined) & (~TC_ACT_EXT_VAL_MASK))
-#define TC_ACT_EXT_CMP(combined, opcode) (TC_ACT_EXT_OPCODE(combined) == opcode)
-
-#define TC_ACT_JUMP __TC_ACT_EXT(1)
-#define TC_ACT_GOTO_CHAIN __TC_ACT_EXT(2)
-#define TC_ACT_EXT_OPCODE_MAX	TC_ACT_GOTO_CHAIN
-
-/* Action type identifiers*/
-enum {
-	TCA_ID_UNSPEC=0,
-	TCA_ID_POLICE=1,
-	/* other actions go here */
-	__TCA_ID_MAX=255
-};
-
-#define TCA_ID_MAX __TCA_ID_MAX
-
-struct tc_police {
-	__u32			index;
-	int			action;
-#define TC_POLICE_UNSPEC	TC_ACT_UNSPEC
-#define TC_POLICE_OK		TC_ACT_OK
-#define TC_POLICE_RECLASSIFY	TC_ACT_RECLASSIFY
-#define TC_POLICE_SHOT		TC_ACT_SHOT
-#define TC_POLICE_PIPE		TC_ACT_PIPE
-
-	__u32			limit;
-	__u32			burst;
-	__u32			mtu;
-	struct tc_ratespec	rate;
-	struct tc_ratespec	peakrate;
-	int			refcnt;
-	int			bindcnt;
-	__u32			capab;
-};
-
-struct tcf_t {
-	__u64   install;
-	__u64   lastuse;
-	__u64   expires;
-	__u64   firstuse;
-};
-
-struct tc_cnt {
-	int                   refcnt;
-	int                   bindcnt;
-};
-
-#define tc_gen \
-	__u32                 index; \
-	__u32                 capab; \
-	int                   action; \
-	int                   refcnt; \
-	int                   bindcnt
-
-enum {
-	TCA_POLICE_UNSPEC,
-	TCA_POLICE_TBF,
-	TCA_POLICE_RATE,
-	TCA_POLICE_PEAKRATE,
-	TCA_POLICE_AVRATE,
-	TCA_POLICE_RESULT,
-	TCA_POLICE_TM,
-	TCA_POLICE_PAD,
-	__TCA_POLICE_MAX
-#define TCA_POLICE_RESULT TCA_POLICE_RESULT
-};
-
-#define TCA_POLICE_MAX (__TCA_POLICE_MAX - 1)
-
-/* tca flags definitions */
-#define TCA_CLS_FLAGS_SKIP_HW	(1 << 0) /* don't offload filter to HW */
-#define TCA_CLS_FLAGS_SKIP_SW	(1 << 1) /* don't use filter in SW */
-#define TCA_CLS_FLAGS_IN_HW	(1 << 2) /* filter is offloaded to HW */
-#define TCA_CLS_FLAGS_NOT_IN_HW (1 << 3) /* filter isn't offloaded to HW */
-#define TCA_CLS_FLAGS_VERBOSE	(1 << 4) /* verbose logging */
-
-/* U32 filters */
-
-#define TC_U32_HTID(h) ((h)&0xFFF00000)
-#define TC_U32_USERHTID(h) (TC_U32_HTID(h)>>20)
-#define TC_U32_HASH(h) (((h)>>12)&0xFF)
-#define TC_U32_NODE(h) ((h)&0xFFF)
-#define TC_U32_KEY(h) ((h)&0xFFFFF)
-#define TC_U32_UNSPEC	0
-#define TC_U32_ROOT	(0xFFF00000)
-
-enum {
-	TCA_U32_UNSPEC,
-	TCA_U32_CLASSID,
-	TCA_U32_HASH,
-	TCA_U32_LINK,
-	TCA_U32_DIVISOR,
-	TCA_U32_SEL,
-	TCA_U32_POLICE,
-	TCA_U32_ACT,
-	TCA_U32_INDEV,
-	TCA_U32_PCNT,
-	TCA_U32_MARK,
-	TCA_U32_FLAGS,
-	TCA_U32_PAD,
-	__TCA_U32_MAX
-};
-
-#define TCA_U32_MAX (__TCA_U32_MAX - 1)
-
-struct tc_u32_key {
-	__be32		mask;
-	__be32		val;
-	int		off;
-	int		offmask;
-};
-
-struct tc_u32_sel {
-	unsigned char		flags;
-	unsigned char		offshift;
-	unsigned char		nkeys;
-
-	__be16			offmask;
-	__u16			off;
-	short			offoff;
-
-	short			hoff;
-	__be32			hmask;
-	struct tc_u32_key	keys[];
-};
-
-struct tc_u32_mark {
-	__u32		val;
-	__u32		mask;
-	__u32		success;
-};
-
-struct tc_u32_pcnt {
-	__u64 rcnt;
-	__u64 rhit;
-	__u64 kcnts[];
-};
-
-/* Flags */
-
-#define TC_U32_TERMINAL		1
-#define TC_U32_OFFSET		2
-#define TC_U32_VAROFFSET	4
-#define TC_U32_EAT		8
-
-#define TC_U32_MAXDEPTH 8
-
-/* ROUTE filter */
-
-enum {
-	TCA_ROUTE4_UNSPEC,
-	TCA_ROUTE4_CLASSID,
-	TCA_ROUTE4_TO,
-	TCA_ROUTE4_FROM,
-	TCA_ROUTE4_IIF,
-	TCA_ROUTE4_POLICE,
-	TCA_ROUTE4_ACT,
-	__TCA_ROUTE4_MAX
-};
-
-#define TCA_ROUTE4_MAX (__TCA_ROUTE4_MAX - 1)
-
-
-/* FW filter */
-
-enum {
-	TCA_FW_UNSPEC,
-	TCA_FW_CLASSID,
-	TCA_FW_POLICE,
-	TCA_FW_INDEV,
-	TCA_FW_ACT, /* used by CONFIG_NET_CLS_ACT */
-	TCA_FW_MASK,
-	__TCA_FW_MAX
-};
-
-#define TCA_FW_MAX (__TCA_FW_MAX - 1)
-
-/* Flow filter */
-
-enum {
-	FLOW_KEY_SRC,
-	FLOW_KEY_DST,
-	FLOW_KEY_PROTO,
-	FLOW_KEY_PROTO_SRC,
-	FLOW_KEY_PROTO_DST,
-	FLOW_KEY_IIF,
-	FLOW_KEY_PRIORITY,
-	FLOW_KEY_MARK,
-	FLOW_KEY_NFCT,
-	FLOW_KEY_NFCT_SRC,
-	FLOW_KEY_NFCT_DST,
-	FLOW_KEY_NFCT_PROTO_SRC,
-	FLOW_KEY_NFCT_PROTO_DST,
-	FLOW_KEY_RTCLASSID,
-	FLOW_KEY_SKUID,
-	FLOW_KEY_SKGID,
-	FLOW_KEY_VLAN_TAG,
-	FLOW_KEY_RXHASH,
-	__FLOW_KEY_MAX,
-};
-
-#define FLOW_KEY_MAX	(__FLOW_KEY_MAX - 1)
-
-enum {
-	FLOW_MODE_MAP,
-	FLOW_MODE_HASH,
-};
-
-enum {
-	TCA_FLOW_UNSPEC,
-	TCA_FLOW_KEYS,
-	TCA_FLOW_MODE,
-	TCA_FLOW_BASECLASS,
-	TCA_FLOW_RSHIFT,
-	TCA_FLOW_ADDEND,
-	TCA_FLOW_MASK,
-	TCA_FLOW_XOR,
-	TCA_FLOW_DIVISOR,
-	TCA_FLOW_ACT,
-	TCA_FLOW_POLICE,
-	TCA_FLOW_EMATCHES,
-	TCA_FLOW_PERTURB,
-	__TCA_FLOW_MAX
-};
-
-#define TCA_FLOW_MAX	(__TCA_FLOW_MAX - 1)
-
-/* Basic filter */
-
-enum {
-	TCA_BASIC_UNSPEC,
-	TCA_BASIC_CLASSID,
-	TCA_BASIC_EMATCHES,
-	TCA_BASIC_ACT,
-	TCA_BASIC_POLICE,
-	__TCA_BASIC_MAX
-};
-
-#define TCA_BASIC_MAX (__TCA_BASIC_MAX - 1)
-
-
-/* Cgroup classifier */
-
-enum {
-	TCA_CGROUP_UNSPEC,
-	TCA_CGROUP_ACT,
-	TCA_CGROUP_POLICE,
-	TCA_CGROUP_EMATCHES,
-	__TCA_CGROUP_MAX,
-};
-
-#define TCA_CGROUP_MAX (__TCA_CGROUP_MAX - 1)
-
-/* BPF classifier */
-
-#define TCA_BPF_FLAG_ACT_DIRECT		(1 << 0)
-
-enum {
-	TCA_BPF_UNSPEC,
-	TCA_BPF_ACT,
-	TCA_BPF_POLICE,
-	TCA_BPF_CLASSID,
-	TCA_BPF_OPS_LEN,
-	TCA_BPF_OPS,
-	TCA_BPF_FD,
-	TCA_BPF_NAME,
-	TCA_BPF_FLAGS,
-	TCA_BPF_FLAGS_GEN,
-	TCA_BPF_TAG,
-	TCA_BPF_ID,
-	__TCA_BPF_MAX,
-};
-
-#define TCA_BPF_MAX (__TCA_BPF_MAX - 1)
-
-/* Flower classifier */
-
-enum {
-	TCA_FLOWER_UNSPEC,
-	TCA_FLOWER_CLASSID,
-	TCA_FLOWER_INDEV,
-	TCA_FLOWER_ACT,
-	TCA_FLOWER_KEY_ETH_DST,		/* ETH_ALEN */
-	TCA_FLOWER_KEY_ETH_DST_MASK,	/* ETH_ALEN */
-	TCA_FLOWER_KEY_ETH_SRC,		/* ETH_ALEN */
-	TCA_FLOWER_KEY_ETH_SRC_MASK,	/* ETH_ALEN */
-	TCA_FLOWER_KEY_ETH_TYPE,	/* be16 */
-	TCA_FLOWER_KEY_IP_PROTO,	/* u8 */
-	TCA_FLOWER_KEY_IPV4_SRC,	/* be32 */
-	TCA_FLOWER_KEY_IPV4_SRC_MASK,	/* be32 */
-	TCA_FLOWER_KEY_IPV4_DST,	/* be32 */
-	TCA_FLOWER_KEY_IPV4_DST_MASK,	/* be32 */
-	TCA_FLOWER_KEY_IPV6_SRC,	/* struct in6_addr */
-	TCA_FLOWER_KEY_IPV6_SRC_MASK,	/* struct in6_addr */
-	TCA_FLOWER_KEY_IPV6_DST,	/* struct in6_addr */
-	TCA_FLOWER_KEY_IPV6_DST_MASK,	/* struct in6_addr */
-	TCA_FLOWER_KEY_TCP_SRC,		/* be16 */
-	TCA_FLOWER_KEY_TCP_DST,		/* be16 */
-	TCA_FLOWER_KEY_UDP_SRC,		/* be16 */
-	TCA_FLOWER_KEY_UDP_DST,		/* be16 */
-
-	TCA_FLOWER_FLAGS,
-	TCA_FLOWER_KEY_VLAN_ID,		/* be16 */
-	TCA_FLOWER_KEY_VLAN_PRIO,	/* u8   */
-	TCA_FLOWER_KEY_VLAN_ETH_TYPE,	/* be16 */
-
-	TCA_FLOWER_KEY_ENC_KEY_ID,	/* be32 */
-	TCA_FLOWER_KEY_ENC_IPV4_SRC,	/* be32 */
-	TCA_FLOWER_KEY_ENC_IPV4_SRC_MASK,/* be32 */
-	TCA_FLOWER_KEY_ENC_IPV4_DST,	/* be32 */
-	TCA_FLOWER_KEY_ENC_IPV4_DST_MASK,/* be32 */
-	TCA_FLOWER_KEY_ENC_IPV6_SRC,	/* struct in6_addr */
-	TCA_FLOWER_KEY_ENC_IPV6_SRC_MASK,/* struct in6_addr */
-	TCA_FLOWER_KEY_ENC_IPV6_DST,	/* struct in6_addr */
-	TCA_FLOWER_KEY_ENC_IPV6_DST_MASK,/* struct in6_addr */
-
-	TCA_FLOWER_KEY_TCP_SRC_MASK,	/* be16 */
-	TCA_FLOWER_KEY_TCP_DST_MASK,	/* be16 */
-	TCA_FLOWER_KEY_UDP_SRC_MASK,	/* be16 */
-	TCA_FLOWER_KEY_UDP_DST_MASK,	/* be16 */
-	TCA_FLOWER_KEY_SCTP_SRC_MASK,	/* be16 */
-	TCA_FLOWER_KEY_SCTP_DST_MASK,	/* be16 */
-
-	TCA_FLOWER_KEY_SCTP_SRC,	/* be16 */
-	TCA_FLOWER_KEY_SCTP_DST,	/* be16 */
-
-	TCA_FLOWER_KEY_ENC_UDP_SRC_PORT,	/* be16 */
-	TCA_FLOWER_KEY_ENC_UDP_SRC_PORT_MASK,	/* be16 */
-	TCA_FLOWER_KEY_ENC_UDP_DST_PORT,	/* be16 */
-	TCA_FLOWER_KEY_ENC_UDP_DST_PORT_MASK,	/* be16 */
-
-	TCA_FLOWER_KEY_FLAGS,		/* be32 */
-	TCA_FLOWER_KEY_FLAGS_MASK,	/* be32 */
-
-	TCA_FLOWER_KEY_ICMPV4_CODE,	/* u8 */
-	TCA_FLOWER_KEY_ICMPV4_CODE_MASK,/* u8 */
-	TCA_FLOWER_KEY_ICMPV4_TYPE,	/* u8 */
-	TCA_FLOWER_KEY_ICMPV4_TYPE_MASK,/* u8 */
-	TCA_FLOWER_KEY_ICMPV6_CODE,	/* u8 */
-	TCA_FLOWER_KEY_ICMPV6_CODE_MASK,/* u8 */
-	TCA_FLOWER_KEY_ICMPV6_TYPE,	/* u8 */
-	TCA_FLOWER_KEY_ICMPV6_TYPE_MASK,/* u8 */
-
-	TCA_FLOWER_KEY_ARP_SIP,		/* be32 */
-	TCA_FLOWER_KEY_ARP_SIP_MASK,	/* be32 */
-	TCA_FLOWER_KEY_ARP_TIP,		/* be32 */
-	TCA_FLOWER_KEY_ARP_TIP_MASK,	/* be32 */
-	TCA_FLOWER_KEY_ARP_OP,		/* u8 */
-	TCA_FLOWER_KEY_ARP_OP_MASK,	/* u8 */
-	TCA_FLOWER_KEY_ARP_SHA,		/* ETH_ALEN */
-	TCA_FLOWER_KEY_ARP_SHA_MASK,	/* ETH_ALEN */
-	TCA_FLOWER_KEY_ARP_THA,		/* ETH_ALEN */
-	TCA_FLOWER_KEY_ARP_THA_MASK,	/* ETH_ALEN */
-
-	TCA_FLOWER_KEY_MPLS_TTL,	/* u8 - 8 bits */
-	TCA_FLOWER_KEY_MPLS_BOS,	/* u8 - 1 bit */
-	TCA_FLOWER_KEY_MPLS_TC,		/* u8 - 3 bits */
-	TCA_FLOWER_KEY_MPLS_LABEL,	/* be32 - 20 bits */
-
-	TCA_FLOWER_KEY_TCP_FLAGS,	/* be16 */
-	TCA_FLOWER_KEY_TCP_FLAGS_MASK,	/* be16 */
-
-	TCA_FLOWER_KEY_IP_TOS,		/* u8 */
-	TCA_FLOWER_KEY_IP_TOS_MASK,	/* u8 */
-	TCA_FLOWER_KEY_IP_TTL,		/* u8 */
-	TCA_FLOWER_KEY_IP_TTL_MASK,	/* u8 */
-
-	TCA_FLOWER_KEY_CVLAN_ID,	/* be16 */
-	TCA_FLOWER_KEY_CVLAN_PRIO,	/* u8   */
-	TCA_FLOWER_KEY_CVLAN_ETH_TYPE,	/* be16 */
-
-	TCA_FLOWER_KEY_ENC_IP_TOS,	/* u8 */
-	TCA_FLOWER_KEY_ENC_IP_TOS_MASK,	/* u8 */
-	TCA_FLOWER_KEY_ENC_IP_TTL,	/* u8 */
-	TCA_FLOWER_KEY_ENC_IP_TTL_MASK,	/* u8 */
-
-	TCA_FLOWER_KEY_ENC_OPTS,
-	TCA_FLOWER_KEY_ENC_OPTS_MASK,
-
-	TCA_FLOWER_IN_HW_COUNT,
-
-	__TCA_FLOWER_MAX,
-};
-
-#define TCA_FLOWER_MAX (__TCA_FLOWER_MAX - 1)
-
-enum {
-	TCA_FLOWER_KEY_ENC_OPTS_UNSPEC,
-	TCA_FLOWER_KEY_ENC_OPTS_GENEVE, /* Nested
-					 * TCA_FLOWER_KEY_ENC_OPT_GENEVE_
-					 * attributes
-					 */
-	__TCA_FLOWER_KEY_ENC_OPTS_MAX,
-};
-
-#define TCA_FLOWER_KEY_ENC_OPTS_MAX (__TCA_FLOWER_KEY_ENC_OPTS_MAX - 1)
-
-enum {
-	TCA_FLOWER_KEY_ENC_OPT_GENEVE_UNSPEC,
-	TCA_FLOWER_KEY_ENC_OPT_GENEVE_CLASS,            /* u16 */
-	TCA_FLOWER_KEY_ENC_OPT_GENEVE_TYPE,             /* u8 */
-	TCA_FLOWER_KEY_ENC_OPT_GENEVE_DATA,             /* 4 to 128 bytes */
-
-	__TCA_FLOWER_KEY_ENC_OPT_GENEVE_MAX,
-};
-
-#define TCA_FLOWER_KEY_ENC_OPT_GENEVE_MAX \
-		(__TCA_FLOWER_KEY_ENC_OPT_GENEVE_MAX - 1)
-
-enum {
-	TCA_FLOWER_KEY_FLAGS_IS_FRAGMENT = (1 << 0),
-	TCA_FLOWER_KEY_FLAGS_FRAG_IS_FIRST = (1 << 1),
-};
-
-/* Match-all classifier */
-
-enum {
-	TCA_MATCHALL_UNSPEC,
-	TCA_MATCHALL_CLASSID,
-	TCA_MATCHALL_ACT,
-	TCA_MATCHALL_FLAGS,
-	__TCA_MATCHALL_MAX,
-};
-
-#define TCA_MATCHALL_MAX (__TCA_MATCHALL_MAX - 1)
-
-/* Extended Matches */
-
-struct tcf_ematch_tree_hdr {
-	__u16		nmatches;
-	__u16		progid;
-};
-
-enum {
-	TCA_EMATCH_TREE_UNSPEC,
-	TCA_EMATCH_TREE_HDR,
-	TCA_EMATCH_TREE_LIST,
-	__TCA_EMATCH_TREE_MAX
-};
-#define TCA_EMATCH_TREE_MAX (__TCA_EMATCH_TREE_MAX - 1)
-
-struct tcf_ematch_hdr {
-	__u16		matchid;
-	__u16		kind;
-	__u16		flags;
-	__u16		pad; /* currently unused */
-};
-
-/*  0                   1
- *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 
- * +-----------------------+-+-+---+
- * |         Unused        |S|I| R |
- * +-----------------------+-+-+---+
- *
- * R(2) ::= relation to next ematch
- *          where: 0 0 END (last ematch)
- *                 0 1 AND
- *                 1 0 OR
- *                 1 1 Unused (invalid)
- * I(1) ::= invert result
- * S(1) ::= simple payload
- */
-#define TCF_EM_REL_END	0
-#define TCF_EM_REL_AND	(1<<0)
-#define TCF_EM_REL_OR	(1<<1)
-#define TCF_EM_INVERT	(1<<2)
-#define TCF_EM_SIMPLE	(1<<3)
-
-#define TCF_EM_REL_MASK	3
-#define TCF_EM_REL_VALID(v) (((v) & TCF_EM_REL_MASK) != TCF_EM_REL_MASK)
-
-enum {
-	TCF_LAYER_LINK,
-	TCF_LAYER_NETWORK,
-	TCF_LAYER_TRANSPORT,
-	__TCF_LAYER_MAX
-};
-#define TCF_LAYER_MAX (__TCF_LAYER_MAX - 1)
-
-/* Ematch type assignments
- *   1..32767		Reserved for ematches inside kernel tree
- *   32768..65535	Free to use, not reliable
- */
-#define	TCF_EM_CONTAINER	0
-#define	TCF_EM_CMP		1
-#define	TCF_EM_NBYTE		2
-#define	TCF_EM_U32		3
-#define	TCF_EM_META		4
-#define	TCF_EM_TEXT		5
-#define	TCF_EM_VLAN		6
-#define	TCF_EM_CANID		7
-#define	TCF_EM_IPSET		8
-#define	TCF_EM_IPT		9
-#define	TCF_EM_MAX		9
-
-enum {
-	TCF_EM_PROG_TC
-};
-
-enum {
-	TCF_EM_OPND_EQ,
-	TCF_EM_OPND_GT,
-	TCF_EM_OPND_LT
-};
-
-#endif

scripts/build-fuzzers.sh

@@ -1,82 +0,0 @@
-#!/bin/bash
-set -eux
-
-SANITIZER=${SANITIZER:-address}
-flags="-O1 -fno-omit-frame-pointer -g -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=$SANITIZER -fsanitize=fuzzer-no-link"
-
-export CC=${CC:-clang}
-export CFLAGS=${CFLAGS:-$flags}
-
-export CXX=${CXX:-clang++}
-export CXXFLAGS=${CXXFLAGS:-$flags}
-
-cd "$(dirname -- "$0")/.."
-
-export OUT=${OUT:-"$(pwd)/out"}
-mkdir -p "$OUT"
-
-export LIB_FUZZING_ENGINE=${LIB_FUZZING_ENGINE:--fsanitize=fuzzer}
-
-# libelf is compiled with _FORTIFY_SOURCE by default and it
-# isn't compatible with MSan. It was borrowed
-# from https://github.com/google/oss-fuzz/pull/7422
-if [[ "$SANITIZER" == memory ]]; then
-    CFLAGS+=" -U_FORTIFY_SOURCE"
-    CXXFLAGS+=" -U_FORTIFY_SOURCE"
-fi
-
-# The alignment check is turned off by default on OSS-Fuzz/CFLite so it should be
-# turned on explicitly there. It was borrowed from
-# https://github.com/google/oss-fuzz/pull/7092
-if [[ "$SANITIZER" == undefined ]]; then
-    additional_ubsan_checks=alignment
-    UBSAN_FLAGS="-fsanitize=$additional_ubsan_checks -fno-sanitize-recover=$additional_ubsan_checks"
-    CFLAGS+=" $UBSAN_FLAGS"
-    CXXFLAGS+=" $UBSAN_FLAGS"
-fi
-
-# Ideally libbelf should be built using release tarballs available
-# at https://sourceware.org/elfutils/ftp/. Unfortunately sometimes they
-# fail to compile (for example, elfutils-0.185 fails to compile with LDFLAGS enabled
-# due to https://bugs.gentoo.org/794601) so let's just point the script to
-# commits referring to versions of libelf that actually can be built
-rm -rf elfutils
-git clone https://sourceware.org/git/elfutils.git
-(
-cd elfutils
-git checkout 67a187d4c1790058fc7fd218317851cb68bb087c
-git log --oneline -1
-
-# ASan isn't compatible with -Wl,--no-undefined: https://github.com/google/sanitizers/issues/380
-sed -i 's/^\(NO_UNDEFINED=\).*/\1/' configure.ac
-
-# ASan isn't compatible with -Wl,-z,defs either:
-# https://clang.llvm.org/docs/AddressSanitizer.html#usage
-sed -i 's/^\(ZDEFS_LDFLAGS=\).*/\1/' configure.ac
-
-if [[ "$SANITIZER" == undefined ]]; then
-    # That's basicaly what --enable-sanitize-undefined does to turn off unaligned access
-    # elfutils heavily relies on on i386/x86_64 but without changing compiler flags along the way
-    sed -i 's/\(check_undefined_val\)=[0-9]/\1=1/' configure.ac
-fi
-
-autoreconf -i -f
-if ! ./configure --enable-maintainer-mode --disable-debuginfod --disable-libdebuginfod \
-            --disable-demangler --without-bzlib --without-lzma --without-zstd \
-	    CC="$CC" CFLAGS="-Wno-error $CFLAGS" CXX="$CXX" CXXFLAGS="-Wno-error $CXXFLAGS" LDFLAGS="$CFLAGS"; then
-    cat config.log
-    exit 1
-fi
-
-make -C config -j$(nproc) V=1
-make -C lib -j$(nproc) V=1
-make -C libelf -j$(nproc) V=1
-)
-
-make -C src BUILD_STATIC_ONLY=y V=1 clean
-make -C src -j$(nproc) CFLAGS="-I$(pwd)/elfutils/libelf $CFLAGS" BUILD_STATIC_ONLY=y V=1
-
-$CC $CFLAGS -Isrc -Iinclude -Iinclude/uapi -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64  -c fuzz/bpf-object-fuzzer.c -o bpf-object-fuzzer.o
-$CXX $CXXFLAGS $LIB_FUZZING_ENGINE bpf-object-fuzzer.o src/libbpf.a "$(pwd)/elfutils/libelf/libelf.a" -l:libz.a -o "$OUT/bpf-object-fuzzer"
-
-cp fuzz/bpf-object-fuzzer_seed_corpus.zip "$OUT"

scripts/check-reallocarray.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+# Usage: check-reallocarray.sh cc_path [cc_args...]
+
+tfile=$(mktemp /tmp/test_reallocarray_XXXXXXXX.c)
+ofile=${tfile%.c}.o
+
+cat > $tfile <<EOL
+#define _GNU_SOURCE
+#include <stdlib.h>
+
+int main(void)
+{
+	return !!reallocarray(NULL, 1, 1);
+}
+EOL
+
+"$@" $tfile -o $ofile >/dev/null 2>&1
+if [ $? -ne 0 ]; then echo "FAIL"; fi
+/bin/rm -f $tfile $ofile

scripts/mailmap-update.sh

@@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-
-usage () {
-    echo "USAGE: ./mailmap-update.sh <libbpf-repo> <linux-repo>"
-    exit 1
-}
-
-LIBBPF_REPO="${1-""}"
-LINUX_REPO="${2-""}"
-
-if [ -z "${LIBBPF_REPO}" ] || [ -z "${LINUX_REPO}" ]; then
-    echo "Error: libbpf or linux repos are not specified"
-    usage
-fi
-
-LIBBPF_MAILMAP="${LIBBPF_REPO}/.mailmap"
-LINUX_MAILMAP="${LINUX_REPO}/.mailmap"
-
-tmpfile="$(mktemp)"
-cleanup() {
-    rm -f "${tmpfile}"
-}
-trap cleanup EXIT
-
-grep_lines() {
-    local pattern="$1"
-    local file="$2"
-    grep "${pattern}" "${file}" || true
-}
-
-while read -r email; do
-    grep_lines "${email}$" "${LINUX_MAILMAP}" >> "${tmpfile}"
-done < <(git log --format='<%ae>' | sort -u)
-
-sort -u "${tmpfile}" > "${LIBBPF_MAILMAP}"

scripts/sync-kernel.sh

@@ -6,6 +6,7 @@ usage () {
 	echo "Set BPF_NEXT_BASELINE to override bpf-next tree commit, otherwise read from <libbpf-repo>/CHECKPOINT-COMMIT."
 	echo "Set BPF_BASELINE to override bpf tree commit, otherwise read from <libbpf-repo>/BPF-CHECKPOINT-COMMIT."
 	echo "Set MANUAL_MODE to 1 to manually control every cherry-picked commits."
+	echo "Set IGNORE_CONSISTENCY to 1 to ignore failed contents consistency check."
 	exit 1
 }
 
@@ -17,7 +18,7 @@ BPF_BRANCH=${3-""}
 BASELINE_COMMIT=${BPF_NEXT_BASELINE:-$(cat ${LIBBPF_REPO}/CHECKPOINT-COMMIT)}
 BPF_BASELINE_COMMIT=${BPF_BASELINE:-$(cat ${LIBBPF_REPO}/BPF-CHECKPOINT-COMMIT)}
 
-if [ -z "${LIBBPF_REPO}" ] || [ -z "${LINUX_REPO}" ]; then
+if [ -z "${LIBBPF_REPO}" ] || [ -z "${LINUX_REPO}" ] || [ -z "${BPF_BRANCH}" ]; then
 	echo "Error: libbpf or linux repos are not specified"
 	usage
 fi
@@ -42,22 +43,15 @@ PATH_MAP=(									\
 	[tools/include/uapi/linux/bpf_common.h]=include/uapi/linux/bpf_common.h	\
 	[tools/include/uapi/linux/bpf.h]=include/uapi/linux/bpf.h		\
 	[tools/include/uapi/linux/btf.h]=include/uapi/linux/btf.h		\
-	[tools/include/uapi/linux/fcntl.h]=include/uapi/linux/fcntl.h		\
-	[tools/include/uapi/linux/openat2.h]=include/uapi/linux/openat2.h	\
 	[tools/include/uapi/linux/if_link.h]=include/uapi/linux/if_link.h	\
 	[tools/include/uapi/linux/if_xdp.h]=include/uapi/linux/if_xdp.h		\
-	[tools/include/uapi/linux/netdev.h]=include/uapi/linux/netdev.h		\
 	[tools/include/uapi/linux/netlink.h]=include/uapi/linux/netlink.h	\
-	[tools/include/uapi/linux/pkt_cls.h]=include/uapi/linux/pkt_cls.h	\
-	[tools/include/uapi/linux/pkt_sched.h]=include/uapi/linux/pkt_sched.h	\
-	[include/uapi/linux/perf_event.h]=include/uapi/linux/perf_event.h	\
-	[Documentation/bpf/libbpf]=docs						\
+	[tools/include/tools/libc_compat.h]=include/tools/libc_compat.h		\
 )
 
-LIBBPF_PATHS=("${!PATH_MAP[@]}" ":^tools/lib/bpf/Makefile" ":^tools/lib/bpf/Build" ":^tools/lib/bpf/.gitignore" ":^tools/include/tools/libc_compat.h")
-LIBBPF_VIEW_PATHS=("${PATH_MAP[@]}")
-LIBBPF_VIEW_EXCLUDE_REGEX='^src/(Makefile|Build|test_libbpf\.c|bpf_helper_defs\.h|\.gitignore)$|^docs/(\.gitignore|api\.rst|conf\.py)$|^docs/sphinx/.*'
-LINUX_VIEW_EXCLUDE_REGEX='^include/tools/libc_compat.h$'
+LIBBPF_PATHS="${!PATH_MAP[@]} :^tools/lib/bpf/Makefile :^tools/lib/bpf/Build :^tools/lib/bpf/.gitignore"
+LIBBPF_VIEW_PATHS="${PATH_MAP[@]}"
+LIBBPF_VIEW_EXCLUDE_REGEX='^src/(Makefile|Build|test_libbpf\.c|bpf_helper_defs\.h|\.gitignore)$'
 
 LIBBPF_TREE_FILTER="mkdir -p __libbpf/include/uapi/linux __libbpf/include/tools && "$'\\\n'
 for p in "${!PATH_MAP[@]}"; do
@@ -78,7 +72,7 @@ commit_desc()
 }
 
 # Create commit single-line signature, which consists of:
-# - full commit subject
+# - full commit hash
 # - author date in ISO8601 format
 # - full commit body with newlines replaced with vertical bars (|)
 # - shortstat appended at the end
@@ -88,9 +82,7 @@ commit_desc()
 # $2 - paths filter
 commit_signature()
 {
-	local ref=$1
-	shift
-	git show --pretty='("%s")|%aI|%b' --shortstat $ref -- "${@-.}" | tr '\n' '|'
+	git show --pretty='("%s")|%aI|%b' --shortstat $1 -- ${2-.} | tr '\n' '|'
 }
 
 # Cherry-pick commits touching libbpf-related files
@@ -109,7 +101,7 @@ cherry_pick_commits()
 	local libbpf_conflict_cnt
 	local desc
 
-	new_commits=$(git rev-list --no-merges --topo-order --reverse ${baseline_tag}..${tip_tag} -- "${LIBBPF_PATHS[@]}")
+	new_commits=$(git rev-list --no-merges --topo-order --reverse ${baseline_tag}..${tip_tag} ${LIBBPF_PATHS[@]})
 	for new_commit in ${new_commits}; do
 		desc="$(commit_desc ${new_commit})"
 		signature="$(commit_signature ${new_commit} "${LIBBPF_PATHS[@]}")"
@@ -143,9 +135,8 @@ cherry_pick_commits()
 		echo "Picking '${desc}'..."
 		if ! git cherry-pick ${new_commit} &>/dev/null; then
 			echo "Warning! Cherry-picking '${desc} failed, checking if it's non-libbpf files causing problems..."
-			libbpf_conflict_cnt=$(git diff --name-only --diff-filter=U -- "${LIBBPF_PATHS[@]}" | wc -l)
+			libbpf_conflict_cnt=$(git diff --name-only --diff-filter=U -- ${LIBBPF_PATHS[@]} | wc -l)
 			conflict_cnt=$(git diff --name-only | wc -l)
-			prompt_resolution=1
 
 			if ((${libbpf_conflict_cnt} == 0)); then
 				echo "Looks like only non-libbpf files have conflicts, ignoring..."
@@ -161,37 +152,15 @@ cherry_pick_commits()
 					echo "Error! That still failed! Please resolve manually."
 				else
 					echo "Success! All cherry-pick conflicts were resolved for '${desc}'!"
-					prompt_resolution=0
+					continue
 				fi
 			fi
 
-			if ((${prompt_resolution} == 1)); then
-				read -p "Error! Cherry-picking '${desc}' failed, please fix manually and press <return> to proceed..."
-			fi
+			read -p "Error! Cherry-picking '${desc}' failed, please fix manually and press <return> to proceed..."
 		fi
-		# Append signature of just cherry-picked commit to avoid
-		# potentially cherry-picking the same commit twice later when
-		# processing bpf tree commits. At this point we don't know yet
-		# the final commit sha in libbpf repo, so we record Linux SHA
-		# instead as LINUX_<sha>.
-		echo LINUX_$(git log --pretty='%h' -n1) "${signature}" >> ${TMP_DIR}/libbpf_commits.txt
 	done
 }
 
-cleanup()
-{
-	echo "Cleaning up..."
-	rm -r ${TMP_DIR}
-	cd_to ${LINUX_REPO}
-	git checkout ${TIP_SYM_REF}
-	git branch -D ${BASELINE_TAG} ${TIP_TAG} ${BPF_BASELINE_TAG} ${BPF_TIP_TAG} \
-		      ${SQUASH_BASE_TAG} ${SQUASH_TIP_TAG} ${VIEW_TAG} || true
-
-	cd_to .
-	echo "DONE."
-}
-
-
 cd_to ${LIBBPF_REPO}
 GITHUB_ABS_DIR=$(pwd)
 echo "Dumping existing libbpf commit signatures..."
@@ -257,60 +226,40 @@ FILTER_BRANCH_SQUELCH_WARNING=1 git filter-branch --prune-empty -f --subdirector
 COMMIT_CNT=$(git rev-list --count ${SQUASH_BASE_TAG}..${SQUASH_TIP_TAG})
 if ((${COMMIT_CNT} <= 0)); then
     echo "No new changes to apply, we are done!"
-    cleanup
     exit 2
 fi
 
 # Exclude baseline commit and generate nice cover letter with summary
-git format-patch --no-signature ${SQUASH_BASE_TAG}..${SQUASH_TIP_TAG} --cover-letter -o ${TMP_DIR}/patches
+git format-patch ${SQUASH_BASE_TAG}..${SQUASH_TIP_TAG} --cover-letter -o ${TMP_DIR}/patches
 
 # Now is time to re-apply libbpf-related linux patches to libbpf repo
 cd_to ${LIBBPF_REPO}
 git checkout -b ${LIBBPF_SYNC_TAG}
 
 for patch in $(ls -1 ${TMP_DIR}/patches | tail -n +2); do
-	if ! git am -3 --committer-date-is-author-date "${TMP_DIR}/patches/${patch}"; then
-		if ! patch -p1 --merge < "${TMP_DIR}/patches/${patch}"; then
-			read -p "Applying ${TMP_DIR}/patches/${patch} failed, please resolve manually and press <return> to proceed..."
-		fi
-		git am --continue
+	if ! git am --committer-date-is-author-date "${TMP_DIR}/patches/${patch}"; then
+		read -p "Applying ${TMP_DIR}/patches/${patch} failed, please resolve manually and press <return> to proceed..."
 	fi
 done
 
 # Generate bpf_helper_defs.h and commit, if anything changed
-# restore Linux tip to use bpf_doc.py
+# restore Linux tip to use bpf_helpers_doc.py
 cd_to ${LINUX_REPO}
 git checkout ${TIP_TAG}
 # re-generate bpf_helper_defs.h
 cd_to ${LIBBPF_REPO}
-"${LINUX_ABS_DIR}/scripts/bpf_doc.py" --header					      \
+"${LINUX_ABS_DIR}/scripts/bpf_helpers_doc.py" --header			    \
 	--file include/uapi/linux/bpf.h > src/bpf_helper_defs.h
 # if anything changed, commit it
 helpers_changes=$(git status --porcelain src/bpf_helper_defs.h | wc -l)
 if ((${helpers_changes} == 1)); then
 	git add src/bpf_helper_defs.h
-	git commit -s -m "sync: auto-generate latest BPF helpers
+	git commit -m "sync: auto-generate latest BPF helpers
 
 Latest changes to BPF helper definitions.
 " -- src/bpf_helper_defs.h
 fi
 
-echo "Regenerating .mailmap..."
-cd_to "${LINUX_REPO}"
-git checkout "${TIP_SYM_REF}"
-cd_to "${LIBBPF_REPO}"
-"${LIBBPF_REPO}"/scripts/mailmap-update.sh "${LIBBPF_REPO}" "${LINUX_REPO}"
-# if anything changed, commit it
-mailmap_changes=$(git status --porcelain .mailmap | wc -l)
-if ((${mailmap_changes} == 1)); then
-	git add .mailmap
-	git commit -s -m "sync: update .mailmap
-
-Update .mailmap based on libbpf's list of contributors and on the latest
-.mailmap version in the upstream repository.
-" -- .mailmap
-fi
-
 # Use generated cover-letter as a template for "sync commit" with
 # baseline and checkpoint commits from kernel repo (and leave summary
 # from cover letter intact, of course)
@@ -327,7 +276,7 @@ Baseline bpf-next commit:   ${BASELINE_COMMIT}\n\
 Checkpoint bpf-next commit: ${TIP_COMMIT}\n\
 Baseline bpf commit:        ${BPF_BASELINE_COMMIT}\n\
 Checkpoint bpf commit:      ${BPF_TIP_COMMIT}/" |				      \
-git commit -s --file=-
+git commit --file=-
 
 echo "SUCCESS! ${COMMIT_CNT} commits synced."
 
@@ -337,10 +286,10 @@ cd_to ${LINUX_REPO}
 git checkout -b ${VIEW_TAG} ${TIP_COMMIT}
 FILTER_BRANCH_SQUELCH_WARNING=1 git filter-branch -f --tree-filter "${LIBBPF_TREE_FILTER}" ${VIEW_TAG}^..${VIEW_TAG}
 FILTER_BRANCH_SQUELCH_WARNING=1 git filter-branch -f --subdirectory-filter __libbpf ${VIEW_TAG}^..${VIEW_TAG}
-git ls-files -- "${LIBBPF_VIEW_PATHS[@]}" | grep -v -E "${LINUX_VIEW_EXCLUDE_REGEX}" > ${TMP_DIR}/linux-view.ls
+git ls-files -- ${LIBBPF_VIEW_PATHS[@]} > ${TMP_DIR}/linux-view.ls
 
 cd_to ${LIBBPF_REPO}
-git ls-files -- "${LIBBPF_VIEW_PATHS[@]}" | grep -v -E "${LIBBPF_VIEW_EXCLUDE_REGEX}" > ${TMP_DIR}/github-view.ls
+git ls-files -- ${LIBBPF_VIEW_PATHS[@]} | grep -v -E "${LIBBPF_VIEW_EXCLUDE_REGEX}" > ${TMP_DIR}/github-view.ls
 
 echo "Comparing list of files..."
 diff -u ${TMP_DIR}/linux-view.ls ${TMP_DIR}/github-view.ls
@@ -355,17 +304,19 @@ done
 if ((${CONSISTENT} == 1)); then
 	echo "Great! Content is identical!"
 else
-	ignore_inconsistency=n
-	echo "Unfortunately, there are some inconsistencies, please double check."
-	read -p "Does everything look good? [y/N]: " ignore_inconsistency
-	case "${ignore_inconsistency}" in
-		"y" | "Y")
-			echo "Ok, proceeding..."
-			;;
-		*)
-			echo "Oops, exiting with error..."
-			exit 4
-	esac
+	echo "Unfortunately, there are consistency problems!"
+	if ((${IGNORE_CONSISTENCY-0} != 1)); then
+		exit 4
+	fi
 fi
 
-cleanup
+echo "Cleaning up..."
+rm -r ${TMP_DIR}
+cd_to ${LINUX_REPO}
+git checkout ${TIP_SYM_REF}
+git branch -D ${BASELINE_TAG} ${TIP_TAG} ${BPF_BASELINE_TAG} ${BPF_TIP_TAG} \
+	      ${SQUASH_BASE_TAG} ${SQUASH_TIP_TAG} ${VIEW_TAG}
+
+cd_to .
+echo "DONE."
+

src/Makefile

@@ -1,61 +1,39 @@
 # SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
 
-ifeq ($(V),1)
-	Q =
-	msg =
-else
-	Q = @
-	msg = @printf '  %-8s %s%s\n' "$(1)" "$(2)" "$(if $(3), $(3))";
-endif
-
-LIBBPF_MAJOR_VERSION := 1
-LIBBPF_MINOR_VERSION := 5
-LIBBPF_PATCH_VERSION := 0
-LIBBPF_VERSION := $(LIBBPF_MAJOR_VERSION).$(LIBBPF_MINOR_VERSION).$(LIBBPF_PATCH_VERSION)
-LIBBPF_MAJMIN_VERSION := $(LIBBPF_MAJOR_VERSION).$(LIBBPF_MINOR_VERSION).0
-LIBBPF_MAP_VERSION := $(shell grep -oE '^LIBBPF_([0-9.]+)' libbpf.map | sort -rV | head -n1 | cut -d'_' -f2)
-ifneq ($(LIBBPF_MAJMIN_VERSION), $(LIBBPF_MAP_VERSION))
-$(error Libbpf release ($(LIBBPF_VERSION)) and map ($(LIBBPF_MAP_VERSION)) versions are out of sync!)
-endif
-
-define allow-override
-  $(if $(or $(findstring environment,$(origin $(1))),\
-            $(findstring command line,$(origin $(1)))),,\
-    $(eval $(1) = $(2)))
-endef
-
-$(call allow-override,CC,$(CROSS_COMPILE)cc)
-$(call allow-override,LD,$(CROSS_COMPILE)ld)
+LIBBPF_VERSION := $(shell \
+	grep -oE '^LIBBPF_([0-9.]+)' libbpf.map | \
+	sort -rV | head -n1 | cut -d'_' -f2)
+LIBBPF_MAJOR_VERSION := $(firstword $(subst ., ,$(LIBBPF_VERSION)))
 
 TOPDIR = ..
 
 INCLUDES := -I. -I$(TOPDIR)/include -I$(TOPDIR)/include/uapi
 ALL_CFLAGS := $(INCLUDES)
 
+FEATURE_REALLOCARRAY := $(shell $(TOPDIR)/scripts/check-reallocarray.sh $(CC))
+ifneq ($(FEATURE_REALLOCARRAY),)
+	ALL_CFLAGS += -DCOMPAT_NEED_REALLOCARRAY
+endif
+
 SHARED_CFLAGS += -fPIC -fvisibility=hidden -DSHARED
 
-CFLAGS ?= -g -O2 -Werror -Wall -std=gnu89
-ALL_CFLAGS += $(CFLAGS) 						\
-	      -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64		\
-	      -Wno-unknown-warning-option -Wno-format-overflow		\
-	      $(EXTRA_CFLAGS)
-ALL_LDFLAGS += $(LDFLAGS) $(EXTRA_LDFLAGS)
-
+CFLAGS ?= -g -O2 -Werror -Wall
+ALL_CFLAGS += $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
+ALL_LDFLAGS += $(LDFLAGS)
 ifdef NO_PKG_CONFIG
 	ALL_LDFLAGS += -lelf -lz
 else
 	PKG_CONFIG ?= pkg-config
-	ALL_CFLAGS += $(shell $(PKG_CONFIG) --cflags libelf zlib)
-	ALL_LDFLAGS += $(shell $(PKG_CONFIG) --libs libelf zlib)
+	ALL_CFLAGS += $(shell $(PKG_CONFIG) --cflags libelf)
+	ALL_LDFLAGS += $(shell $(PKG_CONFIG) --libs libelf)
 endif
 
 OBJDIR ?= .
 SHARED_OBJDIR := $(OBJDIR)/sharedobjs
 STATIC_OBJDIR := $(OBJDIR)/staticobjs
 OBJS := bpf.o btf.o libbpf.o libbpf_errno.o netlink.o \
-	nlattr.o str_error.o libbpf_probes.o bpf_prog_linfo.o \
-	btf_dump.o hashmap.o ringbuf.o strset.o linker.o gen_loader.o \
-	relo_core.o usdt.o zip.o elf.o features.o btf_iter.o btf_relocate.o
+	nlattr.o str_error.o libbpf_probes.o bpf_prog_linfo.o xsk.o \
+	btf_dump.o hashmap.o ringbuf.o
 SHARED_OBJS := $(addprefix $(SHARED_OBJDIR)/,$(OBJS))
 STATIC_OBJS := $(addprefix $(STATIC_OBJDIR)/,$(OBJS))
 
@@ -67,10 +45,9 @@ ifndef BUILD_STATIC_ONLY
 	VERSION_SCRIPT := libbpf.map
 endif
 
-HEADERS := bpf.h libbpf.h btf.h libbpf_common.h libbpf_legacy.h \
+HEADERS := bpf.h libbpf.h btf.h xsk.h libbpf_util.h \
 	   bpf_helpers.h bpf_helper_defs.h bpf_tracing.h \
-	   bpf_endian.h bpf_core_read.h skel_internal.h libbpf_version.h \
-	   usdt.bpf.h
+	   bpf_endian.h bpf_core_read.h libbpf_common.h
 UAPI_HEADERS := $(addprefix $(TOPDIR)/include/uapi/linux/,\
 			    bpf.h bpf_common.h btf.h)
 
@@ -80,20 +57,12 @@ INSTALL = install
 
 DESTDIR ?=
 
-HOSTARCH = $(firstword $(subst -, ,$(shell $(CC) -dumpmachine)))
-ifeq ($(filter-out %64 %64be %64eb %64le %64el s390x, $(HOSTARCH)),)
+ifeq ($(shell uname -m),x86_64)
 	LIBSUBDIR := lib64
 else
 	LIBSUBDIR := lib
 endif
 
-# By default let the pc file itself use ${prefix} in includedir/libdir so that
-# the prefix can be overridden at runtime (eg: --define-prefix)
-ifndef LIBDIR
-	LIBDIR_PC := $$\{prefix\}/$(LIBSUBDIR)
-else
-	LIBDIR_PC := $(LIBDIR)
-endif
 PREFIX ?= /usr
 LIBDIR ?= $(PREFIX)/$(LIBSUBDIR)
 INCLUDEDIR ?= $(PREFIX)/include
@@ -104,54 +73,50 @@ TAGS_PROG := $(if $(shell which etags 2>/dev/null),etags,ctags)
 all: $(STATIC_LIBS) $(SHARED_LIBS) $(PC_FILE)
 
 $(OBJDIR)/libbpf.a: $(STATIC_OBJS)
-	$(call msg,AR,$@)
-	$(Q)$(AR) rcs $@ $^
+	$(AR) rcs $@ $^
 
 $(OBJDIR)/libbpf.so: $(OBJDIR)/libbpf.so.$(LIBBPF_MAJOR_VERSION)
-	$(Q)ln -sf $(^F) $@
+	ln -sf $(^F) $@
 
 $(OBJDIR)/libbpf.so.$(LIBBPF_MAJOR_VERSION): $(OBJDIR)/libbpf.so.$(LIBBPF_VERSION)
-	$(Q)ln -sf $(^F) $@
+	ln -sf $(^F) $@
 
 $(OBJDIR)/libbpf.so.$(LIBBPF_VERSION): $(SHARED_OBJS)
-	$(call msg,CC,$@)
-	$(Q)$(CC) -shared -Wl,--version-script=$(VERSION_SCRIPT) \
-		  -Wl,-soname,libbpf.so.$(LIBBPF_MAJOR_VERSION) \
-		  $^ $(ALL_LDFLAGS) -o $@
+	$(CC) -shared -Wl,--version-script=$(VERSION_SCRIPT) \
+		      -Wl,-soname,libbpf.so.$(LIBBPF_MAJOR_VERSION) \
+		      $^ $(ALL_LDFLAGS) -o $@
 
-$(OBJDIR)/libbpf.pc: force | $(OBJDIR)
-	$(Q)sed -e "s|@PREFIX@|$(PREFIX)|" \
-		-e "s|@LIBDIR@|$(LIBDIR_PC)|" \
+$(OBJDIR)/libbpf.pc:
+	sed -e "s|@PREFIX@|$(PREFIX)|" \
+		-e "s|@LIBDIR@|$(LIBDIR)|" \
 		-e "s|@VERSION@|$(LIBBPF_VERSION)|" \
 		< libbpf.pc.template > $@
 
-$(OBJDIR) $(STATIC_OBJDIR) $(SHARED_OBJDIR):
-	$(call msg,MKDIR,$@)
-	$(Q)mkdir -p $@
+$(STATIC_OBJDIR):
+	mkdir -p $(STATIC_OBJDIR)
+
+$(SHARED_OBJDIR):
+	mkdir -p $(SHARED_OBJDIR)
 
 $(STATIC_OBJDIR)/%.o: %.c | $(STATIC_OBJDIR)
-	$(call msg,CC,$@)
-	$(Q)$(CC) $(ALL_CFLAGS) $(CPPFLAGS) -c $< -o $@
+	$(CC) $(ALL_CFLAGS) $(CPPFLAGS) -c $< -o $@
 
 $(SHARED_OBJDIR)/%.o: %.c | $(SHARED_OBJDIR)
-	$(call msg,CC,$@)
-	$(Q)$(CC) $(ALL_CFLAGS) $(SHARED_CFLAGS) $(CPPFLAGS) -c $< -o $@
+	$(CC) $(ALL_CFLAGS) $(SHARED_CFLAGS) $(CPPFLAGS) -c $< -o $@
 
 define do_install
-	$(call msg,INSTALL,$1)
-	$(Q)if [ ! -d '$(DESTDIR)$2' ]; then		\
+	if [ ! -d '$(DESTDIR)$2' ]; then		\
 		$(INSTALL) -d -m 755 '$(DESTDIR)$2';	\
-	fi;
-	$(Q)$(INSTALL) $(if $3,-m $3,) $1 '$(DESTDIR)$2'
+	fi;						\
+	$(INSTALL) $1 $(if $3,-m $3,) '$(DESTDIR)$2'
 endef
 
 # Preserve symlinks at installation.
 define do_s_install
-	$(call msg,INSTALL,$1)
-	$(Q)if [ ! -d '$(DESTDIR)$2' ]; then		\
+	if [ ! -d '$(DESTDIR)$2' ]; then		\
 		$(INSTALL) -d -m 755 '$(DESTDIR)$2';	\
-	fi;
-	$(Q)cp -fR $1 '$(DESTDIR)$2'
+	fi;						\
+	cp -fpR $1 '$(DESTDIR)$2'
 endef
 
 install: all install_headers install_pkgconfig
@@ -169,18 +134,13 @@ install_pkgconfig: $(PC_FILE)
 	$(call do_install,$(PC_FILE),$(LIBDIR)/pkgconfig,644)
 
 clean:
-	$(call msg,CLEAN)
-	$(Q)rm -rf *.o *.a *.so *.so.* *.pc $(SHARED_OBJDIR) $(STATIC_OBJDIR)
+	rm -rf *.o *.a *.so *.so.* *.pc $(SHARED_OBJDIR) $(STATIC_OBJDIR)
 
-.PHONY: cscope tags force
+.PHONY: cscope tags
 cscope:
-	$(call msg,CSCOPE)
-	$(Q)ls *.c *.h > cscope.files
-	$(Q)cscope -b -q -f cscope.out
+	ls *.c *.h > cscope.files
+	cscope -b -q -f cscope.out
 
 tags:
-	$(call msg,CTAGS)
-	$(Q)rm -f TAGS tags
-	$(Q)ls *.c *.h | xargs $(TAGS_PROG) -a
-
-force:
+	rm -f TAGS tags
+	ls *.c *.h | xargs $(TAGS_PROG) -a

src/README.rst

@@ -1,7 +1,7 @@
 .. SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
 
-API naming convention
-=====================
+libbpf API naming convention
+============================
 
 libbpf API provides access to a few logically separated groups of
 functions and types. Every group has its own naming convention
@@ -9,15 +9,15 @@ described here. It's recommended to follow these conventions whenever a
 new function or type is added to keep libbpf API clean and consistent.
 
 All types and functions provided by libbpf API should have one of the
-following prefixes: ``bpf_``, ``btf_``, ``libbpf_``, ``btf_dump_``,
-``ring_buffer_``, ``perf_buffer_``.
+following prefixes: ``bpf_``, ``btf_``, ``libbpf_``, ``xsk_``,
+``perf_buffer_``.
 
 System call wrappers
 --------------------
 
 System call wrappers are simple wrappers for commands supported by
 sys_bpf system call. These wrappers should go to ``bpf.h`` header file
-and map one to one to corresponding commands.
+and map one-on-one to corresponding commands.
 
 For example ``bpf_map_lookup_elem`` wraps ``BPF_MAP_LOOKUP_ELEM``
 command of sys_bpf, ``bpf_prog_attach`` wraps ``BPF_PROG_ATTACH``, etc.
@@ -49,6 +49,10 @@ object, ``bpf_object``, double underscore and ``open`` that defines the
 purpose of the function to open ELF file and create ``bpf_object`` from
 it.
 
+Another example: ``bpf_program__load`` is named for corresponding
+object, ``bpf_program``, that is separated from other part of the name
+by double underscore.
+
 All objects and corresponding functions other than BTF related should go
 to ``libbpf.h``. BTF types and functions should go to ``btf.h``.
 
@@ -59,8 +63,21 @@ Auxiliary functions and types that don't fit well in any of categories
 described above should have ``libbpf_`` prefix, e.g.
 ``libbpf_get_error`` or ``libbpf_prog_type_by_name``.
 
-ABI
----
+AF_XDP functions
+-------------------
+
+AF_XDP functions should have an ``xsk_`` prefix, e.g.
+``xsk_umem__get_data`` or ``xsk_umem__create``. The interface consists
+of both low-level ring access functions and high-level configuration
+functions. These can be mixed and matched. Note that these functions
+are not reentrant for performance reasons.
+
+Please take a look at Documentation/networking/af_xdp.rst in the Linux
+kernel source tree on how to use XDP sockets and for some common
+mistakes in case you do not get any traffic up to user space.
+
+libbpf ABI
+==========
 
 libbpf can be both linked statically or used as DSO. To avoid possible
 conflicts with other libraries an application is linked with, all
@@ -83,8 +100,8 @@ This prevents from accidentally exporting a symbol, that is not supposed
 to be a part of ABI what, in turn, improves both libbpf developer- and
 user-experiences.
 
-ABI versioning
---------------
+ABI versionning
+---------------
 
 To make future ABI extensions possible libbpf ABI is versioned.
 Versioning is implemented by ``libbpf.map`` version script that is
@@ -99,8 +116,7 @@ This bump in ABI version is at most once per kernel development cycle.
 
 For example, if current state of ``libbpf.map`` is:
 
-.. code-block:: none
-
+.. code-block::
         LIBBPF_0.0.1 {
         	global:
                         bpf_func_a;
@@ -112,8 +128,7 @@ For example, if current state of ``libbpf.map`` is:
 , and a new symbol ``bpf_func_c`` is being introduced, then
 ``libbpf.map`` should be changed like this:
 
-.. code-block:: none
-
+.. code-block::
         LIBBPF_0.0.1 {
         	global:
                         bpf_func_a;
@@ -133,7 +148,7 @@ Format of version script and ways to handle ABI changes, including
 incompatible ones, described in details in [1].
 
 Stand-alone build
--------------------
+=================
 
 Under https://github.com/libbpf/libbpf there is a (semi-)automated
 mirror of the mainline's version of libbpf for a stand-alone build.
@@ -141,53 +156,13 @@ mirror of the mainline's version of libbpf for a stand-alone build.
 However, all changes to libbpf's code base must be upstreamed through
 the mainline kernel tree.
 
-
-API documentation convention
-============================
-
-The libbpf API is documented via comments above definitions in
-header files. These comments can be rendered by doxygen and sphinx
-for well organized html output. This section describes the
-convention in which these comments should be formatted.
-
-Here is an example from btf.h:
-
-.. code-block:: c
-
-        /**
-         * @brief **btf__new()** creates a new instance of a BTF object from the raw
-         * bytes of an ELF's BTF section
-         * @param data raw bytes
-         * @param size number of bytes passed in `data`
-         * @return new BTF object instance which has to be eventually freed with
-         * **btf__free()**
-         *
-         * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract
-         * error code from such a pointer `libbpf_get_error()` should be used. If
-         * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is
-         * returned on error instead. In both cases thread-local `errno` variable is
-         * always set to error code as well.
-         */
-
-The comment must start with a block comment of the form '/\*\*'.
-
-The documentation always starts with a @brief directive. This line is a short
-description about this API. It starts with the name of the API, denoted in bold
-like so: **api_name**. Please include an open and close parenthesis if this is a
-function. Follow with the short description of the API. A longer form description
-can be added below the last directive, at the bottom of the comment.
-
-Parameters are denoted with the @param directive, there should be one for each
-parameter. If this is a function with a non-void return, use the @return directive
-to document it.
-
 License
--------------------
+=======
 
 libbpf is dual-licensed under LGPL 2.1 and BSD 2-Clause.
 
 Links
--------------------
+=====
 
 [1] https://www.akkadia.org/drepper/dsohowto.pdf
     (Chapter 3. Maintaining APIs and ABIs).

src/bpf.h

@@ -1,7 +1,7 @@
 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
 
 /*
- * Common BPF ELF operations.
+ * common eBPF ELF operations.
  *
  * Copyright (C) 2013-2015 Alexei Starovoitov <ast@kernel.org>
  * Copyright (C) 2015 Wang Nan <wangnan0@huawei.com>
@@ -29,121 +29,92 @@
 #include <stdint.h>
 
 #include "libbpf_common.h"
-#include "libbpf_legacy.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-LIBBPF_API int libbpf_set_memlock_rlim(size_t memlock_bytes);
-
-struct bpf_map_create_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-
+struct bpf_create_map_attr {
+	const char *name;
+	enum bpf_map_type map_type;
+	__u32 map_flags;
+	__u32 key_size;
+	__u32 value_size;
+	__u32 max_entries;
+	__u32 numa_node;
 	__u32 btf_fd;
 	__u32 btf_key_type_id;
 	__u32 btf_value_type_id;
-	__u32 btf_vmlinux_value_type_id;
-
-	__u32 inner_map_fd;
-	__u32 map_flags;
-	__u64 map_extra;
-
-	__u32 numa_node;
 	__u32 map_ifindex;
-	__s32 value_type_btf_obj_fd;
-
-	__u32 token_fd;
-	size_t :0;
+	union {
+		__u32 inner_map_fd;
+		__u32 btf_vmlinux_value_type_id;
+	};
 };
-#define bpf_map_create_opts__last_field token_fd
 
-LIBBPF_API int bpf_map_create(enum bpf_map_type map_type,
-			      const char *map_name,
-			      __u32 key_size,
-			      __u32 value_size,
-			      __u32 max_entries,
-			      const struct bpf_map_create_opts *opts);
-
-struct bpf_prog_load_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-
-	/* libbpf can retry BPF_PROG_LOAD command if bpf() syscall returns
-	 * -EAGAIN. This field determines how many attempts libbpf has to
-	 *  make. If not specified, libbpf will use default value of 5.
-	 */
-	int attempts;
+LIBBPF_API int
+bpf_create_map_xattr(const struct bpf_create_map_attr *create_attr);
+LIBBPF_API int bpf_create_map_node(enum bpf_map_type map_type, const char *name,
+				   int key_size, int value_size,
+				   int max_entries, __u32 map_flags, int node);
+LIBBPF_API int bpf_create_map_name(enum bpf_map_type map_type, const char *name,
+				   int key_size, int value_size,
+				   int max_entries, __u32 map_flags);
+LIBBPF_API int bpf_create_map(enum bpf_map_type map_type, int key_size,
+			      int value_size, int max_entries, __u32 map_flags);
+LIBBPF_API int bpf_create_map_in_map_node(enum bpf_map_type map_type,
+					  const char *name, int key_size,
+					  int inner_map_fd, int max_entries,
+					  __u32 map_flags, int node);
+LIBBPF_API int bpf_create_map_in_map(enum bpf_map_type map_type,
+				     const char *name, int key_size,
+				     int inner_map_fd, int max_entries,
+				     __u32 map_flags);
 
+struct bpf_load_program_attr {
+	enum bpf_prog_type prog_type;
 	enum bpf_attach_type expected_attach_type;
+	const char *name;
+	const struct bpf_insn *insns;
+	size_t insns_cnt;
+	const char *license;
+	union {
+		__u32 kern_version;
+		__u32 attach_prog_fd;
+	};
+	union {
+		__u32 prog_ifindex;
+		__u32 attach_btf_id;
+	};
 	__u32 prog_btf_fd;
-	__u32 prog_flags;
-	__u32 prog_ifindex;
-	__u32 kern_version;
-
-	__u32 attach_btf_id;
-	__u32 attach_prog_fd;
-	__u32 attach_btf_obj_fd;
-
-	const int *fd_array;
-
-	/* .BTF.ext func info data */
+	__u32 func_info_rec_size;
 	const void *func_info;
 	__u32 func_info_cnt;
-	__u32 func_info_rec_size;
-
-	/* .BTF.ext line info data */
+	__u32 line_info_rec_size;
 	const void *line_info;
 	__u32 line_info_cnt;
-	__u32 line_info_rec_size;
-
-	/* verifier log options */
 	__u32 log_level;
-	__u32 log_size;
-	char *log_buf;
-	/* output: actual total log contents size (including termintaing zero).
-	 * It could be both larger than original log_size (if log was
-	 * truncated), or smaller (if log buffer wasn't filled completely).
-	 * If kernel doesn't support this feature, log_size is left unchanged.
-	 */
-	__u32 log_true_size;
-	__u32 token_fd;
-	size_t :0;
+	__u32 prog_flags;
 };
-#define bpf_prog_load_opts__last_field token_fd
-
-LIBBPF_API int bpf_prog_load(enum bpf_prog_type prog_type,
-			     const char *prog_name, const char *license,
-			     const struct bpf_insn *insns, size_t insn_cnt,
-			     struct bpf_prog_load_opts *opts);
 
 /* Flags to direct loading requirements */
 #define MAPS_RELAX_COMPAT	0x01
 
-/* Recommended log buffer size */
+/* Recommend log buffer size */
 #define BPF_LOG_BUF_SIZE (UINT32_MAX >> 8) /* verifier maximum in kernels <= 5.1 */
-
-struct bpf_btf_load_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-
-	/* kernel log options */
-	char *log_buf;
-	__u32 log_level;
-	__u32 log_size;
-	/* output: actual total log contents size (including termintaing zero).
-	 * It could be both larger than original log_size (if log was
-	 * truncated), or smaller (if log buffer wasn't filled completely).
-	 * If kernel doesn't support this feature, log_size is left unchanged.
-	 */
-	__u32 log_true_size;
-
-	__u32 btf_flags;
-	__u32 token_fd;
-	size_t :0;
-};
-#define bpf_btf_load_opts__last_field token_fd
-
-LIBBPF_API int bpf_btf_load(const void *btf_data, size_t btf_size,
-			    struct bpf_btf_load_opts *opts);
+LIBBPF_API int
+bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,
+		       char *log_buf, size_t log_buf_sz);
+LIBBPF_API int bpf_load_program(enum bpf_prog_type type,
+				const struct bpf_insn *insns, size_t insns_cnt,
+				const char *license, __u32 kern_version,
+				char *log_buf, size_t log_buf_sz);
+LIBBPF_API int bpf_verify_program(enum bpf_prog_type type,
+				  const struct bpf_insn *insns,
+				  size_t insns_cnt, __u32 prog_flags,
+				  const char *license, __u32 kern_version,
+				  char *log_buf, size_t log_buf_sz,
+				  int log_level);
 
 LIBBPF_API int bpf_map_update_elem(int fd, const void *key, const void *value,
 				   __u64 flags);
@@ -153,10 +124,7 @@ LIBBPF_API int bpf_map_lookup_elem_flags(int fd, const void *key, void *value,
 					 __u64 flags);
 LIBBPF_API int bpf_map_lookup_and_delete_elem(int fd, const void *key,
 					      void *value);
-LIBBPF_API int bpf_map_lookup_and_delete_elem_flags(int fd, const void *key,
-						    void *value, __u64 flags);
 LIBBPF_API int bpf_map_delete_elem(int fd, const void *key);
-LIBBPF_API int bpf_map_delete_elem_flags(int fd, const void *key, __u64 flags);
 LIBBPF_API int bpf_map_get_next_key(int fd, const void *key, void *next_key);
 LIBBPF_API int bpf_map_freeze(int fd);
 
@@ -167,227 +135,38 @@ struct bpf_map_batch_opts {
 };
 #define bpf_map_batch_opts__last_field flags
 
-
-/**
- * @brief **bpf_map_delete_batch()** allows for batch deletion of multiple
- * elements in a BPF map.
- *
- * @param fd BPF map file descriptor
- * @param keys pointer to an array of *count* keys
- * @param count input and output parameter; on input **count** represents the
- * number of  elements in the map to delete in batch;
- * on output if a non-EFAULT error is returned, **count** represents the number of deleted
- * elements if the output **count** value is not equal to the input **count** value
- * If EFAULT is returned, **count** should not be trusted to be correct.
- * @param opts options for configuring the way the batch deletion works
- * @return 0, on success; negative error code, otherwise (errno is also set to
- * the error code)
- */
-LIBBPF_API int bpf_map_delete_batch(int fd, const void *keys,
+LIBBPF_API int bpf_map_delete_batch(int fd, void *keys,
 				    __u32 *count,
 				    const struct bpf_map_batch_opts *opts);
-
-/**
- * @brief **bpf_map_lookup_batch()** allows for batch lookup of BPF map elements.
- *
- * The parameter *in_batch* is the address of the first element in the batch to
- * read. *out_batch* is an output parameter that should be passed as *in_batch*
- * to subsequent calls to **bpf_map_lookup_batch()**. NULL can be passed for
- * *in_batch* to indicate that the batched lookup starts from the beginning of
- * the map. Both *in_batch* and *out_batch* must point to memory large enough to
- * hold a single key, except for maps of type **BPF_MAP_TYPE_{HASH, PERCPU_HASH,
- * LRU_HASH, LRU_PERCPU_HASH}**, for which the memory size must be at
- * least 4 bytes wide regardless of key size.
- *
- * The *keys* and *values* are output parameters which must point to memory large enough to
- * hold *count* items based on the key and value size of the map *map_fd*. The *keys*
- * buffer must be of *key_size* * *count*. The *values* buffer must be of
- * *value_size* * *count*.
- *
- * @param fd BPF map file descriptor
- * @param in_batch address of the first element in batch to read, can pass NULL to
- * indicate that the batched lookup starts from the beginning of the map.
- * @param out_batch output parameter that should be passed to next call as *in_batch*
- * @param keys pointer to an array large enough for *count* keys
- * @param values pointer to an array large enough for *count* values
- * @param count input and output parameter; on input it's the number of elements
- * in the map to read in batch; on output it's the number of elements that were
- * successfully read.
- * If a non-EFAULT error is returned, count will be set as the number of elements
- * that were read before the error occurred.
- * If EFAULT is returned, **count** should not be trusted to be correct.
- * @param opts options for configuring the way the batch lookup works
- * @return 0, on success; negative error code, otherwise (errno is also set to
- * the error code)
- */
 LIBBPF_API int bpf_map_lookup_batch(int fd, void *in_batch, void *out_batch,
 				    void *keys, void *values, __u32 *count,
 				    const struct bpf_map_batch_opts *opts);
-
-/**
- * @brief **bpf_map_lookup_and_delete_batch()** allows for batch lookup and deletion
- * of BPF map elements where each element is deleted after being retrieved.
- *
- * @param fd BPF map file descriptor
- * @param in_batch address of the first element in batch to read, can pass NULL to
- * get address of the first element in *out_batch*. If not NULL, must be large
- * enough to hold a key. For **BPF_MAP_TYPE_{HASH, PERCPU_HASH, LRU_HASH,
- * LRU_PERCPU_HASH}**, the memory size must be at least 4 bytes wide regardless
- * of key size.
- * @param out_batch output parameter that should be passed to next call as *in_batch*
- * @param keys pointer to an array of *count* keys
- * @param values pointer to an array large enough for *count* values
- * @param count input and output parameter; on input it's the number of elements
- * in the map to read and delete in batch; on output it represents the number of
- * elements that were successfully read and deleted
- * If a non-**EFAULT** error code is returned and if the output **count** value
- * is not equal to the input **count** value, up to **count** elements may
- * have been deleted.
- * if **EFAULT** is returned up to *count* elements may have been deleted without
- * being returned via the *keys* and *values* output parameters.
- * @param opts options for configuring the way the batch lookup and delete works
- * @return 0, on success; negative error code, otherwise (errno is also set to
- * the error code)
- */
 LIBBPF_API int bpf_map_lookup_and_delete_batch(int fd, void *in_batch,
 					void *out_batch, void *keys,
 					void *values, __u32 *count,
 					const struct bpf_map_batch_opts *opts);
-
-/**
- * @brief **bpf_map_update_batch()** updates multiple elements in a map
- * by specifying keys and their corresponding values.
- *
- * The *keys* and *values* parameters must point to memory large enough
- * to hold *count* items based on the key and value size of the map.
- *
- * The *opts* parameter can be used to control how *bpf_map_update_batch()*
- * should handle keys that either do or do not already exist in the map.
- * In particular the *flags* parameter of *bpf_map_batch_opts* can be
- * one of the following:
- *
- * Note that *count* is an input and output parameter, where on output it
- * represents how many elements were successfully updated. Also note that if
- * **EFAULT** then *count* should not be trusted to be correct.
- *
- * **BPF_ANY**
- *    Create new elements or update existing.
- *
- * **BPF_NOEXIST**
- *    Create new elements only if they do not exist.
- *
- * **BPF_EXIST**
- *    Update existing elements.
- *
- * **BPF_F_LOCK**
- *    Update spin_lock-ed map elements. This must be
- *    specified if the map value contains a spinlock.
- *
- * @param fd BPF map file descriptor
- * @param keys pointer to an array of *count* keys
- * @param values pointer to an array of *count* values
- * @param count input and output parameter; on input it's the number of elements
- * in the map to update in batch; on output if a non-EFAULT error is returned,
- * **count** represents the number of updated elements if the output **count**
- * value is not equal to the input **count** value.
- * If EFAULT is returned, **count** should not be trusted to be correct.
- * @param opts options for configuring the way the batch update works
- * @return 0, on success; negative error code, otherwise (errno is also set to
- * the error code)
- */
-LIBBPF_API int bpf_map_update_batch(int fd, const void *keys, const void *values,
+LIBBPF_API int bpf_map_update_batch(int fd, void *keys, void *values,
 				    __u32 *count,
 				    const struct bpf_map_batch_opts *opts);
 
-struct bpf_obj_pin_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-
-	__u32 file_flags;
-	int path_fd;
-
-	size_t :0;
-};
-#define bpf_obj_pin_opts__last_field path_fd
-
 LIBBPF_API int bpf_obj_pin(int fd, const char *pathname);
-LIBBPF_API int bpf_obj_pin_opts(int fd, const char *pathname,
-				const struct bpf_obj_pin_opts *opts);
-
-struct bpf_obj_get_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-
-	__u32 file_flags;
-	int path_fd;
-
-	size_t :0;
-};
-#define bpf_obj_get_opts__last_field path_fd
-
 LIBBPF_API int bpf_obj_get(const char *pathname);
-LIBBPF_API int bpf_obj_get_opts(const char *pathname,
-				const struct bpf_obj_get_opts *opts);
-
-LIBBPF_API int bpf_prog_attach(int prog_fd, int attachable_fd,
-			       enum bpf_attach_type type, unsigned int flags);
-LIBBPF_API int bpf_prog_detach(int attachable_fd, enum bpf_attach_type type);
-LIBBPF_API int bpf_prog_detach2(int prog_fd, int attachable_fd,
-				enum bpf_attach_type type);
 
 struct bpf_prog_attach_opts {
 	size_t sz; /* size of this struct for forward/backward compatibility */
-	__u32 flags;
-	union {
-		int replace_prog_fd;
-		int replace_fd;
-	};
-	int relative_fd;
-	__u32 relative_id;
-	__u64 expected_revision;
-	size_t :0;
+	unsigned int flags;
+	int replace_prog_fd;
 };
-#define bpf_prog_attach_opts__last_field expected_revision
+#define bpf_prog_attach_opts__last_field replace_prog_fd
 
-struct bpf_prog_detach_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-	__u32 flags;
-	int relative_fd;
-	__u32 relative_id;
-	__u64 expected_revision;
-	size_t :0;
-};
-#define bpf_prog_detach_opts__last_field expected_revision
-
-/**
- * @brief **bpf_prog_attach_opts()** attaches the BPF program corresponding to
- * *prog_fd* to a *target* which can represent a file descriptor or netdevice
- * ifindex.
- *
- * @param prog_fd BPF program file descriptor
- * @param target attach location file descriptor or ifindex
- * @param type attach type for the BPF program
- * @param opts options for configuring the attachment
- * @return 0, on success; negative error code, otherwise (errno is also set to
- * the error code)
- */
-LIBBPF_API int bpf_prog_attach_opts(int prog_fd, int target,
-				    enum bpf_attach_type type,
-				    const struct bpf_prog_attach_opts *opts);
-
-/**
- * @brief **bpf_prog_detach_opts()** detaches the BPF program corresponding to
- * *prog_fd* from a *target* which can represent a file descriptor or netdevice
- * ifindex.
- *
- * @param prog_fd BPF program file descriptor
- * @param target detach location file descriptor or ifindex
- * @param type detach type for the BPF program
- * @param opts options for configuring the detachment
- * @return 0, on success; negative error code, otherwise (errno is also set to
- * the error code)
- */
-LIBBPF_API int bpf_prog_detach_opts(int prog_fd, int target,
-				    enum bpf_attach_type type,
-				    const struct bpf_prog_detach_opts *opts);
+LIBBPF_API int bpf_prog_attach(int prog_fd, int attachable_fd,
+			       enum bpf_attach_type type, unsigned int flags);
+LIBBPF_API int bpf_prog_attach_xattr(int prog_fd, int attachable_fd,
+				     enum bpf_attach_type type,
+				     const struct bpf_prog_attach_opts *opts);
+LIBBPF_API int bpf_prog_detach(int attachable_fd, enum bpf_attach_type type);
+LIBBPF_API int bpf_prog_detach2(int prog_fd, int attachable_fd,
+				enum bpf_attach_type type);
 
 union bpf_iter_link_info; /* defined in up-to-date linux/bpf.h */
 struct bpf_link_create_opts {
@@ -395,50 +174,8 @@ struct bpf_link_create_opts {
 	__u32 flags;
 	union bpf_iter_link_info *iter_info;
 	__u32 iter_info_len;
-	__u32 target_btf_id;
-	union {
-		struct {
-			__u64 bpf_cookie;
-		} perf_event;
-		struct {
-			__u32 flags;
-			__u32 cnt;
-			const char **syms;
-			const unsigned long *addrs;
-			const __u64 *cookies;
-		} kprobe_multi;
-		struct {
-			__u32 flags;
-			__u32 cnt;
-			const char *path;
-			const unsigned long *offsets;
-			const unsigned long *ref_ctr_offsets;
-			const __u64 *cookies;
-			__u32 pid;
-		} uprobe_multi;
-		struct {
-			__u64 cookie;
-		} tracing;
-		struct {
-			__u32 pf;
-			__u32 hooknum;
-			__s32 priority;
-			__u32 flags;
-		} netfilter;
-		struct {
-			__u32 relative_fd;
-			__u32 relative_id;
-			__u64 expected_revision;
-		} tcx;
-		struct {
-			__u32 relative_fd;
-			__u32 relative_id;
-			__u64 expected_revision;
-		} netkit;
-	};
-	size_t :0;
 };
-#define bpf_link_create_opts__last_field uprobe_multi.pid
+#define bpf_link_create_opts__last_field iter_info_len
 
 LIBBPF_API int bpf_link_create(int prog_fd, int target_fd,
 			       enum bpf_attach_type attach_type,
@@ -450,9 +187,8 @@ struct bpf_link_update_opts {
 	size_t sz; /* size of this struct for forward/backward compatibility */
 	__u32 flags;	   /* extra flags */
 	__u32 old_prog_fd; /* expected old program FD */
-	__u32 old_map_fd;  /* expected old map FD */
 };
-#define bpf_link_update_opts__last_field old_map_fd
+#define bpf_link_update_opts__last_field old_prog_fd
 
 LIBBPF_API int bpf_link_update(int link_fd, int new_prog_fd,
 			       const struct bpf_link_update_opts *opts);
@@ -476,229 +212,36 @@ struct bpf_prog_test_run_attr {
 			     * out: length of cxt_out */
 };
 
+LIBBPF_API int bpf_prog_test_run_xattr(struct bpf_prog_test_run_attr *test_attr);
+
+/*
+ * bpf_prog_test_run does not check that data_out is large enough. Consider
+ * using bpf_prog_test_run_xattr instead.
+ */
+LIBBPF_API int bpf_prog_test_run(int prog_fd, int repeat, void *data,
+				 __u32 size, void *data_out, __u32 *size_out,
+				 __u32 *retval, __u32 *duration);
 LIBBPF_API int bpf_prog_get_next_id(__u32 start_id, __u32 *next_id);
 LIBBPF_API int bpf_map_get_next_id(__u32 start_id, __u32 *next_id);
 LIBBPF_API int bpf_btf_get_next_id(__u32 start_id, __u32 *next_id);
 LIBBPF_API int bpf_link_get_next_id(__u32 start_id, __u32 *next_id);
-
-struct bpf_get_fd_by_id_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-	__u32 open_flags; /* permissions requested for the operation on fd */
-	size_t :0;
-};
-#define bpf_get_fd_by_id_opts__last_field open_flags
-
 LIBBPF_API int bpf_prog_get_fd_by_id(__u32 id);
-LIBBPF_API int bpf_prog_get_fd_by_id_opts(__u32 id,
-				const struct bpf_get_fd_by_id_opts *opts);
 LIBBPF_API int bpf_map_get_fd_by_id(__u32 id);
-LIBBPF_API int bpf_map_get_fd_by_id_opts(__u32 id,
-				const struct bpf_get_fd_by_id_opts *opts);
 LIBBPF_API int bpf_btf_get_fd_by_id(__u32 id);
-LIBBPF_API int bpf_btf_get_fd_by_id_opts(__u32 id,
-				const struct bpf_get_fd_by_id_opts *opts);
 LIBBPF_API int bpf_link_get_fd_by_id(__u32 id);
-LIBBPF_API int bpf_link_get_fd_by_id_opts(__u32 id,
-				const struct bpf_get_fd_by_id_opts *opts);
 LIBBPF_API int bpf_obj_get_info_by_fd(int bpf_fd, void *info, __u32 *info_len);
-
-/**
- * @brief **bpf_prog_get_info_by_fd()** obtains information about the BPF
- * program corresponding to *prog_fd*.
- *
- * Populates up to *info_len* bytes of *info* and updates *info_len* with the
- * actual number of bytes written to *info*. Note that *info* should be
- * zero-initialized or initialized as expected by the requested *info*
- * type. Failing to (zero-)initialize *info* under certain circumstances can
- * result in this helper returning an error.
- *
- * @param prog_fd BPF program file descriptor
- * @param info pointer to **struct bpf_prog_info** that will be populated with
- * BPF program information
- * @param info_len pointer to the size of *info*; on success updated with the
- * number of bytes written to *info*
- * @return 0, on success; negative error code, otherwise (errno is also set to
- * the error code)
- */
-LIBBPF_API int bpf_prog_get_info_by_fd(int prog_fd, struct bpf_prog_info *info, __u32 *info_len);
-
-/**
- * @brief **bpf_map_get_info_by_fd()** obtains information about the BPF
- * map corresponding to *map_fd*.
- *
- * Populates up to *info_len* bytes of *info* and updates *info_len* with the
- * actual number of bytes written to *info*. Note that *info* should be
- * zero-initialized or initialized as expected by the requested *info*
- * type. Failing to (zero-)initialize *info* under certain circumstances can
- * result in this helper returning an error.
- *
- * @param map_fd BPF map file descriptor
- * @param info pointer to **struct bpf_map_info** that will be populated with
- * BPF map information
- * @param info_len pointer to the size of *info*; on success updated with the
- * number of bytes written to *info*
- * @return 0, on success; negative error code, otherwise (errno is also set to
- * the error code)
- */
-LIBBPF_API int bpf_map_get_info_by_fd(int map_fd, struct bpf_map_info *info, __u32 *info_len);
-
-/**
- * @brief **bpf_btf_get_info_by_fd()** obtains information about the
- * BTF object corresponding to *btf_fd*.
- *
- * Populates up to *info_len* bytes of *info* and updates *info_len* with the
- * actual number of bytes written to *info*. Note that *info* should be
- * zero-initialized or initialized as expected by the requested *info*
- * type. Failing to (zero-)initialize *info* under certain circumstances can
- * result in this helper returning an error.
- *
- * @param btf_fd BTF object file descriptor
- * @param info pointer to **struct bpf_btf_info** that will be populated with
- * BTF object information
- * @param info_len pointer to the size of *info*; on success updated with the
- * number of bytes written to *info*
- * @return 0, on success; negative error code, otherwise (errno is also set to
- * the error code)
- */
-LIBBPF_API int bpf_btf_get_info_by_fd(int btf_fd, struct bpf_btf_info *info, __u32 *info_len);
-
-/**
- * @brief **bpf_btf_get_info_by_fd()** obtains information about the BPF
- * link corresponding to *link_fd*.
- *
- * Populates up to *info_len* bytes of *info* and updates *info_len* with the
- * actual number of bytes written to *info*. Note that *info* should be
- * zero-initialized or initialized as expected by the requested *info*
- * type. Failing to (zero-)initialize *info* under certain circumstances can
- * result in this helper returning an error.
- *
- * @param link_fd BPF link file descriptor
- * @param info pointer to **struct bpf_link_info** that will be populated with
- * BPF link information
- * @param info_len pointer to the size of *info*; on success updated with the
- * number of bytes written to *info*
- * @return 0, on success; negative error code, otherwise (errno is also set to
- * the error code)
- */
-LIBBPF_API int bpf_link_get_info_by_fd(int link_fd, struct bpf_link_info *info, __u32 *info_len);
-
-struct bpf_prog_query_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-	__u32 query_flags;
-	__u32 attach_flags; /* output argument */
-	__u32 *prog_ids;
-	union {
-		/* input+output argument */
-		__u32 prog_cnt;
-		__u32 count;
-	};
-	__u32 *prog_attach_flags;
-	__u32 *link_ids;
-	__u32 *link_attach_flags;
-	__u64 revision;
-	size_t :0;
-};
-#define bpf_prog_query_opts__last_field revision
-
-/**
- * @brief **bpf_prog_query_opts()** queries the BPF programs and BPF links
- * which are attached to *target* which can represent a file descriptor or
- * netdevice ifindex.
- *
- * @param target query location file descriptor or ifindex
- * @param type attach type for the BPF program
- * @param opts options for configuring the query
- * @return 0, on success; negative error code, otherwise (errno is also set to
- * the error code)
- */
-LIBBPF_API int bpf_prog_query_opts(int target, enum bpf_attach_type type,
-				   struct bpf_prog_query_opts *opts);
 LIBBPF_API int bpf_prog_query(int target_fd, enum bpf_attach_type type,
 			      __u32 query_flags, __u32 *attach_flags,
 			      __u32 *prog_ids, __u32 *prog_cnt);
-
-struct bpf_raw_tp_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-	const char *tp_name;
-	__u64 cookie;
-	size_t :0;
-};
-#define bpf_raw_tp_opts__last_field cookie
-
-LIBBPF_API int bpf_raw_tracepoint_open_opts(int prog_fd, struct bpf_raw_tp_opts *opts);
 LIBBPF_API int bpf_raw_tracepoint_open(const char *name, int prog_fd);
+LIBBPF_API int bpf_load_btf(void *btf, __u32 btf_size, char *log_buf,
+			    __u32 log_buf_size, bool do_log);
 LIBBPF_API int bpf_task_fd_query(int pid, int fd, __u32 flags, char *buf,
 				 __u32 *buf_len, __u32 *prog_id, __u32 *fd_type,
 				 __u64 *probe_offset, __u64 *probe_addr);
 
-#ifdef __cplusplus
-/* forward-declaring enums in C++ isn't compatible with pure C enums, so
- * instead define bpf_enable_stats() as accepting int as an input
- */
-LIBBPF_API int bpf_enable_stats(int type);
-#else
 enum bpf_stats_type; /* defined in up-to-date linux/bpf.h */
 LIBBPF_API int bpf_enable_stats(enum bpf_stats_type type);
-#endif
-
-struct bpf_prog_bind_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-	__u32 flags;
-};
-#define bpf_prog_bind_opts__last_field flags
-
-LIBBPF_API int bpf_prog_bind_map(int prog_fd, int map_fd,
-				 const struct bpf_prog_bind_opts *opts);
-
-struct bpf_test_run_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-	const void *data_in; /* optional */
-	void *data_out;      /* optional */
-	__u32 data_size_in;
-	__u32 data_size_out; /* in: max length of data_out
-			      * out: length of data_out
-			      */
-	const void *ctx_in; /* optional */
-	void *ctx_out;      /* optional */
-	__u32 ctx_size_in;
-	__u32 ctx_size_out; /* in: max length of ctx_out
-			     * out: length of cxt_out
-			     */
-	__u32 retval;        /* out: return code of the BPF program */
-	int repeat;
-	__u32 duration;      /* out: average per repetition in ns */
-	__u32 flags;
-	__u32 cpu;
-	__u32 batch_size;
-};
-#define bpf_test_run_opts__last_field batch_size
-
-LIBBPF_API int bpf_prog_test_run_opts(int prog_fd,
-				      struct bpf_test_run_opts *opts);
-
-struct bpf_token_create_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-	__u32 flags;
-	size_t :0;
-};
-#define bpf_token_create_opts__last_field flags
-
-/**
- * @brief **bpf_token_create()** creates a new instance of BPF token derived
- * from specified BPF FS mount point.
- *
- * BPF token created with this API can be passed to bpf() syscall for
- * commands like BPF_PROG_LOAD, BPF_MAP_CREATE, etc.
- *
- * @param bpffs_fd FD for BPF FS instance from which to derive a BPF token
- * instance.
- * @param opts optional BPF token creation options, can be NULL
- *
- * @return BPF token FD > 0, on success; negative error code, otherwise (errno
- * is also set to the error code)
- */
-LIBBPF_API int bpf_token_create(int bpffs_fd,
-				struct bpf_token_create_opts *opts);
 
 #ifdef __cplusplus
 } /* extern "C" */

src/bpf_core_read.h

@@ -2,8 +2,6 @@
 #ifndef __BPF_CORE_READ_H__
 #define __BPF_CORE_READ_H__
 
-#include "bpf_helpers.h"
-
 /*
  * enum bpf_field_info_kind is passed as a second argument into
  * __builtin_preserve_field_info() built-in to get a specific aspect of
@@ -21,53 +19,32 @@ enum bpf_field_info_kind {
 	BPF_FIELD_RSHIFT_U64 = 5,
 };
 
-/* second argument to __builtin_btf_type_id() built-in */
-enum bpf_type_id_kind {
-	BPF_TYPE_ID_LOCAL = 0,		/* BTF type ID in local program */
-	BPF_TYPE_ID_TARGET = 1,		/* BTF type ID in target kernel */
-};
-
-/* second argument to __builtin_preserve_type_info() built-in */
-enum bpf_type_info_kind {
-	BPF_TYPE_EXISTS = 0,		/* type existence in target kernel */
-	BPF_TYPE_SIZE = 1,		/* type size in target kernel */
-	BPF_TYPE_MATCHES = 2,		/* type match in target kernel */
-};
-
-/* second argument to __builtin_preserve_enum_value() built-in */
-enum bpf_enum_value_kind {
-	BPF_ENUMVAL_EXISTS = 0,		/* enum value existence in kernel */
-	BPF_ENUMVAL_VALUE = 1,		/* enum value value relocation */
-};
-
 #define __CORE_RELO(src, field, info)					      \
 	__builtin_preserve_field_info((src)->field, BPF_FIELD_##info)
 
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#if __BYTE_ORDER == __LITTLE_ENDIAN
 #define __CORE_BITFIELD_PROBE_READ(dst, src, fld)			      \
-	bpf_probe_read_kernel(						      \
-			(void *)dst,					      \
-			__CORE_RELO(src, fld, BYTE_SIZE),		      \
-			(const void *)src + __CORE_RELO(src, fld, BYTE_OFFSET))
+	bpf_probe_read((void *)dst,					      \
+		       __CORE_RELO(src, fld, BYTE_SIZE),		      \
+		       (const void *)src + __CORE_RELO(src, fld, BYTE_OFFSET))
 #else
 /* semantics of LSHIFT_64 assumes loading values into low-ordered bytes, so
  * for big-endian we need to adjust destination pointer accordingly, based on
  * field byte size
  */
 #define __CORE_BITFIELD_PROBE_READ(dst, src, fld)			      \
-	bpf_probe_read_kernel(						      \
-			(void *)dst + (8 - __CORE_RELO(src, fld, BYTE_SIZE)), \
-			__CORE_RELO(src, fld, BYTE_SIZE),		      \
-			(const void *)src + __CORE_RELO(src, fld, BYTE_OFFSET))
+	bpf_probe_read((void *)dst + (8 - __CORE_RELO(src, fld, BYTE_SIZE)),  \
+		       __CORE_RELO(src, fld, BYTE_SIZE),		      \
+		       (const void *)src + __CORE_RELO(src, fld, BYTE_OFFSET))
 #endif
 
 /*
  * Extract bitfield, identified by s->field, and return its value as u64.
  * All this is done in relocatable manner, so bitfield changes such as
  * signedness, bit size, offset changes, this will be handled automatically.
- * This version of macro is using bpf_probe_read_kernel() to read underlying
- * integer storage. Macro functions as an expression and its return type is
- * bpf_probe_read_kernel()'s return value: 0, on success, <0 on error.
+ * This version of macro is using bpf_probe_read() to read underlying integer
+ * storage. Macro functions as an expression and its return type is
+ * bpf_probe_read()'s return value: 0, on success, <0 on error.
  */
 #define BPF_CORE_READ_BITFIELD_PROBED(s, field) ({			      \
 	unsigned long long val = 0;					      \
@@ -91,20 +68,11 @@ enum bpf_enum_value_kind {
 	const void *p = (const void *)s + __CORE_RELO(s, field, BYTE_OFFSET); \
 	unsigned long long val;						      \
 									      \
-	/* This is a so-called barrier_var() operation that makes specified   \
-	 * variable "a black box" for optimizing compiler.		      \
-	 * It forces compiler to perform BYTE_OFFSET relocation on p and use  \
-	 * its calculated value in the switch below, instead of applying      \
-	 * the same relocation 4 times for each individual memory load.       \
-	 */								      \
-	asm volatile("" : "=r"(p) : "0"(p));				      \
-									      \
 	switch (__CORE_RELO(s, field, BYTE_SIZE)) {			      \
-	case 1: val = *(const unsigned char *)p; break;			      \
-	case 2: val = *(const unsigned short *)p; break;		      \
-	case 4: val = *(const unsigned int *)p; break;			      \
-	case 8: val = *(const unsigned long long *)p; break;		      \
-	default: val = 0; break;					      \
+	case 1: val = *(const unsigned char *)p;			      \
+	case 2: val = *(const unsigned short *)p;			      \
+	case 4: val = *(const unsigned int *)p;				      \
+	case 8: val = *(const unsigned long long *)p;			      \
 	}								      \
 	val <<= __CORE_RELO(s, field, LSHIFT_U64);			      \
 	if (__CORE_RELO(s, field, SIGNED))				      \
@@ -114,187 +82,25 @@ enum bpf_enum_value_kind {
 	val;								      \
 })
 
-/*
- * Write to a bitfield, identified by s->field.
- * This is the inverse of BPF_CORE_WRITE_BITFIELD().
- */
-#define BPF_CORE_WRITE_BITFIELD(s, field, new_val) ({			\
-	void *p = (void *)s + __CORE_RELO(s, field, BYTE_OFFSET);	\
-	unsigned int byte_size = __CORE_RELO(s, field, BYTE_SIZE);	\
-	unsigned int lshift = __CORE_RELO(s, field, LSHIFT_U64);	\
-	unsigned int rshift = __CORE_RELO(s, field, RSHIFT_U64);	\
-	unsigned long long mask, val, nval = new_val;			\
-	unsigned int rpad = rshift - lshift;				\
-									\
-	asm volatile("" : "+r"(p));					\
-									\
-	switch (byte_size) {						\
-	case 1: val = *(unsigned char *)p; break;			\
-	case 2: val = *(unsigned short *)p; break;			\
-	case 4: val = *(unsigned int *)p; break;			\
-	case 8: val = *(unsigned long long *)p; break;			\
-	}								\
-									\
-	mask = (~0ULL << rshift) >> lshift;				\
-	val = (val & ~mask) | ((nval << rpad) & mask);			\
-									\
-	switch (byte_size) {						\
-	case 1: *(unsigned char *)p      = val; break;			\
-	case 2: *(unsigned short *)p     = val; break;			\
-	case 4: *(unsigned int *)p       = val; break;			\
-	case 8: *(unsigned long long *)p = val; break;			\
-	}								\
-})
-
-/* Differentiator between compilers builtin implementations. This is a
- * requirement due to the compiler parsing differences where GCC optimizes
- * early in parsing those constructs of type pointers to the builtin specific
- * type, resulting in not being possible to collect the required type
- * information in the builtin expansion.
- */
-#ifdef __clang__
-#define ___bpf_typeof(type) ((typeof(type) *) 0)
-#else
-#define ___bpf_typeof1(type, NR) ({					    \
-	extern typeof(type) *___concat(bpf_type_tmp_, NR);		    \
-	___concat(bpf_type_tmp_, NR);					    \
-})
-#define ___bpf_typeof(type) ___bpf_typeof1(type, __COUNTER__)
-#endif
-
-#ifdef __clang__
-#define ___bpf_field_ref1(field)	(field)
-#define ___bpf_field_ref2(type, field)	(___bpf_typeof(type)->field)
-#else
-#define ___bpf_field_ref1(field)	(&(field))
-#define ___bpf_field_ref2(type, field)	(&(___bpf_typeof(type)->field))
-#endif
-#define ___bpf_field_ref(args...)					    \
-	___bpf_apply(___bpf_field_ref, ___bpf_narg(args))(args)
-
 /*
  * Convenience macro to check that field actually exists in target kernel's.
  * Returns:
  *    1, if matching field is present in target kernel;
  *    0, if no matching field found.
- *
- * Supports two forms:
- *   - field reference through variable access:
- *     bpf_core_field_exists(p->my_field);
- *   - field reference through type and field names:
- *     bpf_core_field_exists(struct my_type, my_field).
  */
-#define bpf_core_field_exists(field...)					    \
-	__builtin_preserve_field_info(___bpf_field_ref(field), BPF_FIELD_EXISTS)
+#define bpf_core_field_exists(field)					    \
+	__builtin_preserve_field_info(field, BPF_FIELD_EXISTS)
 
 /*
- * Convenience macro to get the byte size of a field. Works for integers,
+ * Convenience macro to get byte size of a field. Works for integers,
  * struct/unions, pointers, arrays, and enums.
- *
- * Supports two forms:
- *   - field reference through variable access:
- *     bpf_core_field_size(p->my_field);
- *   - field reference through type and field names:
- *     bpf_core_field_size(struct my_type, my_field).
  */
-#define bpf_core_field_size(field...)					    \
-	__builtin_preserve_field_info(___bpf_field_ref(field), BPF_FIELD_BYTE_SIZE)
+#define bpf_core_field_size(field)					    \
+	__builtin_preserve_field_info(field, BPF_FIELD_BYTE_SIZE)
 
 /*
- * Convenience macro to get field's byte offset.
- *
- * Supports two forms:
- *   - field reference through variable access:
- *     bpf_core_field_offset(p->my_field);
- *   - field reference through type and field names:
- *     bpf_core_field_offset(struct my_type, my_field).
- */
-#define bpf_core_field_offset(field...)					    \
-	__builtin_preserve_field_info(___bpf_field_ref(field), BPF_FIELD_BYTE_OFFSET)
-
-/*
- * Convenience macro to get BTF type ID of a specified type, using a local BTF
- * information. Return 32-bit unsigned integer with type ID from program's own
- * BTF. Always succeeds.
- */
-#define bpf_core_type_id_local(type)					    \
-	__builtin_btf_type_id(*___bpf_typeof(type), BPF_TYPE_ID_LOCAL)
-
-/*
- * Convenience macro to get BTF type ID of a target kernel's type that matches
- * specified local type.
- * Returns:
- *    - valid 32-bit unsigned type ID in kernel BTF;
- *    - 0, if no matching type was found in a target kernel BTF.
- */
-#define bpf_core_type_id_kernel(type)					    \
-	__builtin_btf_type_id(*___bpf_typeof(type), BPF_TYPE_ID_TARGET)
-
-/*
- * Convenience macro to check that provided named type
- * (struct/union/enum/typedef) exists in a target kernel.
- * Returns:
- *    1, if such type is present in target kernel's BTF;
- *    0, if no matching type is found.
- */
-#define bpf_core_type_exists(type)					    \
-	__builtin_preserve_type_info(*___bpf_typeof(type), BPF_TYPE_EXISTS)
-
-/*
- * Convenience macro to check that provided named type
- * (struct/union/enum/typedef) "matches" that in a target kernel.
- * Returns:
- *    1, if the type matches in the target kernel's BTF;
- *    0, if the type does not match any in the target kernel
- */
-#define bpf_core_type_matches(type)					    \
-	__builtin_preserve_type_info(*___bpf_typeof(type), BPF_TYPE_MATCHES)
-
-/*
- * Convenience macro to get the byte size of a provided named type
- * (struct/union/enum/typedef) in a target kernel.
- * Returns:
- *    >= 0 size (in bytes), if type is present in target kernel's BTF;
- *    0, if no matching type is found.
- */
-#define bpf_core_type_size(type)					    \
-	__builtin_preserve_type_info(*___bpf_typeof(type), BPF_TYPE_SIZE)
-
-/*
- * Convenience macro to check that provided enumerator value is defined in
- * a target kernel.
- * Returns:
- *    1, if specified enum type and its enumerator value are present in target
- *    kernel's BTF;
- *    0, if no matching enum and/or enum value within that enum is found.
- */
-#ifdef __clang__
-#define bpf_core_enum_value_exists(enum_type, enum_value)		    \
-	__builtin_preserve_enum_value(*(typeof(enum_type) *)enum_value, BPF_ENUMVAL_EXISTS)
-#else
-#define bpf_core_enum_value_exists(enum_type, enum_value)		    \
-	__builtin_preserve_enum_value(___bpf_typeof(enum_type), enum_value, BPF_ENUMVAL_EXISTS)
-#endif
-
-/*
- * Convenience macro to get the integer value of an enumerator value in
- * a target kernel.
- * Returns:
- *    64-bit value, if specified enum type and its enumerator value are
- *    present in target kernel's BTF;
- *    0, if no matching enum and/or enum value within that enum is found.
- */
-#ifdef __clang__
-#define bpf_core_enum_value(enum_type, enum_value)			    \
-	__builtin_preserve_enum_value(*(typeof(enum_type) *)enum_value, BPF_ENUMVAL_VALUE)
-#else
-#define bpf_core_enum_value(enum_type, enum_value)			    \
-	__builtin_preserve_enum_value(___bpf_typeof(enum_type), enum_value, BPF_ENUMVAL_VALUE)
-#endif
-
-/*
- * bpf_core_read() abstracts away bpf_probe_read_kernel() call and captures
- * offset relocation for source address using __builtin_preserve_access_index()
+ * bpf_core_read() abstracts away bpf_probe_read() call and captures offset
+ * relocation for source address using __builtin_preserve_access_index()
  * built-in, provided by Clang.
  *
  * __builtin_preserve_access_index() takes as an argument an expression of
@@ -302,40 +108,24 @@ enum bpf_enum_value_kind {
  * a relocation, which records BTF type ID describing root struct/union and an
  * accessor string which describes exact embedded field that was used to take
  * an address. See detailed description of this relocation format and
- * semantics in comments to struct bpf_core_relo in include/uapi/linux/bpf.h.
+ * semantics in comments to struct bpf_field_reloc in libbpf_internal.h.
  *
  * This relocation allows libbpf to adjust BPF instruction to use correct
  * actual field offset, based on target kernel BTF type that matches original
  * (local) BTF, used to record relocation.
  */
 #define bpf_core_read(dst, sz, src)					    \
-	bpf_probe_read_kernel(dst, sz, (const void *)__builtin_preserve_access_index(src))
+	bpf_probe_read(dst, sz,						    \
+		       (const void *)__builtin_preserve_access_index(src))
 
-/* NOTE: see comments for BPF_CORE_READ_USER() about the proper types use. */
-#define bpf_core_read_user(dst, sz, src)				    \
-	bpf_probe_read_user(dst, sz, (const void *)__builtin_preserve_access_index(src))
 /*
  * bpf_core_read_str() is a thin wrapper around bpf_probe_read_str()
  * additionally emitting BPF CO-RE field relocation for specified source
  * argument.
  */
 #define bpf_core_read_str(dst, sz, src)					    \
-	bpf_probe_read_kernel_str(dst, sz, (const void *)__builtin_preserve_access_index(src))
-
-/* NOTE: see comments for BPF_CORE_READ_USER() about the proper types use. */
-#define bpf_core_read_user_str(dst, sz, src)				    \
-	bpf_probe_read_user_str(dst, sz, (const void *)__builtin_preserve_access_index(src))
-
-extern void *bpf_rdonly_cast(const void *obj, __u32 btf_id) __ksym __weak;
-
-/*
- * Cast provided pointer *ptr* into a pointer to a specified *type* in such
- * a way that BPF verifier will become aware of associated kernel-side BTF
- * type. This allows to access members of kernel types directly without the
- * need to use BPF_CORE_READ() macros.
- */
-#define bpf_core_cast(ptr, type)					    \
-	((typeof(type) *)bpf_rdonly_cast((ptr), bpf_core_type_id_kernel(type)))
+	bpf_probe_read_str(dst, sz,					    \
+			   (const void *)__builtin_preserve_access_index(src))
 
 #define ___concat(a, b) a ## b
 #define ___apply(fn, n) ___concat(fn, n)
@@ -394,29 +184,30 @@ extern void *bpf_rdonly_cast(const void *obj, __u32 btf_id) __ksym __weak;
 	read_fn((void *)(dst), sizeof(*(dst)), &((src_type)(src))->accessor)
 
 /* "recursively" read a sequence of inner pointers using local __t var */
-#define ___rd_first(fn, src, a) ___read(fn, &__t, ___type(src), src, a);
-#define ___rd_last(fn, ...)						    \
-	___read(fn, &__t, ___type(___nolast(__VA_ARGS__)), __t, ___last(__VA_ARGS__));
-#define ___rd_p1(fn, ...) const void *__t; ___rd_first(fn, __VA_ARGS__)
-#define ___rd_p2(fn, ...) ___rd_p1(fn, ___nolast(__VA_ARGS__)) ___rd_last(fn, __VA_ARGS__)
-#define ___rd_p3(fn, ...) ___rd_p2(fn, ___nolast(__VA_ARGS__)) ___rd_last(fn, __VA_ARGS__)
-#define ___rd_p4(fn, ...) ___rd_p3(fn, ___nolast(__VA_ARGS__)) ___rd_last(fn, __VA_ARGS__)
-#define ___rd_p5(fn, ...) ___rd_p4(fn, ___nolast(__VA_ARGS__)) ___rd_last(fn, __VA_ARGS__)
-#define ___rd_p6(fn, ...) ___rd_p5(fn, ___nolast(__VA_ARGS__)) ___rd_last(fn, __VA_ARGS__)
-#define ___rd_p7(fn, ...) ___rd_p6(fn, ___nolast(__VA_ARGS__)) ___rd_last(fn, __VA_ARGS__)
-#define ___rd_p8(fn, ...) ___rd_p7(fn, ___nolast(__VA_ARGS__)) ___rd_last(fn, __VA_ARGS__)
-#define ___rd_p9(fn, ...) ___rd_p8(fn, ___nolast(__VA_ARGS__)) ___rd_last(fn, __VA_ARGS__)
-#define ___read_ptrs(fn, src, ...)					    \
-	___apply(___rd_p, ___narg(__VA_ARGS__))(fn, src, __VA_ARGS__)
+#define ___rd_first(src, a) ___read(bpf_core_read, &__t, ___type(src), src, a);
+#define ___rd_last(...)							    \
+	___read(bpf_core_read, &__t,					    \
+		___type(___nolast(__VA_ARGS__)), __t, ___last(__VA_ARGS__));
+#define ___rd_p1(...) const void *__t; ___rd_first(__VA_ARGS__)
+#define ___rd_p2(...) ___rd_p1(___nolast(__VA_ARGS__)) ___rd_last(__VA_ARGS__)
+#define ___rd_p3(...) ___rd_p2(___nolast(__VA_ARGS__)) ___rd_last(__VA_ARGS__)
+#define ___rd_p4(...) ___rd_p3(___nolast(__VA_ARGS__)) ___rd_last(__VA_ARGS__)
+#define ___rd_p5(...) ___rd_p4(___nolast(__VA_ARGS__)) ___rd_last(__VA_ARGS__)
+#define ___rd_p6(...) ___rd_p5(___nolast(__VA_ARGS__)) ___rd_last(__VA_ARGS__)
+#define ___rd_p7(...) ___rd_p6(___nolast(__VA_ARGS__)) ___rd_last(__VA_ARGS__)
+#define ___rd_p8(...) ___rd_p7(___nolast(__VA_ARGS__)) ___rd_last(__VA_ARGS__)
+#define ___rd_p9(...) ___rd_p8(___nolast(__VA_ARGS__)) ___rd_last(__VA_ARGS__)
+#define ___read_ptrs(src, ...)						    \
+	___apply(___rd_p, ___narg(__VA_ARGS__))(src, __VA_ARGS__)
 
-#define ___core_read0(fn, fn_ptr, dst, src, a)				    \
+#define ___core_read0(fn, dst, src, a)					    \
 	___read(fn, dst, ___type(src), src, a);
-#define ___core_readN(fn, fn_ptr, dst, src, ...)			    \
-	___read_ptrs(fn_ptr, src, ___nolast(__VA_ARGS__))		    \
+#define ___core_readN(fn, dst, src, ...)				    \
+	___read_ptrs(src, ___nolast(__VA_ARGS__))			    \
 	___read(fn, dst, ___type(src, ___nolast(__VA_ARGS__)), __t,	    \
 		___last(__VA_ARGS__));
-#define ___core_read(fn, fn_ptr, dst, src, a, ...)			    \
-	___apply(___core_read, ___empty(__VA_ARGS__))(fn, fn_ptr, dst,	    \
+#define ___core_read(fn, dst, src, a, ...)				    \
+	___apply(___core_read, ___empty(__VA_ARGS__))(fn, dst,		    \
 						      src, a, ##__VA_ARGS__)
 
 /*
@@ -424,73 +215,20 @@ extern void *bpf_rdonly_cast(const void *obj, __u32 btf_id) __ksym __weak;
  * BPF_CORE_READ(), in which final field is read into user-provided storage.
  * See BPF_CORE_READ() below for more details on general usage.
  */
-#define BPF_CORE_READ_INTO(dst, src, a, ...) ({				    \
-	___core_read(bpf_core_read, bpf_core_read,			    \
-		     dst, (src), a, ##__VA_ARGS__)			    \
-})
-
-/*
- * Variant of BPF_CORE_READ_INTO() for reading from user-space memory.
- *
- * NOTE: see comments for BPF_CORE_READ_USER() about the proper types use.
- */
-#define BPF_CORE_READ_USER_INTO(dst, src, a, ...) ({			    \
-	___core_read(bpf_core_read_user, bpf_core_read_user,		    \
-		     dst, (src), a, ##__VA_ARGS__)			    \
-})
-
-/* Non-CO-RE variant of BPF_CORE_READ_INTO() */
-#define BPF_PROBE_READ_INTO(dst, src, a, ...) ({			    \
-	___core_read(bpf_probe_read_kernel, bpf_probe_read_kernel,	    \
-		     dst, (src), a, ##__VA_ARGS__)			    \
-})
-
-/* Non-CO-RE variant of BPF_CORE_READ_USER_INTO().
- *
- * As no CO-RE relocations are emitted, source types can be arbitrary and are
- * not restricted to kernel types only.
- */
-#define BPF_PROBE_READ_USER_INTO(dst, src, a, ...) ({			    \
-	___core_read(bpf_probe_read_user, bpf_probe_read_user,		    \
-		     dst, (src), a, ##__VA_ARGS__)			    \
-})
+#define BPF_CORE_READ_INTO(dst, src, a, ...)				    \
+	({								    \
+		___core_read(bpf_core_read, dst, (src), a, ##__VA_ARGS__)   \
+	})
 
 /*
  * BPF_CORE_READ_STR_INTO() does same "pointer chasing" as
  * BPF_CORE_READ() for intermediate pointers, but then executes (and returns
  * corresponding error code) bpf_core_read_str() for final string read.
  */
-#define BPF_CORE_READ_STR_INTO(dst, src, a, ...) ({			    \
-	___core_read(bpf_core_read_str, bpf_core_read,			    \
-		     dst, (src), a, ##__VA_ARGS__)			    \
-})
-
-/*
- * Variant of BPF_CORE_READ_STR_INTO() for reading from user-space memory.
- *
- * NOTE: see comments for BPF_CORE_READ_USER() about the proper types use.
- */
-#define BPF_CORE_READ_USER_STR_INTO(dst, src, a, ...) ({		    \
-	___core_read(bpf_core_read_user_str, bpf_core_read_user,	    \
-		     dst, (src), a, ##__VA_ARGS__)			    \
-})
-
-/* Non-CO-RE variant of BPF_CORE_READ_STR_INTO() */
-#define BPF_PROBE_READ_STR_INTO(dst, src, a, ...) ({			    \
-	___core_read(bpf_probe_read_kernel_str, bpf_probe_read_kernel,	    \
-		     dst, (src), a, ##__VA_ARGS__)			    \
-})
-
-/*
- * Non-CO-RE variant of BPF_CORE_READ_USER_STR_INTO().
- *
- * As no CO-RE relocations are emitted, source types can be arbitrary and are
- * not restricted to kernel types only.
- */
-#define BPF_PROBE_READ_USER_STR_INTO(dst, src, a, ...) ({		    \
-	___core_read(bpf_probe_read_user_str, bpf_probe_read_user,	    \
-		     dst, (src), a, ##__VA_ARGS__)			    \
-})
+#define BPF_CORE_READ_STR_INTO(dst, src, a, ...)			    \
+	({								    \
+		___core_read(bpf_core_read_str, dst, (src), a, ##__VA_ARGS__)\
+	})
 
 /*
  * BPF_CORE_READ() is used to simplify BPF CO-RE relocatable read, especially
@@ -501,61 +239,25 @@ extern void *bpf_rdonly_cast(const void *obj, __u32 btf_id) __ksym __weak;
  *	int x = BPF_CORE_READ(s, a.b.c, d.e, f, g);
  *
  * BPF_CORE_READ will decompose above statement into 4 bpf_core_read (BPF
- * CO-RE relocatable bpf_probe_read_kernel() wrapper) calls, logically
- * equivalent to:
+ * CO-RE relocatable bpf_probe_read() wrapper) calls, logically equivalent to:
  * 1. const void *__t = s->a.b.c;
  * 2. __t = __t->d.e;
  * 3. __t = __t->f;
  * 4. return __t->g;
  *
  * Equivalence is logical, because there is a heavy type casting/preservation
- * involved, as well as all the reads are happening through
- * bpf_probe_read_kernel() calls using __builtin_preserve_access_index() to
- * emit CO-RE relocations.
+ * involved, as well as all the reads are happening through bpf_probe_read()
+ * calls using __builtin_preserve_access_index() to emit CO-RE relocations.
  *
  * N.B. Only up to 9 "field accessors" are supported, which should be more
  * than enough for any practical purpose.
  */
-#define BPF_CORE_READ(src, a, ...) ({					    \
-	___type((src), a, ##__VA_ARGS__) __r;				    \
-	BPF_CORE_READ_INTO(&__r, (src), a, ##__VA_ARGS__);		    \
-	__r;								    \
-})
-
-/*
- * Variant of BPF_CORE_READ() for reading from user-space memory.
- *
- * NOTE: all the source types involved are still *kernel types* and need to
- * exist in kernel (or kernel module) BTF, otherwise CO-RE relocation will
- * fail. Custom user types are not relocatable with CO-RE.
- * The typical situation in which BPF_CORE_READ_USER() might be used is to
- * read kernel UAPI types from the user-space memory passed in as a syscall
- * input argument.
- */
-#define BPF_CORE_READ_USER(src, a, ...) ({				    \
-	___type((src), a, ##__VA_ARGS__) __r;				    \
-	BPF_CORE_READ_USER_INTO(&__r, (src), a, ##__VA_ARGS__);		    \
-	__r;								    \
-})
-
-/* Non-CO-RE variant of BPF_CORE_READ() */
-#define BPF_PROBE_READ(src, a, ...) ({					    \
-	___type((src), a, ##__VA_ARGS__) __r;				    \
-	BPF_PROBE_READ_INTO(&__r, (src), a, ##__VA_ARGS__);		    \
-	__r;								    \
-})
-
-/*
- * Non-CO-RE variant of BPF_CORE_READ_USER().
- *
- * As no CO-RE relocations are emitted, source types can be arbitrary and are
- * not restricted to kernel types only.
- */
-#define BPF_PROBE_READ_USER(src, a, ...) ({				    \
-	___type((src), a, ##__VA_ARGS__) __r;				    \
-	BPF_PROBE_READ_USER_INTO(&__r, (src), a, ##__VA_ARGS__);	    \
-	__r;								    \
-})
+#define BPF_CORE_READ(src, a, ...)					    \
+	({								    \
+		___type((src), a, ##__VA_ARGS__) __r;			    \
+		BPF_CORE_READ_INTO(&__r, (src), a, ##__VA_ARGS__);	    \
+		__r;							    \
+	})
 
 #endif
 

src/bpf_gen_internal.h

@@ -1,74 +0,0 @@
-/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
-/* Copyright (c) 2021 Facebook */
-#ifndef __BPF_GEN_INTERNAL_H
-#define __BPF_GEN_INTERNAL_H
-
-#include "bpf.h"
-
-struct ksym_relo_desc {
-	const char *name;
-	int kind;
-	int insn_idx;
-	bool is_weak;
-	bool is_typeless;
-	bool is_ld64;
-};
-
-struct ksym_desc {
-	const char *name;
-	int ref;
-	int kind;
-	union {
-		/* used for kfunc */
-		int off;
-		/* used for typeless ksym */
-		bool typeless;
-	};
-	int insn;
-	bool is_ld64;
-};
-
-struct bpf_gen {
-	struct gen_loader_opts *opts;
-	void *data_start;
-	void *data_cur;
-	void *insn_start;
-	void *insn_cur;
-	ssize_t cleanup_label;
-	__u32 nr_progs;
-	__u32 nr_maps;
-	int log_level;
-	int error;
-	struct ksym_relo_desc *relos;
-	int relo_cnt;
-	struct bpf_core_relo *core_relos;
-	int core_relo_cnt;
-	char attach_target[128];
-	int attach_kind;
-	struct ksym_desc *ksyms;
-	__u32 nr_ksyms;
-	int fd_array;
-	int nr_fd_array;
-};
-
-void bpf_gen__init(struct bpf_gen *gen, int log_level, int nr_progs, int nr_maps);
-int bpf_gen__finish(struct bpf_gen *gen, int nr_progs, int nr_maps);
-void bpf_gen__free(struct bpf_gen *gen);
-void bpf_gen__load_btf(struct bpf_gen *gen, const void *raw_data, __u32 raw_size);
-void bpf_gen__map_create(struct bpf_gen *gen,
-			 enum bpf_map_type map_type, const char *map_name,
-			 __u32 key_size, __u32 value_size, __u32 max_entries,
-			 struct bpf_map_create_opts *map_attr, int map_idx);
-void bpf_gen__prog_load(struct bpf_gen *gen,
-			enum bpf_prog_type prog_type, const char *prog_name,
-			const char *license, struct bpf_insn *insns, size_t insn_cnt,
-			struct bpf_prog_load_opts *load_attr, int prog_idx);
-void bpf_gen__map_update_elem(struct bpf_gen *gen, int map_idx, void *value, __u32 value_size);
-void bpf_gen__map_freeze(struct bpf_gen *gen, int map_idx);
-void bpf_gen__record_attach_target(struct bpf_gen *gen, const char *name, enum bpf_attach_type type);
-void bpf_gen__record_extern(struct bpf_gen *gen, const char *name, bool is_weak,
-			    bool is_typeless, bool is_ld64, int kind, int insn_idx);
-void bpf_gen__record_relo_core(struct bpf_gen *gen, const struct bpf_core_relo *core_relo);
-void bpf_gen__populate_outer_map(struct bpf_gen *gen, int outer_map_idx, int key, int inner_map_idx);
-
-#endif

src/bpf_helpers.h

@@ -13,160 +13,54 @@
 #define __uint(name, val) int (*name)[val]
 #define __type(name, val) typeof(val) *name
 #define __array(name, val) typeof(val) *name[]
-#define __ulong(name, val) enum { ___bpf_concat(__unique_value, __COUNTER__) = val } name
+
+/* Helper macro to print out debug messages */
+#define bpf_printk(fmt, ...)				\
+({							\
+	char ____fmt[] = fmt;				\
+	bpf_trace_printk(____fmt, sizeof(____fmt),	\
+			 ##__VA_ARGS__);		\
+})
 
 /*
  * Helper macro to place programs, maps, license in
  * different sections in elf_bpf file. Section names
- * are interpreted by libbpf depending on the context (BPF programs, BPF maps,
- * extern variables, etc).
- * To allow use of SEC() with externs (e.g., for extern .maps declarations),
- * make sure __attribute__((unused)) doesn't trigger compilation warning.
+ * are interpreted by elf_bpf loader
  */
-#if __GNUC__ && !__clang__
+#define SEC(NAME) __attribute__((section(NAME), used))
 
-/*
- * Pragma macros are broken on GCC
- * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=55578
- * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90400
- */
-#define SEC(name) __attribute__((section(name), used))
-
-#else
-
-#define SEC(name) \
-	_Pragma("GCC diagnostic push")					    \
-	_Pragma("GCC diagnostic ignored \"-Wignored-attributes\"")	    \
-	__attribute__((section(name), used))				    \
-	_Pragma("GCC diagnostic pop")					    \
-
-#endif
-
-/* Avoid 'linux/stddef.h' definition of '__always_inline'. */
-#undef __always_inline
-#define __always_inline inline __attribute__((always_inline))
-
-#ifndef __noinline
-#define __noinline __attribute__((noinline))
+#ifndef __always_inline
+#define __always_inline __attribute__((always_inline))
 #endif
 #ifndef __weak
 #define __weak __attribute__((weak))
 #endif
 
 /*
- * Use __hidden attribute to mark a non-static BPF subprogram effectively
- * static for BPF verifier's verification algorithm purposes, allowing more
- * extensive and permissive BPF verification process, taking into account
- * subprogram's caller context.
+ * Helper macro to manipulate data structures
  */
-#define __hidden __attribute__((visibility("hidden")))
-
-/* When utilizing vmlinux.h with BPF CO-RE, user BPF programs can't include
- * any system-level headers (such as stddef.h, linux/version.h, etc), and
- * commonly-used macros like NULL and KERNEL_VERSION aren't available through
- * vmlinux.h. This just adds unnecessary hurdles and forces users to re-define
- * them on their own. So as a convenience, provide such definitions here.
- */
-#ifndef NULL
-#define NULL ((void *)0)
+#ifndef offsetof
+#define offsetof(TYPE, MEMBER)	((unsigned long)&((TYPE *)0)->MEMBER)
 #endif
-
-#ifndef KERNEL_VERSION
-#define KERNEL_VERSION(a, b, c) (((a) << 16) + ((b) << 8) + ((c) > 255 ? 255 : (c)))
-#endif
-
-/*
- * Helper macros to manipulate data structures
- */
-
-/* offsetof() definition that uses __builtin_offset() might not preserve field
- * offset CO-RE relocation properly, so force-redefine offsetof() using
- * old-school approach which works with CO-RE correctly
- */
-#undef offsetof
-#define offsetof(type, member)	((unsigned long)&((type *)0)->member)
-
-/* redefined container_of() to ensure we use the above offsetof() macro */
-#undef container_of
+#ifndef container_of
 #define container_of(ptr, type, member)				\
 	({							\
 		void *__mptr = (void *)(ptr);			\
 		((type *)(__mptr - offsetof(type, member)));	\
 	})
-
-/*
- * Compiler (optimization) barrier.
- */
-#ifndef barrier
-#define barrier() asm volatile("" ::: "memory")
-#endif
-
-/* Variable-specific compiler (optimization) barrier. It's a no-op which makes
- * compiler believe that there is some black box modification of a given
- * variable and thus prevents compiler from making extra assumption about its
- * value and potential simplifications and optimizations on this variable.
- *
- * E.g., compiler might often delay or even omit 32-bit to 64-bit casting of
- * a variable, making some code patterns unverifiable. Putting barrier_var()
- * in place will ensure that cast is performed before the barrier_var()
- * invocation, because compiler has to pessimistically assume that embedded
- * asm section might perform some extra operations on that variable.
- *
- * This is a variable-specific variant of more global barrier().
- */
-#ifndef barrier_var
-#define barrier_var(var) asm volatile("" : "+r"(var))
 #endif
 
 /*
- * Helper macro to throw a compilation error if __bpf_unreachable() gets
- * built into the resulting code. This works given BPF back end does not
- * implement __builtin_trap(). This is useful to assert that certain paths
- * of the program code are never used and hence eliminated by the compiler.
- *
- * For example, consider a switch statement that covers known cases used by
- * the program. __bpf_unreachable() can then reside in the default case. If
- * the program gets extended such that a case is not covered in the switch
- * statement, then it will throw a build error due to the default case not
- * being compiled out.
+ * Helper structure used by eBPF C program
+ * to describe BPF map attributes to libbpf loader
  */
-#ifndef __bpf_unreachable
-# define __bpf_unreachable()	__builtin_trap()
-#endif
-
-/*
- * Helper function to perform a tail call with a constant/immediate map slot.
- */
-#if (defined(__clang__) && __clang_major__ >= 8) || (!defined(__clang__) && __GNUC__ > 12)
-#if defined(__bpf__)
-static __always_inline void
-bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)
-{
-	if (!__builtin_constant_p(slot))
-		__bpf_unreachable();
-
-	/*
-	 * Provide a hard guarantee that LLVM won't optimize setting r2 (map
-	 * pointer) and r3 (constant map index) from _different paths_ ending
-	 * up at the _same_ call insn as otherwise we won't be able to use the
-	 * jmpq/nopl retpoline-free patching by the x86-64 JIT in the kernel
-	 * given they mismatch. See also d2e4c1e6c294 ("bpf: Constant map key
-	 * tracking for prog array pokes") for details on verifier tracking.
-	 *
-	 * Note on clobber list: we need to stay in-line with BPF calling
-	 * convention, so even if we don't end up using r0, r4, r5, we need
-	 * to mark them as clobber so that LLVM doesn't end up using them
-	 * before / after the call.
-	 */
-	asm volatile("r1 = %[ctx]\n\t"
-		     "r2 = %[map]\n\t"
-		     "r3 = %[slot]\n\t"
-		     "call 12"
-		     :: [ctx]"r"(ctx), [map]"r"(map), [slot]"i"(slot)
-		     : "r0", "r1", "r2", "r3", "r4", "r5");
-}
-#endif
-#endif
+struct bpf_map_def {
+	unsigned int type;
+	unsigned int key_size;
+	unsigned int value_size;
+	unsigned int max_entries;
+	unsigned int map_flags;
+};
 
 enum libbpf_pin_type {
 	LIBBPF_PIN_NONE,
@@ -182,242 +76,5 @@ enum libbpf_tristate {
 
 #define __kconfig __attribute__((section(".kconfig")))
 #define __ksym __attribute__((section(".ksyms")))
-#define __kptr_untrusted __attribute__((btf_type_tag("kptr_untrusted")))
-#define __kptr __attribute__((btf_type_tag("kptr")))
-#define __percpu_kptr __attribute__((btf_type_tag("percpu_kptr")))
-
-#if defined (__clang__)
-#define bpf_ksym_exists(sym) ({						\
-	_Static_assert(!__builtin_constant_p(!!sym),			\
-		       #sym " should be marked as __weak");		\
-	!!sym;								\
-})
-#elif __GNUC__ > 8
-#define bpf_ksym_exists(sym) ({						\
-	_Static_assert(__builtin_has_attribute (*sym, __weak__),	\
-		       #sym " should be marked as __weak");		\
-	!!sym;								\
-})
-#else
-#define bpf_ksym_exists(sym) !!sym
-#endif
-
-#define __arg_ctx __attribute__((btf_decl_tag("arg:ctx")))
-#define __arg_nonnull __attribute((btf_decl_tag("arg:nonnull")))
-#define __arg_nullable __attribute((btf_decl_tag("arg:nullable")))
-#define __arg_trusted __attribute((btf_decl_tag("arg:trusted")))
-#define __arg_arena __attribute((btf_decl_tag("arg:arena")))
-
-#ifndef ___bpf_concat
-#define ___bpf_concat(a, b) a ## b
-#endif
-#ifndef ___bpf_apply
-#define ___bpf_apply(fn, n) ___bpf_concat(fn, n)
-#endif
-#ifndef ___bpf_nth
-#define ___bpf_nth(_, _1, _2, _3, _4, _5, _6, _7, _8, _9, _a, _b, _c, N, ...) N
-#endif
-#ifndef ___bpf_narg
-#define ___bpf_narg(...) \
-	___bpf_nth(_, ##__VA_ARGS__, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
-#endif
-
-#define ___bpf_fill0(arr, p, x) do {} while (0)
-#define ___bpf_fill1(arr, p, x) arr[p] = x
-#define ___bpf_fill2(arr, p, x, args...) arr[p] = x; ___bpf_fill1(arr, p + 1, args)
-#define ___bpf_fill3(arr, p, x, args...) arr[p] = x; ___bpf_fill2(arr, p + 1, args)
-#define ___bpf_fill4(arr, p, x, args...) arr[p] = x; ___bpf_fill3(arr, p + 1, args)
-#define ___bpf_fill5(arr, p, x, args...) arr[p] = x; ___bpf_fill4(arr, p + 1, args)
-#define ___bpf_fill6(arr, p, x, args...) arr[p] = x; ___bpf_fill5(arr, p + 1, args)
-#define ___bpf_fill7(arr, p, x, args...) arr[p] = x; ___bpf_fill6(arr, p + 1, args)
-#define ___bpf_fill8(arr, p, x, args...) arr[p] = x; ___bpf_fill7(arr, p + 1, args)
-#define ___bpf_fill9(arr, p, x, args...) arr[p] = x; ___bpf_fill8(arr, p + 1, args)
-#define ___bpf_fill10(arr, p, x, args...) arr[p] = x; ___bpf_fill9(arr, p + 1, args)
-#define ___bpf_fill11(arr, p, x, args...) arr[p] = x; ___bpf_fill10(arr, p + 1, args)
-#define ___bpf_fill12(arr, p, x, args...) arr[p] = x; ___bpf_fill11(arr, p + 1, args)
-#define ___bpf_fill(arr, args...) \
-	___bpf_apply(___bpf_fill, ___bpf_narg(args))(arr, 0, args)
-
-/*
- * BPF_SEQ_PRINTF to wrap bpf_seq_printf to-be-printed values
- * in a structure.
- */
-#define BPF_SEQ_PRINTF(seq, fmt, args...)			\
-({								\
-	static const char ___fmt[] = fmt;			\
-	unsigned long long ___param[___bpf_narg(args)];		\
-								\
-	_Pragma("GCC diagnostic push")				\
-	_Pragma("GCC diagnostic ignored \"-Wint-conversion\"")	\
-	___bpf_fill(___param, args);				\
-	_Pragma("GCC diagnostic pop")				\
-								\
-	bpf_seq_printf(seq, ___fmt, sizeof(___fmt),		\
-		       ___param, sizeof(___param));		\
-})
-
-/*
- * BPF_SNPRINTF wraps the bpf_snprintf helper with variadic arguments instead of
- * an array of u64.
- */
-#define BPF_SNPRINTF(out, out_size, fmt, args...)		\
-({								\
-	static const char ___fmt[] = fmt;			\
-	unsigned long long ___param[___bpf_narg(args)];		\
-								\
-	_Pragma("GCC diagnostic push")				\
-	_Pragma("GCC diagnostic ignored \"-Wint-conversion\"")	\
-	___bpf_fill(___param, args);				\
-	_Pragma("GCC diagnostic pop")				\
-								\
-	bpf_snprintf(out, out_size, ___fmt,			\
-		     ___param, sizeof(___param));		\
-})
-
-#ifdef BPF_NO_GLOBAL_DATA
-#define BPF_PRINTK_FMT_MOD
-#else
-#define BPF_PRINTK_FMT_MOD static const
-#endif
-
-#define __bpf_printk(fmt, ...)				\
-({							\
-	BPF_PRINTK_FMT_MOD char ____fmt[] = fmt;	\
-	bpf_trace_printk(____fmt, sizeof(____fmt),	\
-			 ##__VA_ARGS__);		\
-})
-
-/*
- * __bpf_vprintk wraps the bpf_trace_vprintk helper with variadic arguments
- * instead of an array of u64.
- */
-#define __bpf_vprintk(fmt, args...)				\
-({								\
-	static const char ___fmt[] = fmt;			\
-	unsigned long long ___param[___bpf_narg(args)];		\
-								\
-	_Pragma("GCC diagnostic push")				\
-	_Pragma("GCC diagnostic ignored \"-Wint-conversion\"")	\
-	___bpf_fill(___param, args);				\
-	_Pragma("GCC diagnostic pop")				\
-								\
-	bpf_trace_vprintk(___fmt, sizeof(___fmt),		\
-			  ___param, sizeof(___param));		\
-})
-
-/* Use __bpf_printk when bpf_printk call has 3 or fewer fmt args
- * Otherwise use __bpf_vprintk
- */
-#define ___bpf_pick_printk(...) \
-	___bpf_nth(_, ##__VA_ARGS__, __bpf_vprintk, __bpf_vprintk, __bpf_vprintk,	\
-		   __bpf_vprintk, __bpf_vprintk, __bpf_vprintk, __bpf_vprintk,		\
-		   __bpf_vprintk, __bpf_vprintk, __bpf_printk /*3*/, __bpf_printk /*2*/,\
-		   __bpf_printk /*1*/, __bpf_printk /*0*/)
-
-/* Helper macro to print out debug messages */
-#define bpf_printk(fmt, args...) ___bpf_pick_printk(args)(fmt, ##args)
-
-struct bpf_iter_num;
-
-extern int bpf_iter_num_new(struct bpf_iter_num *it, int start, int end) __weak __ksym;
-extern int *bpf_iter_num_next(struct bpf_iter_num *it) __weak __ksym;
-extern void bpf_iter_num_destroy(struct bpf_iter_num *it) __weak __ksym;
-
-#ifndef bpf_for_each
-/* bpf_for_each(iter_type, cur_elem, args...) provides generic construct for
- * using BPF open-coded iterators without having to write mundane explicit
- * low-level loop logic. Instead, it provides for()-like generic construct
- * that can be used pretty naturally. E.g., for some hypothetical cgroup
- * iterator, you'd write:
- *
- * struct cgroup *cg, *parent_cg = <...>;
- *
- * bpf_for_each(cgroup, cg, parent_cg, CG_ITER_CHILDREN) {
- *     bpf_printk("Child cgroup id = %d", cg->cgroup_id);
- *     if (cg->cgroup_id == 123)
- *         break;
- * }
- *
- * I.e., it looks almost like high-level for each loop in other languages,
- * supports continue/break, and is verifiable by BPF verifier.
- *
- * For iterating integers, the difference betwen bpf_for_each(num, i, N, M)
- * and bpf_for(i, N, M) is in that bpf_for() provides additional proof to
- * verifier that i is in [N, M) range, and in bpf_for_each() case i is `int
- * *`, not just `int`. So for integers bpf_for() is more convenient.
- *
- * Note: this macro relies on C99 feature of allowing to declare variables
- * inside for() loop, bound to for() loop lifetime. It also utilizes GCC
- * extension: __attribute__((cleanup(<func>))), supported by both GCC and
- * Clang.
- */
-#define bpf_for_each(type, cur, args...) for (							\
-	/* initialize and define destructor */							\
-	struct bpf_iter_##type ___it __attribute__((aligned(8), /* enforce, just in case */,	\
-						    cleanup(bpf_iter_##type##_destroy))),	\
-	/* ___p pointer is just to call bpf_iter_##type##_new() *once* to init ___it */		\
-			       *___p __attribute__((unused)) = (				\
-					bpf_iter_##type##_new(&___it, ##args),			\
-	/* this is a workaround for Clang bug: it currently doesn't emit BTF */			\
-	/* for bpf_iter_##type##_destroy() when used from cleanup() attribute */		\
-					(void)bpf_iter_##type##_destroy, (void *)0);		\
-	/* iteration and termination check */							\
-	(((cur) = bpf_iter_##type##_next(&___it)));						\
-)
-#endif /* bpf_for_each */
-
-#ifndef bpf_for
-/* bpf_for(i, start, end) implements a for()-like looping construct that sets
- * provided integer variable *i* to values starting from *start* through,
- * but not including, *end*. It also proves to BPF verifier that *i* belongs
- * to range [start, end), so this can be used for accessing arrays without
- * extra checks.
- *
- * Note: *start* and *end* are assumed to be expressions with no side effects
- * and whose values do not change throughout bpf_for() loop execution. They do
- * not have to be statically known or constant, though.
- *
- * Note: similarly to bpf_for_each(), it relies on C99 feature of declaring for()
- * loop bound variables and cleanup attribute, supported by GCC and Clang.
- */
-#define bpf_for(i, start, end) for (								\
-	/* initialize and define destructor */							\
-	struct bpf_iter_num ___it __attribute__((aligned(8), /* enforce, just in case */	\
-						 cleanup(bpf_iter_num_destroy))),		\
-	/* ___p pointer is necessary to call bpf_iter_num_new() *once* to init ___it */		\
-			    *___p __attribute__((unused)) = (					\
-				bpf_iter_num_new(&___it, (start), (end)),			\
-	/* this is a workaround for Clang bug: it currently doesn't emit BTF */			\
-	/* for bpf_iter_num_destroy() when used from cleanup() attribute */			\
-				(void)bpf_iter_num_destroy, (void *)0);				\
-	({											\
-		/* iteration step */								\
-		int *___t = bpf_iter_num_next(&___it);						\
-		/* termination and bounds check */						\
-		(___t && ((i) = *___t, (i) >= (start) && (i) < (end)));				\
-	});											\
-)
-#endif /* bpf_for */
-
-#ifndef bpf_repeat
-/* bpf_repeat(N) performs N iterations without exposing iteration number
- *
- * Note: similarly to bpf_for_each(), it relies on C99 feature of declaring for()
- * loop bound variables and cleanup attribute, supported by GCC and Clang.
- */
-#define bpf_repeat(N) for (									\
-	/* initialize and define destructor */							\
-	struct bpf_iter_num ___it __attribute__((aligned(8), /* enforce, just in case */	\
-						 cleanup(bpf_iter_num_destroy))),		\
-	/* ___p pointer is necessary to call bpf_iter_num_new() *once* to init ___it */		\
-			    *___p __attribute__((unused)) = (					\
-				bpf_iter_num_new(&___it, 0, (N)),				\
-	/* this is a workaround for Clang bug: it currently doesn't emit BTF */			\
-	/* for bpf_iter_num_destroy() when used from cleanup() attribute */			\
-				(void)bpf_iter_num_destroy, (void *)0);				\
-	bpf_iter_num_next(&___it);								\
-	/* nothing here  */									\
-)
-#endif /* bpf_repeat */
 
 #endif

src/bpf_prog_linfo.c

@@ -8,6 +8,9 @@
 #include "libbpf.h"
 #include "libbpf_internal.h"
 
+/* make sure libbpf doesn't use kernel-only integer typedefs */
+#pragma GCC poison u8 u16 u32 u64 s8 s16 s32 s64
+
 struct bpf_prog_linfo {
 	void *raw_linfo;
 	void *raw_jited_linfo;
@@ -106,7 +109,7 @@ struct bpf_prog_linfo *bpf_prog_linfo__new(const struct bpf_prog_info *info)
 	nr_linfo = info->nr_line_info;
 
 	if (!nr_linfo)
-		return errno = EINVAL, NULL;
+		return NULL;
 
 	/*
 	 * The min size that bpf_prog_linfo has to access for
@@ -114,11 +117,11 @@ struct bpf_prog_linfo *bpf_prog_linfo__new(const struct bpf_prog_info *info)
 	 */
 	if (info->line_info_rec_size <
 	    offsetof(struct bpf_line_info, file_name_off))
-		return errno = EINVAL, NULL;
+		return NULL;
 
 	prog_linfo = calloc(1, sizeof(*prog_linfo));
 	if (!prog_linfo)
-		return errno = ENOMEM, NULL;
+		return NULL;
 
 	/* Copy xlated line_info */
 	prog_linfo->nr_linfo = nr_linfo;
@@ -174,7 +177,7 @@ struct bpf_prog_linfo *bpf_prog_linfo__new(const struct bpf_prog_info *info)
 
 err_free:
 	bpf_prog_linfo__free(prog_linfo);
-	return errno = EINVAL, NULL;
+	return NULL;
 }
 
 const struct bpf_line_info *
@@ -186,11 +189,11 @@ bpf_prog_linfo__lfind_addr_func(const struct bpf_prog_linfo *prog_linfo,
 	const __u64 *jited_linfo;
 
 	if (func_idx >= prog_linfo->nr_jited_func)
-		return errno = ENOENT, NULL;
+		return NULL;
 
 	nr_linfo = prog_linfo->nr_jited_linfo_per_func[func_idx];
 	if (nr_skip >= nr_linfo)
-		return errno = ENOENT, NULL;
+		return NULL;
 
 	start = prog_linfo->jited_linfo_func_idx[func_idx] + nr_skip;
 	jited_rec_size = prog_linfo->jited_rec_size;
@@ -198,7 +201,7 @@ bpf_prog_linfo__lfind_addr_func(const struct bpf_prog_linfo *prog_linfo,
 		(start * jited_rec_size);
 	jited_linfo = raw_jited_linfo;
 	if (addr < *jited_linfo)
-		return errno = ENOENT, NULL;
+		return NULL;
 
 	nr_linfo -= nr_skip;
 	rec_size = prog_linfo->rec_size;
@@ -225,13 +228,13 @@ bpf_prog_linfo__lfind(const struct bpf_prog_linfo *prog_linfo,
 
 	nr_linfo = prog_linfo->nr_linfo;
 	if (nr_skip >= nr_linfo)
-		return errno = ENOENT, NULL;
+		return NULL;
 
 	rec_size = prog_linfo->rec_size;
 	raw_linfo = prog_linfo->raw_linfo + (nr_skip * rec_size);
 	linfo = raw_linfo;
 	if (insn_off < linfo->insn_off)
-		return errno = ENOENT, NULL;
+		return NULL;
 
 	nr_linfo -= nr_skip;
 	for (i = 0; i < nr_linfo; i++) {

src/btf.h

@@ -1,12 +1,10 @@
 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
 /* Copyright (c) 2018 Facebook */
-/*! \file */
 
 #ifndef __LIBBPF_BTF_H
 #define __LIBBPF_BTF_H
 
 #include <stdarg.h>
-#include <stdbool.h>
 #include <linux/btf.h>
 #include <linux/types.h>
 
@@ -18,7 +16,6 @@ extern "C" {
 
 #define BTF_ELF_SEC ".BTF"
 #define BTF_EXT_ELF_SEC ".BTF.ext"
-#define BTF_BASE_ELF_SEC ".BTF.base"
 #define MAPS_ELF_SEC ".maps"
 
 struct btf;
@@ -27,260 +24,110 @@ struct btf_type;
 
 struct bpf_object;
 
-enum btf_endianness {
-	BTF_LITTLE_ENDIAN = 0,
-	BTF_BIG_ENDIAN = 1,
+/*
+ * The .BTF.ext ELF section layout defined as
+ *   struct btf_ext_header
+ *   func_info subsection
+ *
+ * The func_info subsection layout:
+ *   record size for struct bpf_func_info in the func_info subsection
+ *   struct btf_sec_func_info for section #1
+ *   a list of bpf_func_info records for section #1
+ *     where struct bpf_func_info mimics one in include/uapi/linux/bpf.h
+ *     but may not be identical
+ *   struct btf_sec_func_info for section #2
+ *   a list of bpf_func_info records for section #2
+ *   ......
+ *
+ * Note that the bpf_func_info record size in .BTF.ext may not
+ * be the same as the one defined in include/uapi/linux/bpf.h.
+ * The loader should ensure that record_size meets minimum
+ * requirement and pass the record as is to the kernel. The
+ * kernel will handle the func_info properly based on its contents.
+ */
+struct btf_ext_header {
+	__u16	magic;
+	__u8	version;
+	__u8	flags;
+	__u32	hdr_len;
+
+	/* All offsets are in bytes relative to the end of this header */
+	__u32	func_info_off;
+	__u32	func_info_len;
+	__u32	line_info_off;
+	__u32	line_info_len;
+
+	/* optional part of .BTF.ext header */
+	__u32	field_reloc_off;
+	__u32	field_reloc_len;
 };
 
-/**
- * @brief **btf__free()** frees all data of a BTF object
- * @param btf BTF object to free
- */
 LIBBPF_API void btf__free(struct btf *btf);
-
-/**
- * @brief **btf__new()** creates a new instance of a BTF object from the raw
- * bytes of an ELF's BTF section
- * @param data raw bytes
- * @param size number of bytes passed in `data`
- * @return new BTF object instance which has to be eventually freed with
- * **btf__free()**
- *
- * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract
- * error code from such a pointer `libbpf_get_error()` should be used. If
- * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is
- * returned on error instead. In both cases thread-local `errno` variable is
- * always set to error code as well.
- */
 LIBBPF_API struct btf *btf__new(const void *data, __u32 size);
-
-/**
- * @brief **btf__new_split()** create a new instance of a BTF object from the
- * provided raw data bytes. It takes another BTF instance, **base_btf**, which
- * serves as a base BTF, which is extended by types in a newly created BTF
- * instance
- * @param data raw bytes
- * @param size length of raw bytes
- * @param base_btf the base BTF object
- * @return new BTF object instance which has to be eventually freed with
- * **btf__free()**
- *
- * If *base_btf* is NULL, `btf__new_split()` is equivalent to `btf__new()` and
- * creates non-split BTF.
- *
- * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract
- * error code from such a pointer `libbpf_get_error()` should be used. If
- * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is
- * returned on error instead. In both cases thread-local `errno` variable is
- * always set to error code as well.
- */
-LIBBPF_API struct btf *btf__new_split(const void *data, __u32 size, struct btf *base_btf);
-
-/**
- * @brief **btf__new_empty()** creates an empty BTF object.  Use
- * `btf__add_*()` to populate such BTF object.
- * @return new BTF object instance which has to be eventually freed with
- * **btf__free()**
- *
- * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract
- * error code from such a pointer `libbpf_get_error()` should be used. If
- * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is
- * returned on error instead. In both cases thread-local `errno` variable is
- * always set to error code as well.
- */
-LIBBPF_API struct btf *btf__new_empty(void);
-
-/**
- * @brief **btf__new_empty_split()** creates an unpopulated BTF object from an
- * ELF BTF section except with a base BTF on top of which split BTF should be
- * based
- * @return new BTF object instance which has to be eventually freed with
- * **btf__free()**
- *
- * If *base_btf* is NULL, `btf__new_empty_split()` is equivalent to
- * `btf__new_empty()` and creates non-split BTF.
- *
- * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract
- * error code from such a pointer `libbpf_get_error()` should be used. If
- * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is
- * returned on error instead. In both cases thread-local `errno` variable is
- * always set to error code as well.
- */
-LIBBPF_API struct btf *btf__new_empty_split(struct btf *base_btf);
-
-/**
- * @brief **btf__distill_base()** creates new versions of the split BTF
- * *src_btf* and its base BTF. The new base BTF will only contain the types
- * needed to improve robustness of the split BTF to small changes in base BTF.
- * When that split BTF is loaded against a (possibly changed) base, this
- * distilled base BTF will help update references to that (possibly changed)
- * base BTF.
- *
- * Both the new split and its associated new base BTF must be freed by
- * the caller.
- *
- * If successful, 0 is returned and **new_base_btf** and **new_split_btf**
- * will point at new base/split BTF. Both the new split and its associated
- * new base BTF must be freed by the caller.
- *
- * A negative value is returned on error and the thread-local `errno` variable
- * is set to the error code as well.
- */
-LIBBPF_API int btf__distill_base(const struct btf *src_btf, struct btf **new_base_btf,
-				 struct btf **new_split_btf);
-
 LIBBPF_API struct btf *btf__parse(const char *path, struct btf_ext **btf_ext);
-LIBBPF_API struct btf *btf__parse_split(const char *path, struct btf *base_btf);
 LIBBPF_API struct btf *btf__parse_elf(const char *path, struct btf_ext **btf_ext);
-LIBBPF_API struct btf *btf__parse_elf_split(const char *path, struct btf *base_btf);
 LIBBPF_API struct btf *btf__parse_raw(const char *path);
-LIBBPF_API struct btf *btf__parse_raw_split(const char *path, struct btf *base_btf);
-
-LIBBPF_API struct btf *btf__load_vmlinux_btf(void);
-LIBBPF_API struct btf *btf__load_module_btf(const char *module_name, struct btf *vmlinux_btf);
-
-LIBBPF_API struct btf *btf__load_from_kernel_by_id(__u32 id);
-LIBBPF_API struct btf *btf__load_from_kernel_by_id_split(__u32 id, struct btf *base_btf);
-
-LIBBPF_API int btf__load_into_kernel(struct btf *btf);
+LIBBPF_API int btf__finalize_data(struct bpf_object *obj, struct btf *btf);
+LIBBPF_API int btf__load(struct btf *btf);
 LIBBPF_API __s32 btf__find_by_name(const struct btf *btf,
 				   const char *type_name);
 LIBBPF_API __s32 btf__find_by_name_kind(const struct btf *btf,
 					const char *type_name, __u32 kind);
-LIBBPF_API __u32 btf__type_cnt(const struct btf *btf);
-LIBBPF_API const struct btf *btf__base_btf(const struct btf *btf);
+LIBBPF_API __u32 btf__get_nr_types(const struct btf *btf);
 LIBBPF_API const struct btf_type *btf__type_by_id(const struct btf *btf,
 						  __u32 id);
 LIBBPF_API size_t btf__pointer_size(const struct btf *btf);
 LIBBPF_API int btf__set_pointer_size(struct btf *btf, size_t ptr_sz);
-LIBBPF_API enum btf_endianness btf__endianness(const struct btf *btf);
-LIBBPF_API int btf__set_endianness(struct btf *btf, enum btf_endianness endian);
 LIBBPF_API __s64 btf__resolve_size(const struct btf *btf, __u32 type_id);
 LIBBPF_API int btf__resolve_type(const struct btf *btf, __u32 type_id);
 LIBBPF_API int btf__align_of(const struct btf *btf, __u32 id);
 LIBBPF_API int btf__fd(const struct btf *btf);
 LIBBPF_API void btf__set_fd(struct btf *btf, int fd);
-LIBBPF_API const void *btf__raw_data(const struct btf *btf, __u32 *size);
+LIBBPF_API const void *btf__get_raw_data(const struct btf *btf, __u32 *size);
 LIBBPF_API const char *btf__name_by_offset(const struct btf *btf, __u32 offset);
-LIBBPF_API const char *btf__str_by_offset(const struct btf *btf, __u32 offset);
+LIBBPF_API int btf__get_from_id(__u32 id, struct btf **btf);
+LIBBPF_API int btf__get_map_kv_tids(const struct btf *btf, const char *map_name,
+				    __u32 expected_key_size,
+				    __u32 expected_value_size,
+				    __u32 *key_type_id, __u32 *value_type_id);
 
-LIBBPF_API struct btf_ext *btf_ext__new(const __u8 *data, __u32 size);
+LIBBPF_API struct btf_ext *btf_ext__new(__u8 *data, __u32 size);
 LIBBPF_API void btf_ext__free(struct btf_ext *btf_ext);
-LIBBPF_API const void *btf_ext__raw_data(const struct btf_ext *btf_ext, __u32 *size);
+LIBBPF_API const void *btf_ext__get_raw_data(const struct btf_ext *btf_ext,
+					     __u32 *size);
+LIBBPF_API int btf_ext__reloc_func_info(const struct btf *btf,
+					const struct btf_ext *btf_ext,
+					const char *sec_name, __u32 insns_cnt,
+					void **func_info, __u32 *cnt);
+LIBBPF_API int btf_ext__reloc_line_info(const struct btf *btf,
+					const struct btf_ext *btf_ext,
+					const char *sec_name, __u32 insns_cnt,
+					void **line_info, __u32 *cnt);
+LIBBPF_API __u32 btf_ext__func_info_rec_size(const struct btf_ext *btf_ext);
+LIBBPF_API __u32 btf_ext__line_info_rec_size(const struct btf_ext *btf_ext);
 
-LIBBPF_API int btf__find_str(struct btf *btf, const char *s);
-LIBBPF_API int btf__add_str(struct btf *btf, const char *s);
-LIBBPF_API int btf__add_type(struct btf *btf, const struct btf *src_btf,
-			     const struct btf_type *src_type);
-/**
- * @brief **btf__add_btf()** appends all the BTF types from *src_btf* into *btf*
- * @param btf BTF object which all the BTF types and strings are added to
- * @param src_btf BTF object which all BTF types and referenced strings are copied from
- * @return BTF type ID of the first appended BTF type, or negative error code
- *
- * **btf__add_btf()** can be used to simply and efficiently append the entire
- * contents of one BTF object to another one. All the BTF type data is copied
- * over, all referenced type IDs are adjusted by adding a necessary ID offset.
- * Only strings referenced from BTF types are copied over and deduplicated, so
- * if there were some unused strings in *src_btf*, those won't be copied over,
- * which is consistent with the general string deduplication semantics of BTF
- * writing APIs.
- *
- * If any error is encountered during this process, the contents of *btf* is
- * left intact, which means that **btf__add_btf()** follows the transactional
- * semantics and the operation as a whole is all-or-nothing.
- *
- * *src_btf* has to be non-split BTF, as of now copying types from split BTF
- * is not supported and will result in -ENOTSUP error code returned.
- */
-LIBBPF_API int btf__add_btf(struct btf *btf, const struct btf *src_btf);
-
-LIBBPF_API int btf__add_int(struct btf *btf, const char *name, size_t byte_sz, int encoding);
-LIBBPF_API int btf__add_float(struct btf *btf, const char *name, size_t byte_sz);
-LIBBPF_API int btf__add_ptr(struct btf *btf, int ref_type_id);
-LIBBPF_API int btf__add_array(struct btf *btf,
-			      int index_type_id, int elem_type_id, __u32 nr_elems);
-/* struct/union construction APIs */
-LIBBPF_API int btf__add_struct(struct btf *btf, const char *name, __u32 sz);
-LIBBPF_API int btf__add_union(struct btf *btf, const char *name, __u32 sz);
-LIBBPF_API int btf__add_field(struct btf *btf, const char *name, int field_type_id,
-			      __u32 bit_offset, __u32 bit_size);
-
-/* enum construction APIs */
-LIBBPF_API int btf__add_enum(struct btf *btf, const char *name, __u32 bytes_sz);
-LIBBPF_API int btf__add_enum_value(struct btf *btf, const char *name, __s64 value);
-LIBBPF_API int btf__add_enum64(struct btf *btf, const char *name, __u32 bytes_sz, bool is_signed);
-LIBBPF_API int btf__add_enum64_value(struct btf *btf, const char *name, __u64 value);
-
-enum btf_fwd_kind {
-	BTF_FWD_STRUCT = 0,
-	BTF_FWD_UNION = 1,
-	BTF_FWD_ENUM = 2,
-};
-
-LIBBPF_API int btf__add_fwd(struct btf *btf, const char *name, enum btf_fwd_kind fwd_kind);
-LIBBPF_API int btf__add_typedef(struct btf *btf, const char *name, int ref_type_id);
-LIBBPF_API int btf__add_volatile(struct btf *btf, int ref_type_id);
-LIBBPF_API int btf__add_const(struct btf *btf, int ref_type_id);
-LIBBPF_API int btf__add_restrict(struct btf *btf, int ref_type_id);
-LIBBPF_API int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id);
-
-/* func and func_proto construction APIs */
-LIBBPF_API int btf__add_func(struct btf *btf, const char *name,
-			     enum btf_func_linkage linkage, int proto_type_id);
-LIBBPF_API int btf__add_func_proto(struct btf *btf, int ret_type_id);
-LIBBPF_API int btf__add_func_param(struct btf *btf, const char *name, int type_id);
-
-/* var & datasec construction APIs */
-LIBBPF_API int btf__add_var(struct btf *btf, const char *name, int linkage, int type_id);
-LIBBPF_API int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz);
-LIBBPF_API int btf__add_datasec_var_info(struct btf *btf, int var_type_id,
-					 __u32 offset, __u32 byte_sz);
-
-/* tag construction API */
-LIBBPF_API int btf__add_decl_tag(struct btf *btf, const char *value, int ref_type_id,
-			    int component_idx);
+LIBBPF_API struct btf *libbpf_find_kernel_btf(void);
 
 struct btf_dedup_opts {
-	size_t sz;
-	/* optional .BTF.ext info to dedup along the main BTF info */
-	struct btf_ext *btf_ext;
-	/* force hash collisions (used for testing) */
-	bool force_collisions;
-	size_t :0;
+	unsigned int dedup_table_size;
+	bool dont_resolve_fwds;
 };
-#define btf_dedup_opts__last_field force_collisions
 
-LIBBPF_API int btf__dedup(struct btf *btf, const struct btf_dedup_opts *opts);
-
-/**
- * @brief **btf__relocate()** will check the split BTF *btf* for references
- * to base BTF kinds, and verify those references are compatible with
- * *base_btf*; if they are, *btf* is adjusted such that is re-parented to
- * *base_btf* and type ids and strings are adjusted to accommodate this.
- *
- * If successful, 0 is returned and **btf** now has **base_btf** as its
- * base.
- *
- * A negative value is returned on error and the thread-local `errno` variable
- * is set to the error code as well.
- */
-LIBBPF_API int btf__relocate(struct btf *btf, const struct btf *base_btf);
+LIBBPF_API int btf__dedup(struct btf *btf, struct btf_ext *btf_ext,
+			  const struct btf_dedup_opts *opts);
 
 struct btf_dump;
 
 struct btf_dump_opts {
-	size_t sz;
+	void *ctx;
 };
-#define btf_dump_opts__last_field sz
 
 typedef void (*btf_dump_printf_fn_t)(void *ctx, const char *fmt, va_list args);
 
 LIBBPF_API struct btf_dump *btf_dump__new(const struct btf *btf,
-					  btf_dump_printf_fn_t printf_fn,
-					  void *ctx,
-					  const struct btf_dump_opts *opts);
-
+					  const struct btf_ext *btf_ext,
+					  const struct btf_dump_opts *opts,
+					  btf_dump_printf_fn_t printf_fn);
 LIBBPF_API void btf_dump__free(struct btf_dump *d);
 
 LIBBPF_API int btf_dump__dump_type(struct btf_dump *d, __u32 id);
@@ -302,7 +149,6 @@ struct btf_dump_emit_type_decl_opts {
 	int indent_level;
 	/* strip all the const/volatile/restrict mods */
 	bool strip_mods;
-	size_t :0;
 };
 #define btf_dump_emit_type_decl_opts__last_field strip_mods
 
@@ -310,49 +156,9 @@ LIBBPF_API int
 btf_dump__emit_type_decl(struct btf_dump *d, __u32 id,
 			 const struct btf_dump_emit_type_decl_opts *opts);
 
-
-struct btf_dump_type_data_opts {
-	/* size of this struct, for forward/backward compatibility */
-	size_t sz;
-	const char *indent_str;
-	int indent_level;
-	/* below match "show" flags for bpf_show_snprintf() */
-	bool compact;		/* no newlines/indentation */
-	bool skip_names;	/* skip member/type names */
-	bool emit_zeroes;	/* show 0-valued fields */
-	size_t :0;
-};
-#define btf_dump_type_data_opts__last_field emit_zeroes
-
-LIBBPF_API int
-btf_dump__dump_type_data(struct btf_dump *d, __u32 id,
-			 const void *data, size_t data_sz,
-			 const struct btf_dump_type_data_opts *opts);
-
 /*
- * A set of helpers for easier BTF types handling.
- *
- * The inline functions below rely on constants from the kernel headers which
- * may not be available for applications including this header file. To avoid
- * compilation errors, we define all the constants here that were added after
- * the initial introduction of the BTF_KIND* constants.
+ * A set of helpers for easier BTF types handling
  */
-#ifndef BTF_KIND_FUNC
-#define BTF_KIND_FUNC		12	/* Function	*/
-#define BTF_KIND_FUNC_PROTO	13	/* Function Proto	*/
-#endif
-#ifndef BTF_KIND_VAR
-#define BTF_KIND_VAR		14	/* Variable	*/
-#define BTF_KIND_DATASEC	15	/* Section	*/
-#endif
-#ifndef BTF_KIND_FLOAT
-#define BTF_KIND_FLOAT		16	/* Floating point	*/
-#endif
-/* The kernel header switched to enums, so the following were never #defined */
-#define BTF_KIND_DECL_TAG	17	/* Decl Tag */
-#define BTF_KIND_TYPE_TAG	18	/* Type Tag */
-#define BTF_KIND_ENUM64		19	/* Enum for up-to 64bit values */
-
 static inline __u16 btf_kind(const struct btf_type *t)
 {
 	return BTF_INFO_KIND(t->info);
@@ -410,11 +216,6 @@ static inline bool btf_is_enum(const struct btf_type *t)
 	return btf_kind(t) == BTF_KIND_ENUM;
 }
 
-static inline bool btf_is_enum64(const struct btf_type *t)
-{
-	return btf_kind(t) == BTF_KIND_ENUM64;
-}
-
 static inline bool btf_is_fwd(const struct btf_type *t)
 {
 	return btf_kind(t) == BTF_KIND_FWD;
@@ -446,8 +247,7 @@ static inline bool btf_is_mod(const struct btf_type *t)
 
 	return kind == BTF_KIND_VOLATILE ||
 	       kind == BTF_KIND_CONST ||
-	       kind == BTF_KIND_RESTRICT ||
-	       kind == BTF_KIND_TYPE_TAG;
+	       kind == BTF_KIND_RESTRICT;
 }
 
 static inline bool btf_is_func(const struct btf_type *t)
@@ -470,33 +270,6 @@ static inline bool btf_is_datasec(const struct btf_type *t)
 	return btf_kind(t) == BTF_KIND_DATASEC;
 }
 
-static inline bool btf_is_float(const struct btf_type *t)
-{
-	return btf_kind(t) == BTF_KIND_FLOAT;
-}
-
-static inline bool btf_is_decl_tag(const struct btf_type *t)
-{
-	return btf_kind(t) == BTF_KIND_DECL_TAG;
-}
-
-static inline bool btf_is_type_tag(const struct btf_type *t)
-{
-	return btf_kind(t) == BTF_KIND_TYPE_TAG;
-}
-
-static inline bool btf_is_any_enum(const struct btf_type *t)
-{
-	return btf_is_enum(t) || btf_is_enum64(t);
-}
-
-static inline bool btf_kind_core_compat(const struct btf_type *t1,
-					const struct btf_type *t2)
-{
-	return btf_kind(t1) == btf_kind(t2) ||
-	       (btf_is_any_enum(t1) && btf_is_any_enum(t2));
-}
-
 static inline __u8 btf_int_encoding(const struct btf_type *t)
 {
 	return BTF_INT_ENCODING(*(__u32 *)(t + 1));
@@ -522,39 +295,6 @@ static inline struct btf_enum *btf_enum(const struct btf_type *t)
 	return (struct btf_enum *)(t + 1);
 }
 
-struct btf_enum64;
-
-static inline struct btf_enum64 *btf_enum64(const struct btf_type *t)
-{
-	return (struct btf_enum64 *)(t + 1);
-}
-
-static inline __u64 btf_enum64_value(const struct btf_enum64 *e)
-{
-	/* struct btf_enum64 is introduced in Linux 6.0, which is very
-	 * bleeding-edge. Here we are avoiding relying on struct btf_enum64
-	 * definition coming from kernel UAPI headers to support wider range
-	 * of system-wide kernel headers.
-	 *
-	 * Given this header can be also included from C++ applications, that
-	 * further restricts C tricks we can use (like using compatible
-	 * anonymous struct). So just treat struct btf_enum64 as
-	 * a three-element array of u32 and access second (lo32) and third
-	 * (hi32) elements directly.
-	 *
-	 * For reference, here is a struct btf_enum64 definition:
-	 *
-	 * const struct btf_enum64 {
-	 *	__u32	name_off;
-	 *	__u32	val_lo32;
-	 *	__u32	val_hi32;
-	 * };
-	 */
-	const __u32 *e64 = (const __u32 *)e;
-
-	return ((__u64)e64[2] << 32) | e64[1];
-}
-
 static inline struct btf_member *btf_members(const struct btf_type *t)
 {
 	return (struct btf_member *)(t + 1);
@@ -598,12 +338,6 @@ btf_var_secinfos(const struct btf_type *t)
 	return (struct btf_var_secinfo *)(t + 1);
 }
 
-struct btf_decl_tag;
-static inline struct btf_decl_tag *btf_decl_tag(const struct btf_type *t)
-{
-	return (struct btf_decl_tag *)(t + 1);
-}
-
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

src/btf_iter.c

@@ -1,177 +0,0 @@
-// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
-/* Copyright (c) 2021 Facebook */
-/* Copyright (c) 2024, Oracle and/or its affiliates. */
-
-#ifdef __KERNEL__
-#include <linux/bpf.h>
-#include <linux/btf.h>
-
-#define btf_var_secinfos(t)	(struct btf_var_secinfo *)btf_type_var_secinfo(t)
-
-#else
-#include "btf.h"
-#include "libbpf_internal.h"
-#endif
-
-int btf_field_iter_init(struct btf_field_iter *it, struct btf_type *t,
-			enum btf_field_iter_kind iter_kind)
-{
-	it->p = NULL;
-	it->m_idx = -1;
-	it->off_idx = 0;
-	it->vlen = 0;
-
-	switch (iter_kind) {
-	case BTF_FIELD_ITER_IDS:
-		switch (btf_kind(t)) {
-		case BTF_KIND_UNKN:
-		case BTF_KIND_INT:
-		case BTF_KIND_FLOAT:
-		case BTF_KIND_ENUM:
-		case BTF_KIND_ENUM64:
-			it->desc = (struct btf_field_desc) {};
-			break;
-		case BTF_KIND_FWD:
-		case BTF_KIND_CONST:
-		case BTF_KIND_VOLATILE:
-		case BTF_KIND_RESTRICT:
-		case BTF_KIND_PTR:
-		case BTF_KIND_TYPEDEF:
-		case BTF_KIND_FUNC:
-		case BTF_KIND_VAR:
-		case BTF_KIND_DECL_TAG:
-		case BTF_KIND_TYPE_TAG:
-			it->desc = (struct btf_field_desc) { 1, {offsetof(struct btf_type, type)} };
-			break;
-		case BTF_KIND_ARRAY:
-			it->desc = (struct btf_field_desc) {
-				2, {sizeof(struct btf_type) + offsetof(struct btf_array, type),
-				sizeof(struct btf_type) + offsetof(struct btf_array, index_type)}
-			};
-			break;
-		case BTF_KIND_STRUCT:
-		case BTF_KIND_UNION:
-			it->desc = (struct btf_field_desc) {
-				0, {},
-				sizeof(struct btf_member),
-				1, {offsetof(struct btf_member, type)}
-			};
-			break;
-		case BTF_KIND_FUNC_PROTO:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, type)},
-				sizeof(struct btf_param),
-				1, {offsetof(struct btf_param, type)}
-			};
-			break;
-		case BTF_KIND_DATASEC:
-			it->desc = (struct btf_field_desc) {
-				0, {},
-				sizeof(struct btf_var_secinfo),
-				1, {offsetof(struct btf_var_secinfo, type)}
-			};
-			break;
-		default:
-			return -EINVAL;
-		}
-		break;
-	case BTF_FIELD_ITER_STRS:
-		switch (btf_kind(t)) {
-		case BTF_KIND_UNKN:
-			it->desc = (struct btf_field_desc) {};
-			break;
-		case BTF_KIND_INT:
-		case BTF_KIND_FLOAT:
-		case BTF_KIND_FWD:
-		case BTF_KIND_ARRAY:
-		case BTF_KIND_CONST:
-		case BTF_KIND_VOLATILE:
-		case BTF_KIND_RESTRICT:
-		case BTF_KIND_PTR:
-		case BTF_KIND_TYPEDEF:
-		case BTF_KIND_FUNC:
-		case BTF_KIND_VAR:
-		case BTF_KIND_DECL_TAG:
-		case BTF_KIND_TYPE_TAG:
-		case BTF_KIND_DATASEC:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, name_off)}
-			};
-			break;
-		case BTF_KIND_ENUM:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, name_off)},
-				sizeof(struct btf_enum),
-				1, {offsetof(struct btf_enum, name_off)}
-			};
-			break;
-		case BTF_KIND_ENUM64:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, name_off)},
-				sizeof(struct btf_enum64),
-				1, {offsetof(struct btf_enum64, name_off)}
-			};
-			break;
-		case BTF_KIND_STRUCT:
-		case BTF_KIND_UNION:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, name_off)},
-				sizeof(struct btf_member),
-				1, {offsetof(struct btf_member, name_off)}
-			};
-			break;
-		case BTF_KIND_FUNC_PROTO:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, name_off)},
-				sizeof(struct btf_param),
-				1, {offsetof(struct btf_param, name_off)}
-			};
-			break;
-		default:
-			return -EINVAL;
-		}
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	if (it->desc.m_sz)
-		it->vlen = btf_vlen(t);
-
-	it->p = t;
-	return 0;
-}
-
-__u32 *btf_field_iter_next(struct btf_field_iter *it)
-{
-	if (!it->p)
-		return NULL;
-
-	if (it->m_idx < 0) {
-		if (it->off_idx < it->desc.t_off_cnt)
-			return it->p + it->desc.t_offs[it->off_idx++];
-		/* move to per-member iteration */
-		it->m_idx = 0;
-		it->p += sizeof(struct btf_type);
-		it->off_idx = 0;
-	}
-
-	/* if type doesn't have members, stop */
-	if (it->desc.m_sz == 0) {
-		it->p = NULL;
-		return NULL;
-	}
-
-	if (it->off_idx >= it->desc.m_off_cnt) {
-		/* exhausted this member's fields, go to the next member */
-		it->m_idx++;
-		it->p += it->desc.m_sz;
-		it->off_idx = 0;
-	}
-
-	if (it->m_idx < it->vlen)
-		return it->p + it->desc.m_offs[it->off_idx++];
-
-	it->p = NULL;
-	return NULL;
-}

src/btf_relocate.c

@@ -1,519 +0,0 @@
-// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
-/* Copyright (c) 2024, Oracle and/or its affiliates. */
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#ifdef __KERNEL__
-#include <linux/bpf.h>
-#include <linux/bsearch.h>
-#include <linux/btf.h>
-#include <linux/sort.h>
-#include <linux/string.h>
-#include <linux/bpf_verifier.h>
-
-#define btf_type_by_id				(struct btf_type *)btf_type_by_id
-#define btf__type_cnt				btf_nr_types
-#define btf__base_btf				btf_base_btf
-#define btf__name_by_offset			btf_name_by_offset
-#define btf__str_by_offset			btf_str_by_offset
-#define btf_kflag				btf_type_kflag
-
-#define calloc(nmemb, sz)			kvcalloc(nmemb, sz, GFP_KERNEL | __GFP_NOWARN)
-#define free(ptr)				kvfree(ptr)
-#define qsort(base, num, sz, cmp)		sort(base, num, sz, cmp, NULL)
-
-#else
-
-#include "btf.h"
-#include "bpf.h"
-#include "libbpf.h"
-#include "libbpf_internal.h"
-
-#endif /* __KERNEL__ */
-
-struct btf;
-
-struct btf_relocate {
-	struct btf *btf;
-	const struct btf *base_btf;
-	const struct btf *dist_base_btf;
-	unsigned int nr_base_types;
-	unsigned int nr_split_types;
-	unsigned int nr_dist_base_types;
-	int dist_str_len;
-	int base_str_len;
-	__u32 *id_map;
-	__u32 *str_map;
-};
-
-/* Set temporarily in relocation id_map if distilled base struct/union is
- * embedded in a split BTF struct/union; in such a case, size information must
- * match between distilled base BTF and base BTF representation of type.
- */
-#define BTF_IS_EMBEDDED ((__u32)-1)
-
-/* <name, size, id> triple used in sorting/searching distilled base BTF. */
-struct btf_name_info {
-	const char *name;
-	/* set when search requires a size match */
-	bool needs_size: 1;
-	unsigned int size: 31;
-	__u32 id;
-};
-
-static int btf_relocate_rewrite_type_id(struct btf_relocate *r, __u32 i)
-{
-	struct btf_type *t = btf_type_by_id(r->btf, i);
-	struct btf_field_iter it;
-	__u32 *id;
-	int err;
-
-	err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_IDS);
-	if (err)
-		return err;
-
-	while ((id = btf_field_iter_next(&it)))
-		*id = r->id_map[*id];
-	return 0;
-}
-
-/* Simple string comparison used for sorting within BTF, since all distilled
- * types are named.  If strings match, and size is non-zero for both elements
- * fall back to using size for ordering.
- */
-static int cmp_btf_name_size(const void *n1, const void *n2)
-{
-	const struct btf_name_info *ni1 = n1;
-	const struct btf_name_info *ni2 = n2;
-	int name_diff = strcmp(ni1->name, ni2->name);
-
-	if (!name_diff && ni1->needs_size && ni2->needs_size)
-		return ni2->size - ni1->size;
-	return name_diff;
-}
-
-/* Binary search with a small twist; find leftmost element that matches
- * so that we can then iterate through all exact matches.  So for example
- * searching { "a", "bb", "bb", "c" }  we would always match on the
- * leftmost "bb".
- */
-static struct btf_name_info *search_btf_name_size(struct btf_name_info *key,
-						  struct btf_name_info *vals,
-						  int nelems)
-{
-	struct btf_name_info *ret = NULL;
-	int high = nelems - 1;
-	int low = 0;
-
-	while (low <= high) {
-		int mid = (low + high)/2;
-		struct btf_name_info *val = &vals[mid];
-		int diff = cmp_btf_name_size(key, val);
-
-		if (diff == 0)
-			ret = val;
-		/* even if found, keep searching for leftmost match */
-		if (diff <= 0)
-			high = mid - 1;
-		else
-			low = mid + 1;
-	}
-	return ret;
-}
-
-/* If a member of a split BTF struct/union refers to a base BTF
- * struct/union, mark that struct/union id temporarily in the id_map
- * with BTF_IS_EMBEDDED.  Members can be const/restrict/volatile/typedef
- * reference types, but if a pointer is encountered, the type is no longer
- * considered embedded.
- */
-static int btf_mark_embedded_composite_type_ids(struct btf_relocate *r, __u32 i)
-{
-	struct btf_type *t = btf_type_by_id(r->btf, i);
-	struct btf_field_iter it;
-	__u32 *id;
-	int err;
-
-	if (!btf_is_composite(t))
-		return 0;
-
-	err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_IDS);
-	if (err)
-		return err;
-
-	while ((id = btf_field_iter_next(&it))) {
-		__u32 next_id = *id;
-
-		while (next_id) {
-			t = btf_type_by_id(r->btf, next_id);
-			switch (btf_kind(t)) {
-			case BTF_KIND_CONST:
-			case BTF_KIND_RESTRICT:
-			case BTF_KIND_VOLATILE:
-			case BTF_KIND_TYPEDEF:
-			case BTF_KIND_TYPE_TAG:
-				next_id = t->type;
-				break;
-			case BTF_KIND_ARRAY: {
-				struct btf_array *a = btf_array(t);
-
-				next_id = a->type;
-				break;
-			}
-			case BTF_KIND_STRUCT:
-			case BTF_KIND_UNION:
-				if (next_id < r->nr_dist_base_types)
-					r->id_map[next_id] = BTF_IS_EMBEDDED;
-				next_id = 0;
-				break;
-			default:
-				next_id = 0;
-				break;
-			}
-		}
-	}
-
-	return 0;
-}
-
-/* Build a map from distilled base BTF ids to base BTF ids. To do so, iterate
- * through base BTF looking up distilled type (using binary search) equivalents.
- */
-static int btf_relocate_map_distilled_base(struct btf_relocate *r)
-{
-	struct btf_name_info *info, *info_end;
-	struct btf_type *base_t, *dist_t;
-	__u8 *base_name_cnt = NULL;
-	int err = 0;
-	__u32 id;
-
-	/* generate a sort index array of name/type ids sorted by name for
-	 * distilled base BTF to speed name-based lookups.
-	 */
-	info = calloc(r->nr_dist_base_types, sizeof(*info));
-	if (!info) {
-		err = -ENOMEM;
-		goto done;
-	}
-	info_end = info + r->nr_dist_base_types;
-	for (id = 0; id < r->nr_dist_base_types; id++) {
-		dist_t = btf_type_by_id(r->dist_base_btf, id);
-		info[id].name = btf__name_by_offset(r->dist_base_btf, dist_t->name_off);
-		info[id].id = id;
-		info[id].size = dist_t->size;
-		info[id].needs_size = true;
-	}
-	qsort(info, r->nr_dist_base_types, sizeof(*info), cmp_btf_name_size);
-
-	/* Mark distilled base struct/union members of split BTF structs/unions
-	 * in id_map with BTF_IS_EMBEDDED; this signals that these types
-	 * need to match both name and size, otherwise embedding the base
-	 * struct/union in the split type is invalid.
-	 */
-	for (id = r->nr_dist_base_types; id < r->nr_split_types; id++) {
-		err = btf_mark_embedded_composite_type_ids(r, id);
-		if (err)
-			goto done;
-	}
-
-	/* Collect name counts for composite types in base BTF.  If multiple
-	 * instances of a struct/union of the same name exist, we need to use
-	 * size to determine which to map to since name alone is ambiguous.
-	 */
-	base_name_cnt = calloc(r->base_str_len, sizeof(*base_name_cnt));
-	if (!base_name_cnt) {
-		err = -ENOMEM;
-		goto done;
-	}
-	for (id = 1; id < r->nr_base_types; id++) {
-		base_t = btf_type_by_id(r->base_btf, id);
-		if (!btf_is_composite(base_t) || !base_t->name_off)
-			continue;
-		if (base_name_cnt[base_t->name_off] < 255)
-			base_name_cnt[base_t->name_off]++;
-	}
-
-	/* Now search base BTF for matching distilled base BTF types. */
-	for (id = 1; id < r->nr_base_types; id++) {
-		struct btf_name_info *dist_info, base_info = {};
-		int dist_kind, base_kind;
-
-		base_t = btf_type_by_id(r->base_btf, id);
-		/* distilled base consists of named types only. */
-		if (!base_t->name_off)
-			continue;
-		base_kind = btf_kind(base_t);
-		base_info.id = id;
-		base_info.name = btf__name_by_offset(r->base_btf, base_t->name_off);
-		switch (base_kind) {
-		case BTF_KIND_INT:
-		case BTF_KIND_FLOAT:
-		case BTF_KIND_ENUM:
-		case BTF_KIND_ENUM64:
-			/* These types should match both name and size */
-			base_info.needs_size = true;
-			base_info.size = base_t->size;
-			break;
-		case BTF_KIND_FWD:
-			/* No size considerations for fwds. */
-			break;
-		case BTF_KIND_STRUCT:
-		case BTF_KIND_UNION:
-			/* Size only needs to be used for struct/union if there
-			 * are multiple types in base BTF with the same name.
-			 * If there are multiple _distilled_ types with the same
-			 * name (a very unlikely scenario), that doesn't matter
-			 * unless corresponding _base_ types to match them are
-			 * missing.
-			 */
-			base_info.needs_size = base_name_cnt[base_t->name_off] > 1;
-			base_info.size = base_t->size;
-			break;
-		default:
-			continue;
-		}
-		/* iterate over all matching distilled base types */
-		for (dist_info = search_btf_name_size(&base_info, info, r->nr_dist_base_types);
-		     dist_info != NULL && dist_info < info_end &&
-		     cmp_btf_name_size(&base_info, dist_info) == 0;
-		     dist_info++) {
-			if (!dist_info->id || dist_info->id >= r->nr_dist_base_types) {
-				pr_warn("base BTF id [%d] maps to invalid distilled base BTF id [%d]\n",
-					id, dist_info->id);
-				err = -EINVAL;
-				goto done;
-			}
-			dist_t = btf_type_by_id(r->dist_base_btf, dist_info->id);
-			dist_kind = btf_kind(dist_t);
-
-			/* Validate that the found distilled type is compatible.
-			 * Do not error out on mismatch as another match may
-			 * occur for an identically-named type.
-			 */
-			switch (dist_kind) {
-			case BTF_KIND_FWD:
-				switch (base_kind) {
-				case BTF_KIND_FWD:
-					if (btf_kflag(dist_t) != btf_kflag(base_t))
-						continue;
-					break;
-				case BTF_KIND_STRUCT:
-					if (btf_kflag(base_t))
-						continue;
-					break;
-				case BTF_KIND_UNION:
-					if (!btf_kflag(base_t))
-						continue;
-					break;
-				default:
-					continue;
-				}
-				break;
-			case BTF_KIND_INT:
-				if (dist_kind != base_kind ||
-				    btf_int_encoding(base_t) != btf_int_encoding(dist_t))
-					continue;
-				break;
-			case BTF_KIND_FLOAT:
-				if (dist_kind != base_kind)
-					continue;
-				break;
-			case BTF_KIND_ENUM:
-				/* ENUM and ENUM64 are encoded as sized ENUM in
-				 * distilled base BTF.
-				 */
-				if (base_kind != dist_kind && base_kind != BTF_KIND_ENUM64)
-					continue;
-				break;
-			case BTF_KIND_STRUCT:
-			case BTF_KIND_UNION:
-				/* size verification is required for embedded
-				 * struct/unions.
-				 */
-				if (r->id_map[dist_info->id] == BTF_IS_EMBEDDED &&
-				    base_t->size != dist_t->size)
-					continue;
-				break;
-			default:
-				continue;
-			}
-			if (r->id_map[dist_info->id] &&
-			    r->id_map[dist_info->id] != BTF_IS_EMBEDDED) {
-				/* we already have a match; this tells us that
-				 * multiple base types of the same name
-				 * have the same size, since for cases where
-				 * multiple types have the same name we match
-				 * on name and size.  In this case, we have
-				 * no way of determining which to relocate
-				 * to in base BTF, so error out.
-				 */
-				pr_warn("distilled base BTF type '%s' [%u], size %u has multiple candidates of the same size (ids [%u, %u]) in base BTF\n",
-					base_info.name, dist_info->id,
-					base_t->size, id, r->id_map[dist_info->id]);
-				err = -EINVAL;
-				goto done;
-			}
-			/* map id and name */
-			r->id_map[dist_info->id] = id;
-			r->str_map[dist_t->name_off] = base_t->name_off;
-		}
-	}
-	/* ensure all distilled BTF ids now have a mapping... */
-	for (id = 1; id < r->nr_dist_base_types; id++) {
-		const char *name;
-
-		if (r->id_map[id] && r->id_map[id] != BTF_IS_EMBEDDED)
-			continue;
-		dist_t = btf_type_by_id(r->dist_base_btf, id);
-		name = btf__name_by_offset(r->dist_base_btf, dist_t->name_off);
-		pr_warn("distilled base BTF type '%s' [%d] is not mapped to base BTF id\n",
-			name, id);
-		err = -EINVAL;
-		break;
-	}
-done:
-	free(base_name_cnt);
-	free(info);
-	return err;
-}
-
-/* distilled base should only have named int/float/enum/fwd/struct/union types. */
-static int btf_relocate_validate_distilled_base(struct btf_relocate *r)
-{
-	unsigned int i;
-
-	for (i = 1; i < r->nr_dist_base_types; i++) {
-		struct btf_type *t = btf_type_by_id(r->dist_base_btf, i);
-		int kind = btf_kind(t);
-
-		switch (kind) {
-		case BTF_KIND_INT:
-		case BTF_KIND_FLOAT:
-		case BTF_KIND_ENUM:
-		case BTF_KIND_STRUCT:
-		case BTF_KIND_UNION:
-		case BTF_KIND_FWD:
-			if (t->name_off)
-				break;
-			pr_warn("type [%d], kind [%d] is invalid for distilled base BTF; it is anonymous\n",
-				i, kind);
-			return -EINVAL;
-		default:
-			pr_warn("type [%d] in distilled based BTF has unexpected kind [%d]\n",
-				i, kind);
-			return -EINVAL;
-		}
-	}
-	return 0;
-}
-
-static int btf_relocate_rewrite_strs(struct btf_relocate *r, __u32 i)
-{
-	struct btf_type *t = btf_type_by_id(r->btf, i);
-	struct btf_field_iter it;
-	__u32 *str_off;
-	int off, err;
-
-	err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_STRS);
-	if (err)
-		return err;
-
-	while ((str_off = btf_field_iter_next(&it))) {
-		if (!*str_off)
-			continue;
-		if (*str_off >= r->dist_str_len) {
-			*str_off += r->base_str_len - r->dist_str_len;
-		} else {
-			off = r->str_map[*str_off];
-			if (!off) {
-				pr_warn("string '%s' [offset %u] is not mapped to base BTF",
-					btf__str_by_offset(r->btf, off), *str_off);
-				return -ENOENT;
-			}
-			*str_off = off;
-		}
-	}
-	return 0;
-}
-
-/* If successful, output of relocation is updated BTF with base BTF pointing
- * at base_btf, and type ids, strings adjusted accordingly.
- */
-int btf_relocate(struct btf *btf, const struct btf *base_btf, __u32 **id_map)
-{
-	unsigned int nr_types = btf__type_cnt(btf);
-	const struct btf_header *dist_base_hdr;
-	const struct btf_header *base_hdr;
-	struct btf_relocate r = {};
-	int err = 0;
-	__u32 id, i;
-
-	r.dist_base_btf = btf__base_btf(btf);
-	if (!base_btf || r.dist_base_btf == base_btf)
-		return -EINVAL;
-
-	r.nr_dist_base_types = btf__type_cnt(r.dist_base_btf);
-	r.nr_base_types = btf__type_cnt(base_btf);
-	r.nr_split_types = nr_types - r.nr_dist_base_types;
-	r.btf = btf;
-	r.base_btf = base_btf;
-
-	r.id_map = calloc(nr_types, sizeof(*r.id_map));
-	r.str_map = calloc(btf_header(r.dist_base_btf)->str_len, sizeof(*r.str_map));
-	dist_base_hdr = btf_header(r.dist_base_btf);
-	base_hdr = btf_header(r.base_btf);
-	r.dist_str_len = dist_base_hdr->str_len;
-	r.base_str_len = base_hdr->str_len;
-	if (!r.id_map || !r.str_map) {
-		err = -ENOMEM;
-		goto err_out;
-	}
-
-	err = btf_relocate_validate_distilled_base(&r);
-	if (err)
-		goto err_out;
-
-	/* Split BTF ids need to be adjusted as base and distilled base
-	 * have different numbers of types, changing the start id of split
-	 * BTF.
-	 */
-	for (id = r.nr_dist_base_types; id < nr_types; id++)
-		r.id_map[id] = id + r.nr_base_types - r.nr_dist_base_types;
-
-	/* Build a map from distilled base ids to actual base BTF ids; it is used
-	 * to update split BTF id references.  Also build a str_map mapping from
-	 * distilled base BTF names to base BTF names.
-	 */
-	err = btf_relocate_map_distilled_base(&r);
-	if (err)
-		goto err_out;
-
-	/* Next, rewrite type ids in split BTF, replacing split ids with updated
-	 * ids based on number of types in base BTF, and base ids with
-	 * relocated ids from base_btf.
-	 */
-	for (i = 0, id = r.nr_dist_base_types; i < r.nr_split_types; i++, id++) {
-		err = btf_relocate_rewrite_type_id(&r, id);
-		if (err)
-			goto err_out;
-	}
-	/* String offsets now need to be updated using the str_map. */
-	for (i = 0; i < r.nr_split_types; i++) {
-		err = btf_relocate_rewrite_strs(&r, i + r.nr_dist_base_types);
-		if (err)
-			goto err_out;
-	}
-	/* Finally reset base BTF to be base_btf */
-	btf_set_base_btf(btf, base_btf);
-
-	if (id_map) {
-		*id_map = r.id_map;
-		r.id_map = NULL;
-	}
-err_out:
-	free(r.id_map);
-	free(r.str_map);
-	return err;
-}

src/elf.c

@@ -1,561 +0,0 @@
-// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-#include <libelf.h>
-#include <gelf.h>
-#include <fcntl.h>
-#include <linux/kernel.h>
-
-#include "libbpf_internal.h"
-#include "str_error.h"
-
-/* A SHT_GNU_versym section holds 16-bit words. This bit is set if
- * the symbol is hidden and can only be seen when referenced using an
- * explicit version number. This is a GNU extension.
- */
-#define VERSYM_HIDDEN	0x8000
-
-/* This is the mask for the rest of the data in a word read from a
- * SHT_GNU_versym section.
- */
-#define VERSYM_VERSION	0x7fff
-
-int elf_open(const char *binary_path, struct elf_fd *elf_fd)
-{
-	char errmsg[STRERR_BUFSIZE];
-	int fd, ret;
-	Elf *elf;
-
-	elf_fd->elf = NULL;
-	elf_fd->fd = -1;
-
-	if (elf_version(EV_CURRENT) == EV_NONE) {
-		pr_warn("elf: failed to init libelf for %s\n", binary_path);
-		return -LIBBPF_ERRNO__LIBELF;
-	}
-	fd = open(binary_path, O_RDONLY | O_CLOEXEC);
-	if (fd < 0) {
-		ret = -errno;
-		pr_warn("elf: failed to open %s: %s\n", binary_path,
-			libbpf_strerror_r(ret, errmsg, sizeof(errmsg)));
-		return ret;
-	}
-	elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
-	if (!elf) {
-		pr_warn("elf: could not read elf from %s: %s\n", binary_path, elf_errmsg(-1));
-		close(fd);
-		return -LIBBPF_ERRNO__FORMAT;
-	}
-	elf_fd->fd = fd;
-	elf_fd->elf = elf;
-	return 0;
-}
-
-void elf_close(struct elf_fd *elf_fd)
-{
-	if (!elf_fd)
-		return;
-	elf_end(elf_fd->elf);
-	close(elf_fd->fd);
-}
-
-/* Return next ELF section of sh_type after scn, or first of that type if scn is NULL. */
-static Elf_Scn *elf_find_next_scn_by_type(Elf *elf, int sh_type, Elf_Scn *scn)
-{
-	while ((scn = elf_nextscn(elf, scn)) != NULL) {
-		GElf_Shdr sh;
-
-		if (!gelf_getshdr(scn, &sh))
-			continue;
-		if (sh.sh_type == sh_type)
-			return scn;
-	}
-	return NULL;
-}
-
-struct elf_sym {
-	const char *name;
-	GElf_Sym sym;
-	GElf_Shdr sh;
-	int ver;
-	bool hidden;
-};
-
-struct elf_sym_iter {
-	Elf *elf;
-	Elf_Data *syms;
-	Elf_Data *versyms;
-	Elf_Data *verdefs;
-	size_t nr_syms;
-	size_t strtabidx;
-	size_t verdef_strtabidx;
-	size_t next_sym_idx;
-	struct elf_sym sym;
-	int st_type;
-};
-
-static int elf_sym_iter_new(struct elf_sym_iter *iter,
-			    Elf *elf, const char *binary_path,
-			    int sh_type, int st_type)
-{
-	Elf_Scn *scn = NULL;
-	GElf_Ehdr ehdr;
-	GElf_Shdr sh;
-
-	memset(iter, 0, sizeof(*iter));
-
-	if (!gelf_getehdr(elf, &ehdr)) {
-		pr_warn("elf: failed to get ehdr from %s: %s\n", binary_path, elf_errmsg(-1));
-		return -EINVAL;
-	}
-
-	scn = elf_find_next_scn_by_type(elf, sh_type, NULL);
-	if (!scn) {
-		pr_debug("elf: failed to find symbol table ELF sections in '%s'\n",
-			 binary_path);
-		return -ENOENT;
-	}
-
-	if (!gelf_getshdr(scn, &sh))
-		return -EINVAL;
-
-	iter->strtabidx = sh.sh_link;
-	iter->syms = elf_getdata(scn, 0);
-	if (!iter->syms) {
-		pr_warn("elf: failed to get symbols for symtab section in '%s': %s\n",
-			binary_path, elf_errmsg(-1));
-		return -EINVAL;
-	}
-	iter->nr_syms = iter->syms->d_size / sh.sh_entsize;
-	iter->elf = elf;
-	iter->st_type = st_type;
-
-	/* Version symbol table is meaningful to dynsym only */
-	if (sh_type != SHT_DYNSYM)
-		return 0;
-
-	scn = elf_find_next_scn_by_type(elf, SHT_GNU_versym, NULL);
-	if (!scn)
-		return 0;
-	iter->versyms = elf_getdata(scn, 0);
-
-	scn = elf_find_next_scn_by_type(elf, SHT_GNU_verdef, NULL);
-	if (!scn)
-		return 0;
-
-	iter->verdefs = elf_getdata(scn, 0);
-	if (!iter->verdefs || !gelf_getshdr(scn, &sh)) {
-		pr_warn("elf: failed to get verdef ELF section in '%s'\n", binary_path);
-		return -EINVAL;
-	}
-	iter->verdef_strtabidx = sh.sh_link;
-
-	return 0;
-}
-
-static struct elf_sym *elf_sym_iter_next(struct elf_sym_iter *iter)
-{
-	struct elf_sym *ret = &iter->sym;
-	GElf_Sym *sym = &ret->sym;
-	const char *name = NULL;
-	GElf_Versym versym;
-	Elf_Scn *sym_scn;
-	size_t idx;
-
-	for (idx = iter->next_sym_idx; idx < iter->nr_syms; idx++) {
-		if (!gelf_getsym(iter->syms, idx, sym))
-			continue;
-		if (GELF_ST_TYPE(sym->st_info) != iter->st_type)
-			continue;
-		name = elf_strptr(iter->elf, iter->strtabidx, sym->st_name);
-		if (!name)
-			continue;
-		sym_scn = elf_getscn(iter->elf, sym->st_shndx);
-		if (!sym_scn)
-			continue;
-		if (!gelf_getshdr(sym_scn, &ret->sh))
-			continue;
-
-		iter->next_sym_idx = idx + 1;
-		ret->name = name;
-		ret->ver = 0;
-		ret->hidden = false;
-
-		if (iter->versyms) {
-			if (!gelf_getversym(iter->versyms, idx, &versym))
-				continue;
-			ret->ver = versym & VERSYM_VERSION;
-			ret->hidden = versym & VERSYM_HIDDEN;
-		}
-		return ret;
-	}
-
-	return NULL;
-}
-
-static const char *elf_get_vername(struct elf_sym_iter *iter, int ver)
-{
-	GElf_Verdaux verdaux;
-	GElf_Verdef verdef;
-	int offset;
-
-	if (!iter->verdefs)
-		return NULL;
-
-	offset = 0;
-	while (gelf_getverdef(iter->verdefs, offset, &verdef)) {
-		if (verdef.vd_ndx != ver) {
-			if (!verdef.vd_next)
-				break;
-
-			offset += verdef.vd_next;
-			continue;
-		}
-
-		if (!gelf_getverdaux(iter->verdefs, offset + verdef.vd_aux, &verdaux))
-			break;
-
-		return elf_strptr(iter->elf, iter->verdef_strtabidx, verdaux.vda_name);
-
-	}
-	return NULL;
-}
-
-static bool symbol_match(struct elf_sym_iter *iter, int sh_type, struct elf_sym *sym,
-			 const char *name, size_t name_len, const char *lib_ver)
-{
-	const char *ver_name;
-
-	/* Symbols are in forms of func, func@LIB_VER or func@@LIB_VER
-	 * make sure the func part matches the user specified name
-	 */
-	if (strncmp(sym->name, name, name_len) != 0)
-		return false;
-
-	/* ...but we don't want a search for "foo" to match 'foo2" also, so any
-	 * additional characters in sname should be of the form "@@LIB".
-	 */
-	if (sym->name[name_len] != '\0' && sym->name[name_len] != '@')
-		return false;
-
-	/* If user does not specify symbol version, then we got a match */
-	if (!lib_ver)
-		return true;
-
-	/* If user specifies symbol version, for dynamic symbols,
-	 * get version name from ELF verdef section for comparison.
-	 */
-	if (sh_type == SHT_DYNSYM) {
-		ver_name = elf_get_vername(iter, sym->ver);
-		if (!ver_name)
-			return false;
-		return strcmp(ver_name, lib_ver) == 0;
-	}
-
-	/* For normal symbols, it is already in form of func@LIB_VER */
-	return strcmp(sym->name, name) == 0;
-}
-
-/* Transform symbol's virtual address (absolute for binaries and relative
- * for shared libs) into file offset, which is what kernel is expecting
- * for uprobe/uretprobe attachment.
- * See Documentation/trace/uprobetracer.rst for more details. This is done
- * by looking up symbol's containing section's header and using iter's virtual
- * address (sh_addr) and corresponding file offset (sh_offset) to transform
- * sym.st_value (virtual address) into desired final file offset.
- */
-static unsigned long elf_sym_offset(struct elf_sym *sym)
-{
-	return sym->sym.st_value - sym->sh.sh_addr + sym->sh.sh_offset;
-}
-
-/* Find offset of function name in the provided ELF object. "binary_path" is
- * the path to the ELF binary represented by "elf", and only used for error
- * reporting matters. "name" matches symbol name or name@@LIB for library
- * functions.
- */
-long elf_find_func_offset(Elf *elf, const char *binary_path, const char *name)
-{
-	int i, sh_types[2] = { SHT_DYNSYM, SHT_SYMTAB };
-	const char *at_symbol, *lib_ver;
-	bool is_shared_lib;
-	long ret = -ENOENT;
-	size_t name_len;
-	GElf_Ehdr ehdr;
-
-	if (!gelf_getehdr(elf, &ehdr)) {
-		pr_warn("elf: failed to get ehdr from %s: %s\n", binary_path, elf_errmsg(-1));
-		ret = -LIBBPF_ERRNO__FORMAT;
-		goto out;
-	}
-	/* for shared lib case, we do not need to calculate relative offset */
-	is_shared_lib = ehdr.e_type == ET_DYN;
-
-	/* Does name specify "@@LIB_VER" or "@LIB_VER" ? */
-	at_symbol = strchr(name, '@');
-	if (at_symbol) {
-		name_len = at_symbol - name;
-		/* skip second @ if it's @@LIB_VER case */
-		if (at_symbol[1] == '@')
-			at_symbol++;
-		lib_ver = at_symbol + 1;
-	} else {
-		name_len = strlen(name);
-		lib_ver = NULL;
-	}
-
-	/* Search SHT_DYNSYM, SHT_SYMTAB for symbol. This search order is used because if
-	 * a binary is stripped, it may only have SHT_DYNSYM, and a fully-statically
-	 * linked binary may not have SHT_DYMSYM, so absence of a section should not be
-	 * reported as a warning/error.
-	 */
-	for (i = 0; i < ARRAY_SIZE(sh_types); i++) {
-		struct elf_sym_iter iter;
-		struct elf_sym *sym;
-		int last_bind = -1;
-		int cur_bind;
-
-		ret = elf_sym_iter_new(&iter, elf, binary_path, sh_types[i], STT_FUNC);
-		if (ret == -ENOENT)
-			continue;
-		if (ret)
-			goto out;
-
-		while ((sym = elf_sym_iter_next(&iter))) {
-			if (!symbol_match(&iter, sh_types[i], sym, name, name_len, lib_ver))
-				continue;
-
-			cur_bind = GELF_ST_BIND(sym->sym.st_info);
-
-			if (ret > 0) {
-				/* handle multiple matches */
-				if (elf_sym_offset(sym) == ret) {
-					/* same offset, no problem */
-					continue;
-				} else if (last_bind != STB_WEAK && cur_bind != STB_WEAK) {
-					/* Only accept one non-weak bind. */
-					pr_warn("elf: ambiguous match for '%s', '%s' in '%s'\n",
-						sym->name, name, binary_path);
-					ret = -LIBBPF_ERRNO__FORMAT;
-					goto out;
-				} else if (cur_bind == STB_WEAK) {
-					/* already have a non-weak bind, and
-					 * this is a weak bind, so ignore.
-					 */
-					continue;
-				}
-			}
-
-			ret = elf_sym_offset(sym);
-			last_bind = cur_bind;
-		}
-		if (ret > 0)
-			break;
-	}
-
-	if (ret > 0) {
-		pr_debug("elf: symbol address match for '%s' in '%s': 0x%lx\n", name, binary_path,
-			 ret);
-	} else {
-		if (ret == 0) {
-			pr_warn("elf: '%s' is 0 in symtab for '%s': %s\n", name, binary_path,
-				is_shared_lib ? "should not be 0 in a shared library" :
-						"try using shared library path instead");
-			ret = -ENOENT;
-		} else {
-			pr_warn("elf: failed to find symbol '%s' in '%s'\n", name, binary_path);
-		}
-	}
-out:
-	return ret;
-}
-
-/* Find offset of function name in ELF object specified by path. "name" matches
- * symbol name or name@@LIB for library functions.
- */
-long elf_find_func_offset_from_file(const char *binary_path, const char *name)
-{
-	struct elf_fd elf_fd;
-	long ret = -ENOENT;
-
-	ret = elf_open(binary_path, &elf_fd);
-	if (ret)
-		return ret;
-	ret = elf_find_func_offset(elf_fd.elf, binary_path, name);
-	elf_close(&elf_fd);
-	return ret;
-}
-
-struct symbol {
-	const char *name;
-	int bind;
-	int idx;
-};
-
-static int symbol_cmp(const void *a, const void *b)
-{
-	const struct symbol *sym_a = a;
-	const struct symbol *sym_b = b;
-
-	return strcmp(sym_a->name, sym_b->name);
-}
-
-/*
- * Return offsets in @poffsets for symbols specified in @syms array argument.
- * On success returns 0 and offsets are returned in allocated array with @cnt
- * size, that needs to be released by the caller.
- */
-int elf_resolve_syms_offsets(const char *binary_path, int cnt,
-			     const char **syms, unsigned long **poffsets,
-			     int st_type)
-{
-	int sh_types[2] = { SHT_DYNSYM, SHT_SYMTAB };
-	int err = 0, i, cnt_done = 0;
-	unsigned long *offsets;
-	struct symbol *symbols;
-	struct elf_fd elf_fd;
-
-	err = elf_open(binary_path, &elf_fd);
-	if (err)
-		return err;
-
-	offsets = calloc(cnt, sizeof(*offsets));
-	symbols = calloc(cnt, sizeof(*symbols));
-
-	if (!offsets || !symbols) {
-		err = -ENOMEM;
-		goto out;
-	}
-
-	for (i = 0; i < cnt; i++) {
-		symbols[i].name = syms[i];
-		symbols[i].idx = i;
-	}
-
-	qsort(symbols, cnt, sizeof(*symbols), symbol_cmp);
-
-	for (i = 0; i < ARRAY_SIZE(sh_types); i++) {
-		struct elf_sym_iter iter;
-		struct elf_sym *sym;
-
-		err = elf_sym_iter_new(&iter, elf_fd.elf, binary_path, sh_types[i], st_type);
-		if (err == -ENOENT)
-			continue;
-		if (err)
-			goto out;
-
-		while ((sym = elf_sym_iter_next(&iter))) {
-			unsigned long sym_offset = elf_sym_offset(sym);
-			int bind = GELF_ST_BIND(sym->sym.st_info);
-			struct symbol *found, tmp = {
-				.name = sym->name,
-			};
-			unsigned long *offset;
-
-			found = bsearch(&tmp, symbols, cnt, sizeof(*symbols), symbol_cmp);
-			if (!found)
-				continue;
-
-			offset = &offsets[found->idx];
-			if (*offset > 0) {
-				/* same offset, no problem */
-				if (*offset == sym_offset)
-					continue;
-				/* handle multiple matches */
-				if (found->bind != STB_WEAK && bind != STB_WEAK) {
-					/* Only accept one non-weak bind. */
-					pr_warn("elf: ambiguous match found '%s@%lu' in '%s' previous offset %lu\n",
-						sym->name, sym_offset, binary_path, *offset);
-					err = -ESRCH;
-					goto out;
-				} else if (bind == STB_WEAK) {
-					/* already have a non-weak bind, and
-					 * this is a weak bind, so ignore.
-					 */
-					continue;
-				}
-			} else {
-				cnt_done++;
-			}
-			*offset = sym_offset;
-			found->bind = bind;
-		}
-	}
-
-	if (cnt != cnt_done) {
-		err = -ENOENT;
-		goto out;
-	}
-
-	*poffsets = offsets;
-
-out:
-	free(symbols);
-	if (err)
-		free(offsets);
-	elf_close(&elf_fd);
-	return err;
-}
-
-/*
- * Return offsets in @poffsets for symbols specified by @pattern argument.
- * On success returns 0 and offsets are returned in allocated @poffsets
- * array with the @pctn size, that needs to be released by the caller.
- */
-int elf_resolve_pattern_offsets(const char *binary_path, const char *pattern,
-				unsigned long **poffsets, size_t *pcnt)
-{
-	int sh_types[2] = { SHT_SYMTAB, SHT_DYNSYM };
-	unsigned long *offsets = NULL;
-	size_t cap = 0, cnt = 0;
-	struct elf_fd elf_fd;
-	int err = 0, i;
-
-	err = elf_open(binary_path, &elf_fd);
-	if (err)
-		return err;
-
-	for (i = 0; i < ARRAY_SIZE(sh_types); i++) {
-		struct elf_sym_iter iter;
-		struct elf_sym *sym;
-
-		err = elf_sym_iter_new(&iter, elf_fd.elf, binary_path, sh_types[i], STT_FUNC);
-		if (err == -ENOENT)
-			continue;
-		if (err)
-			goto out;
-
-		while ((sym = elf_sym_iter_next(&iter))) {
-			if (!glob_match(sym->name, pattern))
-				continue;
-
-			err = libbpf_ensure_mem((void **) &offsets, &cap, sizeof(*offsets),
-						cnt + 1);
-			if (err)
-				goto out;
-
-			offsets[cnt++] = elf_sym_offset(sym);
-		}
-
-		/* If we found anything in the first symbol section,
-		 * do not search others to avoid duplicates.
-		 */
-		if (cnt)
-			break;
-	}
-
-	if (cnt) {
-		*poffsets = offsets;
-		*pcnt = cnt;
-	} else {
-		err = -ENOENT;
-	}
-
-out:
-	if (err)
-		free(offsets);
-	elf_close(&elf_fd);
-	return err;
-}

src/features.c

@@ -1,613 +0,0 @@
-// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
-/* Copyright (c) 2023 Meta Platforms, Inc. and affiliates. */
-#include <linux/kernel.h>
-#include <linux/filter.h>
-#include "bpf.h"
-#include "libbpf.h"
-#include "libbpf_common.h"
-#include "libbpf_internal.h"
-#include "str_error.h"
-
-static inline __u64 ptr_to_u64(const void *ptr)
-{
-	return (__u64)(unsigned long)ptr;
-}
-
-int probe_fd(int fd)
-{
-	if (fd >= 0)
-		close(fd);
-	return fd >= 0;
-}
-
-static int probe_kern_prog_name(int token_fd)
-{
-	const size_t attr_sz = offsetofend(union bpf_attr, prog_token_fd);
-	struct bpf_insn insns[] = {
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	union bpf_attr attr;
-	int ret;
-
-	memset(&attr, 0, attr_sz);
-	attr.prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
-	attr.license = ptr_to_u64("GPL");
-	attr.insns = ptr_to_u64(insns);
-	attr.insn_cnt = (__u32)ARRAY_SIZE(insns);
-	attr.prog_token_fd = token_fd;
-	if (token_fd)
-		attr.prog_flags |= BPF_F_TOKEN_FD;
-	libbpf_strlcpy(attr.prog_name, "libbpf_nametest", sizeof(attr.prog_name));
-
-	/* make sure loading with name works */
-	ret = sys_bpf_prog_load(&attr, attr_sz, PROG_LOAD_ATTEMPTS);
-	return probe_fd(ret);
-}
-
-static int probe_kern_global_data(int token_fd)
-{
-	char *cp, errmsg[STRERR_BUFSIZE];
-	struct bpf_insn insns[] = {
-		BPF_LD_MAP_VALUE(BPF_REG_1, 0, 16),
-		BPF_ST_MEM(BPF_DW, BPF_REG_1, 0, 42),
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	LIBBPF_OPTS(bpf_map_create_opts, map_opts,
-		.token_fd = token_fd,
-		.map_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	LIBBPF_OPTS(bpf_prog_load_opts, prog_opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	int ret, map, insn_cnt = ARRAY_SIZE(insns);
-
-	map = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_global", sizeof(int), 32, 1, &map_opts);
-	if (map < 0) {
-		ret = -errno;
-		cp = libbpf_strerror_r(ret, errmsg, sizeof(errmsg));
-		pr_warn("Error in %s():%s(%d). Couldn't create simple array map.\n",
-			__func__, cp, -ret);
-		return ret;
-	}
-
-	insns[0].imm = map;
-
-	ret = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, NULL, "GPL", insns, insn_cnt, &prog_opts);
-	close(map);
-	return probe_fd(ret);
-}
-
-static int probe_kern_btf(int token_fd)
-{
-	static const char strs[] = "\0int";
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(1, BTF_INT_SIGNED, 0, 32, 4),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_func(int token_fd)
-{
-	static const char strs[] = "\0int\0x\0a";
-	/* void x(int a) {} */
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(1, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
-		/* FUNC_PROTO */                                /* [2] */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 1), 0),
-		BTF_PARAM_ENC(7, 1),
-		/* FUNC x */                                    /* [3] */
-		BTF_TYPE_ENC(5, BTF_INFO_ENC(BTF_KIND_FUNC, 0, 0), 2),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_func_global(int token_fd)
-{
-	static const char strs[] = "\0int\0x\0a";
-	/* static void x(int a) {} */
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(1, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
-		/* FUNC_PROTO */                                /* [2] */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 1), 0),
-		BTF_PARAM_ENC(7, 1),
-		/* FUNC x BTF_FUNC_GLOBAL */                    /* [3] */
-		BTF_TYPE_ENC(5, BTF_INFO_ENC(BTF_KIND_FUNC, 0, BTF_FUNC_GLOBAL), 2),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_datasec(int token_fd)
-{
-	static const char strs[] = "\0x\0.data";
-	/* static int a; */
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
-		/* VAR x */                                     /* [2] */
-		BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_VAR, 0, 0), 1),
-		BTF_VAR_STATIC,
-		/* DATASEC val */                               /* [3] */
-		BTF_TYPE_ENC(3, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
-		BTF_VAR_SECINFO_ENC(2, 0, 4),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_qmark_datasec(int token_fd)
-{
-	static const char strs[] = "\0x\0?.data";
-	/* static int a; */
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
-		/* VAR x */                                     /* [2] */
-		BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_VAR, 0, 0), 1),
-		BTF_VAR_STATIC,
-		/* DATASEC ?.data */                            /* [3] */
-		BTF_TYPE_ENC(3, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
-		BTF_VAR_SECINFO_ENC(2, 0, 4),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_float(int token_fd)
-{
-	static const char strs[] = "\0float";
-	__u32 types[] = {
-		/* float */
-		BTF_TYPE_FLOAT_ENC(1, 4),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_decl_tag(int token_fd)
-{
-	static const char strs[] = "\0tag";
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
-		/* VAR x */                                     /* [2] */
-		BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_VAR, 0, 0), 1),
-		BTF_VAR_STATIC,
-		/* attr */
-		BTF_TYPE_DECL_TAG_ENC(1, 2, -1),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_type_tag(int token_fd)
-{
-	static const char strs[] = "\0tag";
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
-		/* attr */
-		BTF_TYPE_TYPE_TAG_ENC(1, 1),				/* [2] */
-		/* ptr */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),	/* [3] */
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_array_mmap(int token_fd)
-{
-	LIBBPF_OPTS(bpf_map_create_opts, opts,
-		.map_flags = BPF_F_MMAPABLE | (token_fd ? BPF_F_TOKEN_FD : 0),
-		.token_fd = token_fd,
-	);
-	int fd;
-
-	fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_mmap", sizeof(int), sizeof(int), 1, &opts);
-	return probe_fd(fd);
-}
-
-static int probe_kern_exp_attach_type(int token_fd)
-{
-	LIBBPF_OPTS(bpf_prog_load_opts, opts,
-		.expected_attach_type = BPF_CGROUP_INET_SOCK_CREATE,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	struct bpf_insn insns[] = {
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	int fd, insn_cnt = ARRAY_SIZE(insns);
-
-	/* use any valid combination of program type and (optional)
-	 * non-zero expected attach type (i.e., not a BPF_CGROUP_INET_INGRESS)
-	 * to see if kernel supports expected_attach_type field for
-	 * BPF_PROG_LOAD command
-	 */
-	fd = bpf_prog_load(BPF_PROG_TYPE_CGROUP_SOCK, NULL, "GPL", insns, insn_cnt, &opts);
-	return probe_fd(fd);
-}
-
-static int probe_kern_probe_read_kernel(int token_fd)
-{
-	LIBBPF_OPTS(bpf_prog_load_opts, opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	struct bpf_insn insns[] = {
-		BPF_MOV64_REG(BPF_REG_1, BPF_REG_10),	/* r1 = r10 (fp) */
-		BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8),	/* r1 += -8 */
-		BPF_MOV64_IMM(BPF_REG_2, 8),		/* r2 = 8 */
-		BPF_MOV64_IMM(BPF_REG_3, 0),		/* r3 = 0 */
-		BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_probe_read_kernel),
-		BPF_EXIT_INSN(),
-	};
-	int fd, insn_cnt = ARRAY_SIZE(insns);
-
-	fd = bpf_prog_load(BPF_PROG_TYPE_TRACEPOINT, NULL, "GPL", insns, insn_cnt, &opts);
-	return probe_fd(fd);
-}
-
-static int probe_prog_bind_map(int token_fd)
-{
-	char *cp, errmsg[STRERR_BUFSIZE];
-	struct bpf_insn insns[] = {
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	LIBBPF_OPTS(bpf_map_create_opts, map_opts,
-		.token_fd = token_fd,
-		.map_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	LIBBPF_OPTS(bpf_prog_load_opts, prog_opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	int ret, map, prog, insn_cnt = ARRAY_SIZE(insns);
-
-	map = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_det_bind", sizeof(int), 32, 1, &map_opts);
-	if (map < 0) {
-		ret = -errno;
-		cp = libbpf_strerror_r(ret, errmsg, sizeof(errmsg));
-		pr_warn("Error in %s():%s(%d). Couldn't create simple array map.\n",
-			__func__, cp, -ret);
-		return ret;
-	}
-
-	prog = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, NULL, "GPL", insns, insn_cnt, &prog_opts);
-	if (prog < 0) {
-		close(map);
-		return 0;
-	}
-
-	ret = bpf_prog_bind_map(prog, map, NULL);
-
-	close(map);
-	close(prog);
-
-	return ret >= 0;
-}
-
-static int probe_module_btf(int token_fd)
-{
-	static const char strs[] = "\0int";
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(1, BTF_INT_SIGNED, 0, 32, 4),
-	};
-	struct bpf_btf_info info;
-	__u32 len = sizeof(info);
-	char name[16];
-	int fd, err;
-
-	fd = libbpf__load_raw_btf((char *)types, sizeof(types), strs, sizeof(strs), token_fd);
-	if (fd < 0)
-		return 0; /* BTF not supported at all */
-
-	memset(&info, 0, sizeof(info));
-	info.name = ptr_to_u64(name);
-	info.name_len = sizeof(name);
-
-	/* check that BPF_OBJ_GET_INFO_BY_FD supports specifying name pointer;
-	 * kernel's module BTF support coincides with support for
-	 * name/name_len fields in struct bpf_btf_info.
-	 */
-	err = bpf_btf_get_info_by_fd(fd, &info, &len);
-	close(fd);
-	return !err;
-}
-
-static int probe_perf_link(int token_fd)
-{
-	struct bpf_insn insns[] = {
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	LIBBPF_OPTS(bpf_prog_load_opts, opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	int prog_fd, link_fd, err;
-
-	prog_fd = bpf_prog_load(BPF_PROG_TYPE_TRACEPOINT, NULL, "GPL",
-				insns, ARRAY_SIZE(insns), &opts);
-	if (prog_fd < 0)
-		return -errno;
-
-	/* use invalid perf_event FD to get EBADF, if link is supported;
-	 * otherwise EINVAL should be returned
-	 */
-	link_fd = bpf_link_create(prog_fd, -1, BPF_PERF_EVENT, NULL);
-	err = -errno; /* close() can clobber errno */
-
-	if (link_fd >= 0)
-		close(link_fd);
-	close(prog_fd);
-
-	return link_fd < 0 && err == -EBADF;
-}
-
-static int probe_uprobe_multi_link(int token_fd)
-{
-	LIBBPF_OPTS(bpf_prog_load_opts, load_opts,
-		.expected_attach_type = BPF_TRACE_UPROBE_MULTI,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	LIBBPF_OPTS(bpf_link_create_opts, link_opts);
-	struct bpf_insn insns[] = {
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	int prog_fd, link_fd, err;
-	unsigned long offset = 0;
-
-	prog_fd = bpf_prog_load(BPF_PROG_TYPE_KPROBE, NULL, "GPL",
-				insns, ARRAY_SIZE(insns), &load_opts);
-	if (prog_fd < 0)
-		return -errno;
-
-	/* Creating uprobe in '/' binary should fail with -EBADF. */
-	link_opts.uprobe_multi.path = "/";
-	link_opts.uprobe_multi.offsets = &offset;
-	link_opts.uprobe_multi.cnt = 1;
-
-	link_fd = bpf_link_create(prog_fd, -1, BPF_TRACE_UPROBE_MULTI, &link_opts);
-	err = -errno; /* close() can clobber errno */
-
-	if (link_fd >= 0 || err != -EBADF) {
-		if (link_fd >= 0)
-			close(link_fd);
-		close(prog_fd);
-		return 0;
-	}
-
-	/* Initial multi-uprobe support in kernel didn't handle PID filtering
-	 * correctly (it was doing thread filtering, not process filtering).
-	 * So now we'll detect if PID filtering logic was fixed, and, if not,
-	 * we'll pretend multi-uprobes are not supported, if not.
-	 * Multi-uprobes are used in USDT attachment logic, and we need to be
-	 * conservative here, because multi-uprobe selection happens early at
-	 * load time, while the use of PID filtering is known late at
-	 * attachment time, at which point it's too late to undo multi-uprobe
-	 * selection.
-	 *
-	 * Creating uprobe with pid == -1 for (invalid) '/' binary will fail
-	 * early with -EINVAL on kernels with fixed PID filtering logic;
-	 * otherwise -ESRCH would be returned if passed correct binary path
-	 * (but we'll just get -BADF, of course).
-	 */
-	link_opts.uprobe_multi.pid = -1; /* invalid PID */
-	link_opts.uprobe_multi.path = "/"; /* invalid path */
-	link_opts.uprobe_multi.offsets = &offset;
-	link_opts.uprobe_multi.cnt = 1;
-
-	link_fd = bpf_link_create(prog_fd, -1, BPF_TRACE_UPROBE_MULTI, &link_opts);
-	err = -errno; /* close() can clobber errno */
-
-	if (link_fd >= 0)
-		close(link_fd);
-	close(prog_fd);
-
-	return link_fd < 0 && err == -EINVAL;
-}
-
-static int probe_kern_bpf_cookie(int token_fd)
-{
-	struct bpf_insn insns[] = {
-		BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_attach_cookie),
-		BPF_EXIT_INSN(),
-	};
-	LIBBPF_OPTS(bpf_prog_load_opts, opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	int ret, insn_cnt = ARRAY_SIZE(insns);
-
-	ret = bpf_prog_load(BPF_PROG_TYPE_TRACEPOINT, NULL, "GPL", insns, insn_cnt, &opts);
-	return probe_fd(ret);
-}
-
-static int probe_kern_btf_enum64(int token_fd)
-{
-	static const char strs[] = "\0enum64";
-	__u32 types[] = {
-		BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 0), 8),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_arg_ctx_tag(int token_fd)
-{
-	static const char strs[] = "\0a\0b\0arg:ctx\0";
-	const __u32 types[] = {
-		/* [1] INT */
-		BTF_TYPE_INT_ENC(1 /* "a" */, BTF_INT_SIGNED, 0, 32, 4),
-		/* [2] PTR -> VOID */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
-		/* [3] FUNC_PROTO `int(void *a)` */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 1), 1),
-		BTF_PARAM_ENC(1 /* "a" */, 2),
-		/* [4] FUNC 'a' -> FUNC_PROTO (main prog) */
-		BTF_TYPE_ENC(1 /* "a" */, BTF_INFO_ENC(BTF_KIND_FUNC, 0, BTF_FUNC_GLOBAL), 3),
-		/* [5] FUNC_PROTO `int(void *b __arg_ctx)` */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 1), 1),
-		BTF_PARAM_ENC(3 /* "b" */, 2),
-		/* [6] FUNC 'b' -> FUNC_PROTO (subprog) */
-		BTF_TYPE_ENC(3 /* "b" */, BTF_INFO_ENC(BTF_KIND_FUNC, 0, BTF_FUNC_GLOBAL), 5),
-		/* [7] DECL_TAG 'arg:ctx' -> func 'b' arg 'b' */
-		BTF_TYPE_DECL_TAG_ENC(5 /* "arg:ctx" */, 6, 0),
-	};
-	const struct bpf_insn insns[] = {
-		/* main prog */
-		BPF_CALL_REL(+1),
-		BPF_EXIT_INSN(),
-		/* global subprog */
-		BPF_EMIT_CALL(BPF_FUNC_get_func_ip), /* needs PTR_TO_CTX */
-		BPF_EXIT_INSN(),
-	};
-	const struct bpf_func_info_min func_infos[] = {
-		{ 0, 4 }, /* main prog -> FUNC 'a' */
-		{ 2, 6 }, /* subprog -> FUNC 'b' */
-	};
-	LIBBPF_OPTS(bpf_prog_load_opts, opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	int prog_fd, btf_fd, insn_cnt = ARRAY_SIZE(insns);
-
-	btf_fd = libbpf__load_raw_btf((char *)types, sizeof(types), strs, sizeof(strs), token_fd);
-	if (btf_fd < 0)
-		return 0;
-
-	opts.prog_btf_fd = btf_fd;
-	opts.func_info = &func_infos;
-	opts.func_info_cnt = ARRAY_SIZE(func_infos);
-	opts.func_info_rec_size = sizeof(func_infos[0]);
-
-	prog_fd = bpf_prog_load(BPF_PROG_TYPE_KPROBE, "det_arg_ctx",
-				"GPL", insns, insn_cnt, &opts);
-	close(btf_fd);
-
-	return probe_fd(prog_fd);
-}
-
-typedef int (*feature_probe_fn)(int /* token_fd */);
-
-static struct kern_feature_cache feature_cache;
-
-static struct kern_feature_desc {
-	const char *desc;
-	feature_probe_fn probe;
-} feature_probes[__FEAT_CNT] = {
-	[FEAT_PROG_NAME] = {
-		"BPF program name", probe_kern_prog_name,
-	},
-	[FEAT_GLOBAL_DATA] = {
-		"global variables", probe_kern_global_data,
-	},
-	[FEAT_BTF] = {
-		"minimal BTF", probe_kern_btf,
-	},
-	[FEAT_BTF_FUNC] = {
-		"BTF functions", probe_kern_btf_func,
-	},
-	[FEAT_BTF_GLOBAL_FUNC] = {
-		"BTF global function", probe_kern_btf_func_global,
-	},
-	[FEAT_BTF_DATASEC] = {
-		"BTF data section and variable", probe_kern_btf_datasec,
-	},
-	[FEAT_ARRAY_MMAP] = {
-		"ARRAY map mmap()", probe_kern_array_mmap,
-	},
-	[FEAT_EXP_ATTACH_TYPE] = {
-		"BPF_PROG_LOAD expected_attach_type attribute",
-		probe_kern_exp_attach_type,
-	},
-	[FEAT_PROBE_READ_KERN] = {
-		"bpf_probe_read_kernel() helper", probe_kern_probe_read_kernel,
-	},
-	[FEAT_PROG_BIND_MAP] = {
-		"BPF_PROG_BIND_MAP support", probe_prog_bind_map,
-	},
-	[FEAT_MODULE_BTF] = {
-		"module BTF support", probe_module_btf,
-	},
-	[FEAT_BTF_FLOAT] = {
-		"BTF_KIND_FLOAT support", probe_kern_btf_float,
-	},
-	[FEAT_PERF_LINK] = {
-		"BPF perf link support", probe_perf_link,
-	},
-	[FEAT_BTF_DECL_TAG] = {
-		"BTF_KIND_DECL_TAG support", probe_kern_btf_decl_tag,
-	},
-	[FEAT_BTF_TYPE_TAG] = {
-		"BTF_KIND_TYPE_TAG support", probe_kern_btf_type_tag,
-	},
-	[FEAT_MEMCG_ACCOUNT] = {
-		"memcg-based memory accounting", probe_memcg_account,
-	},
-	[FEAT_BPF_COOKIE] = {
-		"BPF cookie support", probe_kern_bpf_cookie,
-	},
-	[FEAT_BTF_ENUM64] = {
-		"BTF_KIND_ENUM64 support", probe_kern_btf_enum64,
-	},
-	[FEAT_SYSCALL_WRAPPER] = {
-		"Kernel using syscall wrapper", probe_kern_syscall_wrapper,
-	},
-	[FEAT_UPROBE_MULTI_LINK] = {
-		"BPF multi-uprobe link support", probe_uprobe_multi_link,
-	},
-	[FEAT_ARG_CTX_TAG] = {
-		"kernel-side __arg_ctx tag", probe_kern_arg_ctx_tag,
-	},
-	[FEAT_BTF_QMARK_DATASEC] = {
-		"BTF DATASEC names starting from '?'", probe_kern_btf_qmark_datasec,
-	},
-};
-
-bool feat_supported(struct kern_feature_cache *cache, enum kern_feature_id feat_id)
-{
-	struct kern_feature_desc *feat = &feature_probes[feat_id];
-	int ret;
-
-	/* assume global feature cache, unless custom one is provided */
-	if (!cache)
-		cache = &feature_cache;
-
-	if (READ_ONCE(cache->res[feat_id]) == FEAT_UNKNOWN) {
-		ret = feat->probe(cache->token_fd);
-		if (ret > 0) {
-			WRITE_ONCE(cache->res[feat_id], FEAT_SUPPORTED);
-		} else if (ret == 0) {
-			WRITE_ONCE(cache->res[feat_id], FEAT_MISSING);
-		} else {
-			pr_warn("Detection of kernel %s support failed: %d\n", feat->desc, ret);
-			WRITE_ONCE(cache->res[feat_id], FEAT_MISSING);
-		}
-	}
-
-	return READ_ONCE(cache->res[feat_id]) == FEAT_SUPPORTED;
-}

src/hashmap.c

@@ -15,9 +15,6 @@
 /* make sure libbpf doesn't use kernel-only integer typedefs */
 #pragma GCC poison u8 u16 u32 u64 s8 s16 s32 s64
 
-/* prevent accidental re-addition of reallocarray() */
-#pragma GCC poison reallocarray
-
 /* start with 4 buckets */
 #define HASHMAP_MIN_CAP_BITS 2
 
@@ -75,7 +72,7 @@ void hashmap__clear(struct hashmap *map)
 
 void hashmap__free(struct hashmap *map)
 {
-	if (IS_ERR_OR_NULL(map))
+	if (!map)
 		return;
 
 	hashmap__clear(map);
@@ -128,7 +125,7 @@ static int hashmap_grow(struct hashmap *map)
 }
 
 static bool hashmap_find_entry(const struct hashmap *map,
-			       const long key, size_t hash,
+			       const void *key, size_t hash,
 			       struct hashmap_entry ***pprev,
 			       struct hashmap_entry **entry)
 {
@@ -151,18 +148,18 @@ static bool hashmap_find_entry(const struct hashmap *map,
 	return false;
 }
 
-int hashmap_insert(struct hashmap *map, long key, long value,
-		   enum hashmap_insert_strategy strategy,
-		   long *old_key, long *old_value)
+int hashmap__insert(struct hashmap *map, const void *key, void *value,
+		    enum hashmap_insert_strategy strategy,
+		    const void **old_key, void **old_value)
 {
 	struct hashmap_entry *entry;
 	size_t h;
 	int err;
 
 	if (old_key)
-		*old_key = 0;
+		*old_key = NULL;
 	if (old_value)
-		*old_value = 0;
+		*old_value = NULL;
 
 	h = hash_bits(map->hash_fn(key, map->ctx), map->cap_bits);
 	if (strategy != HASHMAP_APPEND &&
@@ -203,7 +200,7 @@ int hashmap_insert(struct hashmap *map, long key, long value,
 	return 0;
 }
 
-bool hashmap_find(const struct hashmap *map, long key, long *value)
+bool hashmap__find(const struct hashmap *map, const void *key, void **value)
 {
 	struct hashmap_entry *entry;
 	size_t h;
@@ -217,8 +214,8 @@ bool hashmap_find(const struct hashmap *map, long key, long *value)
 	return true;
 }
 
-bool hashmap_delete(struct hashmap *map, long key,
-		    long *old_key, long *old_value)
+bool hashmap__delete(struct hashmap *map, const void *key,
+		     const void **old_key, void **old_value)
 {
 	struct hashmap_entry **pprev, *entry;
 	size_t h;
@@ -238,3 +235,4 @@ bool hashmap_delete(struct hashmap *map, long key,
 
 	return true;
 }
+

src/hashmap.h

@@ -15,9 +15,6 @@
 static inline size_t hash_bits(size_t h, int bits)
 {
 	/* shuffle bits and return requested number of upper bits */
-	if (bits == 0)
-		return 0;
-
 #if (__SIZEOF_SIZE_T__ == __SIZEOF_LONG_LONG__)
 	/* LP64 case */
 	return (h * 11400714819323198485llu) >> (__SIZEOF_LONG_LONG__ * 8 - bits);
@@ -28,44 +25,12 @@ static inline size_t hash_bits(size_t h, int bits)
 #endif
 }
 
-/* generic C-string hashing function */
-static inline size_t str_hash(const char *s)
-{
-	size_t h = 0;
+typedef size_t (*hashmap_hash_fn)(const void *key, void *ctx);
+typedef bool (*hashmap_equal_fn)(const void *key1, const void *key2, void *ctx);
 
-	while (*s) {
-		h = h * 31 + *s;
-		s++;
-	}
-	return h;
-}
-
-typedef size_t (*hashmap_hash_fn)(long key, void *ctx);
-typedef bool (*hashmap_equal_fn)(long key1, long key2, void *ctx);
-
-/*
- * Hashmap interface is polymorphic, keys and values could be either
- * long-sized integers or pointers, this is achieved as follows:
- * - interface functions that operate on keys and values are hidden
- *   behind auxiliary macros, e.g. hashmap_insert <-> hashmap__insert;
- * - these auxiliary macros cast the key and value parameters as
- *   long or long *, so the user does not have to specify the casts explicitly;
- * - for pointer parameters (e.g. old_key) the size of the pointed
- *   type is verified by hashmap_cast_ptr using _Static_assert;
- * - when iterating using hashmap__for_each_* forms
- *   hasmap_entry->key should be used for integer keys and
- *   hasmap_entry->pkey should be used for pointer keys,
- *   same goes for values.
- */
 struct hashmap_entry {
-	union {
-		long key;
-		const void *pkey;
-	};
-	union {
-		long value;
-		void *pvalue;
-	};
+	const void *key;
+	void *value;
 	struct hashmap_entry *next;
 };
 
@@ -80,6 +45,16 @@ struct hashmap {
 	size_t sz;
 };
 
+#define HASHMAP_INIT(hash_fn, equal_fn, ctx) {	\
+	.hash_fn = (hash_fn),			\
+	.equal_fn = (equal_fn),			\
+	.ctx = (ctx),				\
+	.buckets = NULL,			\
+	.cap = 0,				\
+	.cap_bits = 0,				\
+	.sz = 0,				\
+}
+
 void hashmap__init(struct hashmap *map, hashmap_hash_fn hash_fn,
 		   hashmap_equal_fn equal_fn, void *ctx);
 struct hashmap *hashmap__new(hashmap_hash_fn hash_fn,
@@ -112,13 +87,6 @@ enum hashmap_insert_strategy {
 	HASHMAP_APPEND,
 };
 
-#define hashmap_cast_ptr(p) ({								\
-	_Static_assert((__builtin_constant_p((p)) ? (p) == NULL : 0) ||			\
-				sizeof(*(p)) == sizeof(long),				\
-		       #p " pointee should be a long-sized integer or a pointer");	\
-	(long *)(p);									\
-})
-
 /*
  * hashmap__insert() adds key/value entry w/ various semantics, depending on
  * provided strategy value. If a given key/value pair replaced already
@@ -126,38 +94,42 @@ enum hashmap_insert_strategy {
  * through old_key and old_value to allow calling code do proper memory
  * management.
  */
-int hashmap_insert(struct hashmap *map, long key, long value,
-		   enum hashmap_insert_strategy strategy,
-		   long *old_key, long *old_value);
+int hashmap__insert(struct hashmap *map, const void *key, void *value,
+		    enum hashmap_insert_strategy strategy,
+		    const void **old_key, void **old_value);
 
-#define hashmap__insert(map, key, value, strategy, old_key, old_value) \
-	hashmap_insert((map), (long)(key), (long)(value), (strategy),  \
-		       hashmap_cast_ptr(old_key),		       \
-		       hashmap_cast_ptr(old_value))
+static inline int hashmap__add(struct hashmap *map,
+			       const void *key, void *value)
+{
+	return hashmap__insert(map, key, value, HASHMAP_ADD, NULL, NULL);
+}
 
-#define hashmap__add(map, key, value) \
-	hashmap__insert((map), (key), (value), HASHMAP_ADD, NULL, NULL)
+static inline int hashmap__set(struct hashmap *map,
+			       const void *key, void *value,
+			       const void **old_key, void **old_value)
+{
+	return hashmap__insert(map, key, value, HASHMAP_SET,
+			       old_key, old_value);
+}
 
-#define hashmap__set(map, key, value, old_key, old_value) \
-	hashmap__insert((map), (key), (value), HASHMAP_SET, (old_key), (old_value))
+static inline int hashmap__update(struct hashmap *map,
+				  const void *key, void *value,
+				  const void **old_key, void **old_value)
+{
+	return hashmap__insert(map, key, value, HASHMAP_UPDATE,
+			       old_key, old_value);
+}
 
-#define hashmap__update(map, key, value, old_key, old_value) \
-	hashmap__insert((map), (key), (value), HASHMAP_UPDATE, (old_key), (old_value))
+static inline int hashmap__append(struct hashmap *map,
+				  const void *key, void *value)
+{
+	return hashmap__insert(map, key, value, HASHMAP_APPEND, NULL, NULL);
+}
 
-#define hashmap__append(map, key, value) \
-	hashmap__insert((map), (key), (value), HASHMAP_APPEND, NULL, NULL)
+bool hashmap__delete(struct hashmap *map, const void *key,
+		     const void **old_key, void **old_value);
 
-bool hashmap_delete(struct hashmap *map, long key, long *old_key, long *old_value);
-
-#define hashmap__delete(map, key, old_key, old_value)		       \
-	hashmap_delete((map), (long)(key),			       \
-		       hashmap_cast_ptr(old_key),		       \
-		       hashmap_cast_ptr(old_value))
-
-bool hashmap_find(const struct hashmap *map, long key, long *value);
-
-#define hashmap__find(map, key, value) \
-	hashmap_find((map), (long)(key), hashmap_cast_ptr(value))
+bool hashmap__find(const struct hashmap *map, const void *key, void **value);
 
 /*
  * hashmap__for_each_entry - iterate over all entries in hashmap
@@ -190,17 +162,17 @@ bool hashmap_find(const struct hashmap *map, long key, long *value);
  * @key: key to iterate entries for
  */
 #define hashmap__for_each_key_entry(map, cur, _key)			    \
-	for (cur = map->buckets						    \
-		     ? map->buckets[hash_bits(map->hash_fn((_key), map->ctx), map->cap_bits)] \
-		     : NULL;						    \
+	for (cur = ({ size_t bkt = hash_bits(map->hash_fn((_key), map->ctx),\
+					     map->cap_bits);		    \
+		     map->buckets ? map->buckets[bkt] : NULL; });	    \
 	     cur;							    \
 	     cur = cur->next)						    \
 		if (map->equal_fn(cur->key, (_key), map->ctx))
 
 #define hashmap__for_each_key_entry_safe(map, cur, tmp, _key)		    \
-	for (cur = map->buckets						    \
-		     ? map->buckets[hash_bits(map->hash_fn((_key), map->ctx), map->cap_bits)] \
-		     : NULL;						    \
+	for (cur = ({ size_t bkt = hash_bits(map->hash_fn((_key), map->ctx),\
+					     map->cap_bits);		    \
+		     cur = map->buckets ? map->buckets[bkt] : NULL; });	    \
 	     cur && ({ tmp = cur->next; true; });			    \
 	     cur = tmp)							    \
 		if (map->equal_fn(cur->key, (_key), map->ctx))