netdata_patch_1_4_6: Add patch to run on Debian 10

Upstream bpf-next should be good, so no temporary blocked tests should remain.

Signed-off-by: Andrii Nakryiko <andrii@kernel.org>

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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,59 @@
+#!/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

@@ -0,0 +1,38 @@
+# 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

@@ -0,0 +1,5 @@
+#!/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

@@ -0,0 +1,5 @@
+#!/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/vmtest/action.yml

@@ -0,0 +1,124 @@
+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

@@ -61,32 +61,31 @@ jobs:
           - arch: aarch64
           - arch: ppc64le
           - arch: s390x
-          - arch: amd64
+          - arch: x86
     steps:
       - uses: actions/checkout@v4
         name: Checkout
-
-      - name: Setup QEMU
-        uses: docker/setup-qemu-action@v3
-        with:
-          image: tonistiigi/binfmt:qemu-v8.1.5
-
       - uses: ./.github/actions/setup
         name: Pre-Setup
-
       - run: source /tmp/ci_setup && sudo -E $CI_ROOT/managers/ubuntu.sh
-        if: matrix.arch == 'amd64'
+        if: matrix.arch == 'x86'
         name: Setup
-
-      - name: Build in docker
-        if: matrix.arch != 'amd64'
-        run: |
-          cp /tmp/ci_setup ${GITHUB_WORKSPACE}
-          docker run --rm \
-                 --platform linux/${{ matrix.arch }} \
-                 -v ${GITHUB_WORKSPACE}:${GITHUB_WORKSPACE} \
-                 -e GITHUB_WORKSPACE=${GITHUB_WORKSPACE} \
-                 -w /ci/workspace \
-                 ubuntu:noble \
-                 ${GITHUB_WORKSPACE}/ci/build-in-docker.sh
-
+      - uses: uraimo/run-on-arch-action@v2.8.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/coverity.yml

@@ -1,30 +1,30 @@
 name: libbpf-ci-coverity
 
 on:
-  push:
-    branches:
-      - master
   schedule:
     - cron:  '0 18 * * *'
 
+
 jobs:
   coverity:
     runs-on: ubuntu-latest
+    if: github.repository == 'libbpf/libbpf'
     name: Coverity
-    env:
-      COVERITY_SCAN_TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}
     steps:
       - uses: actions/checkout@v4
       - uses: ./.github/actions/setup
       - name: Run coverity
-        if: ${{ env.COVERITY_SCAN_TOKEN }}
         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'

.github/workflows/ondemand.yml

@@ -3,29 +3,34 @@ name: ondemand
 on:
   workflow_dispatch:
     inputs:
-      arch:
-        default: 'x86_64'
+      kernel-origin:
+        description: 'git repo for linux kernel'
+        default: 'https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git'
         required: true
-      llvm-version:
-        default: '18'
-        required: true
-      kernel:
-        default: 'LATEST'
-        required: true
-      pahole:
+      kernel-rev:
+        description: 'rev/tag/branch for linux kernel'
         default: "master"
         required: true
-      runs-on:
-        default: 'ubuntu-24.04'
+      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:
-    name: ${{ inputs.kernel }} kernel llvm-${{ inputs.llvm-version }} pahole@${{ inputs.pahole }}
-    uses: ./.github/workflows/vmtest.yml
-    with:
-      runs_on: ${{ inputs.runs-on }}
-      kernel: ${{ inputs.kernel }}
-      arch: ${{ inputs.arch }}
-      llvm-version: ${{ inputs.llvm-version }}
-      pahole: ${{ inputs.pahole }}
+    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

@@ -0,0 +1,20 @@
+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,36 +1,39 @@
 name: libbpf-ci
 
-on:
+on: 
   pull_request:
   push:
   schedule:
     - cron:  '0 18 * * *'
 
-concurrency:
+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'
+            runs_on: ubuntu-24.04
             arch: 'x86_64'
-            llvm-version: '18'
-            pahole: 'master'
-          - kernel: 'LATEST'
-            runs_on: 'ubuntu-24.04'
+          - kernel: '5.5.0'
+            runs_on: ubuntu-24.04
             arch: 'x86_64'
-            llvm-version: '18'
-            pahole: 'tmp.master'
-    name: Linux ${{ matrix.kernel }} llvm-${{ matrix.llvm-version }}
-    uses: ./.github/workflows/vmtest.yml
-    with:
-      runs_on: ${{ matrix.runs_on }}
-      kernel: ${{ matrix.kernel }}
-      arch: ${{ matrix.arch }}
-      llvm-version: ${{ matrix.llvm-version }}
-      pahole: ${{ matrix.pahole }}
+          - kernel: '4.9.0'
+            runs_on: ubuntu-24.04
+            arch: 'x86_64'
+    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 }}

.github/workflows/vmtest.yml

@@ -1,117 +0,0 @@
-name: 'Build kernel and selftests/bpf, run selftests via vmtest'
-
-on:
-  workflow_call:
-    inputs:
-      runs_on:
-        required: true
-        default: 'ubuntu-24.04'
-        type: string
-      arch:
-        description: 'what arch to test'
-        required: true
-        default: 'x86_64'
-        type: string
-      kernel:
-        description: 'kernel version or LATEST'
-        required: true
-        default: 'LATEST'
-        type: string
-      pahole:
-        description: 'pahole rev or branch'
-        required: false
-        default: 'master'
-        type: string
-      llvm-version:
-        description: 'llvm version'
-        required: false
-        default: '18'
-        type: string
-jobs:
-  vmtest:
-    name: pahole@${{ inputs.pahole }}
-    runs-on: ${{ inputs.runs_on }}
-    steps:
-
-      - uses: actions/checkout@v4
-
-      - name: Setup environment
-        uses: libbpf/ci/setup-build-env@v3
-        with:
-          pahole: ${{ inputs.pahole }}
-          arch: ${{ inputs.arch }}
-          llvm-version: ${{ inputs.llvm-version }}
-
-      - 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@v3
-        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@v3
-        with:
-          patches-root: '${{ github.workspace }}/ci/diffs'
-          repo-root: '.kernel'
-
-      - name: Configure kernel build
-        shell: bash
-        run: |
-          cd .kernel
-          cat tools/testing/selftests/bpf/config \
-              tools/testing/selftests/bpf/config.${{ inputs.arch }} > .config
-          # this file might or might not exist depending on kernel version
-          cat tools/testing/selftests/bpf/config.vm >> .config || :
-          make olddefconfig && make prepare
-          cd -
-
-      - name: Build kernel image
-        if: ${{ inputs.kernel == 'LATEST' }}
-        shell: bash
-        run: |
-          cd .kernel
-          make -j $((4*$(nproc))) all
-          cp vmlinux ${{ github.workspace }}
-          cd -
-
-      - name: Download prebuilt kernel
-        if: ${{ inputs.kernel != 'LATEST' }}
-        uses: libbpf/ci/download-vmlinux@v3
-        with:
-          kernel: ${{ inputs.kernel }}
-          arch: ${{ inputs.arch }}
-
-      - name: Build selftests/bpf
-        uses: libbpf/ci/build-selftests@v3
-        env:
-          MAX_MAKE_JOBS: 32
-          VMLINUX_BTF: ${{ github.workspace }}/vmlinux
-          VMLINUX_H: ${{ inputs.kernel != 'LATEST' && format('{0}/.github/actions/build-selftests/vmlinux.h', github.workspace) || '' }}
-        with:
-          arch: ${{ inputs.arch }}
-          kernel-root: ${{ github.workspace }}/.kernel
-          llvm-version: ${{ inputs.llvm-version }}
-
-      - name: Run selftests
-        env:
-          ALLOWLIST_FILE: /tmp/allowlist
-          DENYLIST_FILE: /tmp/denylist
-          KERNEL: ${{ inputs.kernel }}
-          VMLINUX: ${{ github.workspace }}/vmlinux
-          LLVM_VERSION: ${{ inputs.llvm-version }}
-          SELFTESTS_BPF: ${{ github.workspace }}/.kernel/tools/testing/selftests/bpf
-          VMTEST_CONFIGS: ${{ github.workspace }}/ci/vmtest/configs
-        uses: libbpf/ci/run-vmtest@v3
-        with:
-          arch: ${{ inputs.arch }}
-          kbuild-output: ${{ github.workspace }}/.kernel
-          kernel-root: ${{ github.workspace }}/.kernel
-          vmlinuz: ${{ inputs.arch }}/vmlinuz-${{ inputs.kernel }}
-

.mailmap

@@ -8,7 +8,6 @@ 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>
-Jesper Dangaard Brouer <hawk@kernel.org> <brouer@redhat.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>

BPF-CHECKPOINT-COMMIT

@@ -1 +1 @@
-b4432656b36e5cc1d50a1f2dc15357543add530e
+d5fb316e2af1d947f0f6c3666e373a54d9f27c6f

CHECKPOINT-COMMIT

@@ -1 +1 @@
-9325d53fe9adff354b6a93fda5f38c165947da0f
+c6fb8030b4baa01c850f99fc6da051b1017edc46

ci/build-in-docker.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-
-export DEBIAN_FRONTEND=noninteractive
-export TZ="America/Los_Angeles"
-
-apt-get update -y
-apt-get install -y tzdata build-essential sudo
-source ${GITHUB_WORKSPACE}/ci_setup
-
-$CI_ROOT/managers/ubuntu.sh
-
-exit 0

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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,32 @@
+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/0001-selftests-bpf-set-test-path-for-token-obj_priv_impli.patch

@@ -1,85 +0,0 @@
-From e3a4f5092e847ec00e2b66c060f2cef52b8d0177 Mon Sep 17 00:00:00 2001
-From: Ihor Solodrai <ihor.solodrai@pm.me>
-Date: Thu, 14 Nov 2024 12:49:34 -0800
-Subject: [PATCH bpf-next] selftests/bpf: set test path for
- token/obj_priv_implicit_token_envvar
-
-token/obj_priv_implicit_token_envvar test may fail in an environment
-where the process executing tests can not write to the root path.
-
-Example:
-https://github.com/libbpf/libbpf/actions/runs/11844507007/job/33007897936
-
-Change default path used by the test to /tmp/bpf-token-fs, and make it
-runtime configurable via an environment variable.
-
-Signed-off-by: Ihor Solodrai <ihor.solodrai@pm.me>
----
- tools/testing/selftests/bpf/prog_tests/token.c | 18 +++++++++++-------
- 1 file changed, 11 insertions(+), 7 deletions(-)
-
-diff --git a/tools/testing/selftests/bpf/prog_tests/token.c b/tools/testing/selftests/bpf/prog_tests/token.c
-index fe86e4fdb89c..39f5414b674b 100644
---- a/tools/testing/selftests/bpf/prog_tests/token.c
-+++ b/tools/testing/selftests/bpf/prog_tests/token.c
-@@ -828,8 +828,11 @@ static int userns_obj_priv_btf_success(int mnt_fd, struct token_lsm *lsm_skel)
- 	return validate_struct_ops_load(mnt_fd, true /* should succeed */);
- }
- 
-+static const char* token_bpffs_custom_dir() {
-+	return getenv("BPF_SELFTESTS_BPF_TOKEN_DIR") ? : "/tmp/bpf-token-fs";
-+}
-+
- #define TOKEN_ENVVAR "LIBBPF_BPF_TOKEN_PATH"
--#define TOKEN_BPFFS_CUSTOM "/bpf-token-fs"
- 
- static int userns_obj_priv_implicit_token(int mnt_fd, struct token_lsm *lsm_skel)
- {
-@@ -892,6 +895,7 @@ static int userns_obj_priv_implicit_token(int mnt_fd, struct token_lsm *lsm_skel
- 
- static int userns_obj_priv_implicit_token_envvar(int mnt_fd, struct token_lsm *lsm_skel)
- {
-+	const char *custom_dir = token_bpffs_custom_dir();
- 	LIBBPF_OPTS(bpf_object_open_opts, opts);
- 	struct dummy_st_ops_success *skel;
- 	int err;
-@@ -909,10 +913,10 @@ static int userns_obj_priv_implicit_token_envvar(int mnt_fd, struct token_lsm *l
- 	 * BPF token implicitly, unless pointed to it through
- 	 * LIBBPF_BPF_TOKEN_PATH envvar
- 	 */
--	rmdir(TOKEN_BPFFS_CUSTOM);
--	if (!ASSERT_OK(mkdir(TOKEN_BPFFS_CUSTOM, 0777), "mkdir_bpffs_custom"))
-+	rmdir(custom_dir);
-+	if (!ASSERT_OK(mkdir(custom_dir, 0777), "mkdir_bpffs_custom"))
- 		goto err_out;
--	err = sys_move_mount(mnt_fd, "", AT_FDCWD, TOKEN_BPFFS_CUSTOM, MOVE_MOUNT_F_EMPTY_PATH);
-+	err = sys_move_mount(mnt_fd, "", AT_FDCWD, custom_dir, MOVE_MOUNT_F_EMPTY_PATH);
- 	if (!ASSERT_OK(err, "move_mount_bpffs"))
- 		goto err_out;
- 
-@@ -925,7 +929,7 @@ static int userns_obj_priv_implicit_token_envvar(int mnt_fd, struct token_lsm *l
- 		goto err_out;
- 	}
- 
--	err = setenv(TOKEN_ENVVAR, TOKEN_BPFFS_CUSTOM, 1 /*overwrite*/);
-+	err = setenv(TOKEN_ENVVAR, custom_dir, 1 /*overwrite*/);
- 	if (!ASSERT_OK(err, "setenv_token_path"))
- 		goto err_out;
- 
-@@ -951,11 +955,11 @@ static int userns_obj_priv_implicit_token_envvar(int mnt_fd, struct token_lsm *l
- 	if (!ASSERT_ERR(err, "obj_empty_token_path_load"))
- 		goto err_out;
- 
--	rmdir(TOKEN_BPFFS_CUSTOM);
-+	rmdir(custom_dir);
- 	unsetenv(TOKEN_ENVVAR);
- 	return 0;
- err_out:
--	rmdir(TOKEN_BPFFS_CUSTOM);
-+	rmdir(custom_dir);
- 	unsetenv(TOKEN_ENVVAR);
- 	return -EINVAL;
- }
--- 
-2.47.0
-

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

@@ -0,0 +1,56 @@
+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/diffs/0003-selftests-bpf-Fix-uprobe-consumer-test.patch

@@ -0,0 +1,58 @@
+From affb32e4f056883f285f8535b766293b85752fb4 Mon Sep 17 00:00:00 2001
+From: Jiri Olsa <jolsa@kernel.org>
+Date: Tue, 24 Sep 2024 13:07:30 +0200
+Subject: [PATCH] selftests/bpf: Fix uprobe consumer test
+
+With newly merged code the uprobe behaviour is slightly different
+and affects uprobe consumer test.
+
+We no longer need to check if the uprobe object is still preserved
+after removing last uretprobe, because it stays as long as there's
+pending/installed uretprobe instance.
+
+This allows to run uretprobe consumers registered 'after' uprobe was
+hit even if previous uretprobe got unregistered before being hit.
+
+The uprobe object will be now removed after the last uprobe ref is
+released and in such case it's held by ri->uprobe (return instance)
+which is released after the uretprobe is hit.
+
+Reported-by: Ihor Solodrai <ihor.solodrai@pm.me>
+Signed-off-by: Jiri Olsa <jolsa@kernel.org>
+Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
+Tested-by: Ihor Solodrai <ihor.solodrai@pm.me>
+Closes: https://lore.kernel.org/bpf/w6U8Z9fdhjnkSp2UaFaV1fGqJXvfLEtDKEUyGDkwmoruDJ_AgF_c0FFhrkeKW18OqiP-05s9yDKiT6X-Ns-avN_ABf0dcUkXqbSJN1TQSXo=@pm.me/
+---
+ .../testing/selftests/bpf/prog_tests/uprobe_multi_test.c | 9 +--------
+ 1 file changed, 1 insertion(+), 8 deletions(-)
+
+diff --git a/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c b/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c
+index 844f6fc8487b..c1ac813ff9ba 100644
+--- a/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c
++++ b/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c
+@@ -869,21 +869,14 @@ static void consumer_test(struct uprobe_multi_consumers *skel,
+ 			fmt = "prog 0/1: uprobe";
+ 		} else {
+ 			/*
+-			 * uprobe return is tricky ;-)
+-			 *
+ 			 * to trigger uretprobe consumer, the uretprobe needs to be installed,
+ 			 * which means one of the 'return' uprobes was alive when probe was hit:
+ 			 *
+ 			 *   idxs: 2/3 uprobe return in 'installed' mask
+-			 *
+-			 * in addition if 'after' state removes everything that was installed in
+-			 * 'before' state, then uprobe kernel object goes away and return uprobe
+-			 * is not installed and we won't hit it even if it's in 'after' state.
+ 			 */
+ 			unsigned long had_uretprobes  = before & 0b1100; /* is uretprobe installed */
+-			unsigned long probe_preserved = before & after;  /* did uprobe go away */
+ 
+-			if (had_uretprobes && probe_preserved && test_bit(idx, after))
++			if (had_uretprobes && test_bit(idx, after))
+ 				val++;
+ 			fmt = "idx 2/3: uretprobe";
+ 		}
+-- 
+2.34.1
+

ci/diffs/4000-selftests-bpf-Fix-tests-after-fields-reorder-in-stru.patch

@@ -1,69 +0,0 @@
-From bd06a13f44e15e2e83561ea165061c445a15bd9e Mon Sep 17 00:00:00 2001
-From: Song Liu <song@kernel.org>
-Date: Thu, 27 Mar 2025 11:55:28 -0700
-Subject: [PATCH 4000/4002] selftests/bpf: Fix tests after fields reorder in
- struct file
-
-The change in struct file [1] moved f_ref to the 3rd cache line.
-It made *(u64 *)file dereference invalid from the verifier point of view,
-because btf_struct_walk() walks into f_lock field, which is 4-byte long.
-
-Fix the selftests to deference the file pointer as a 4-byte access.
-
-[1] commit e249056c91a2 ("fs: place f_ref to 3rd cache line in struct file to resolve false sharing")
-Reported-by: Jakub Kicinski <kuba@kernel.org>
-Signed-off-by: Song Liu <song@kernel.org>
-Link: https://lore.kernel.org/r/20250327185528.1740787-1-song@kernel.org
-Signed-off-by: Alexei Starovoitov <ast@kernel.org>
----
- tools/testing/selftests/bpf/progs/test_module_attach.c    | 2 +-
- tools/testing/selftests/bpf/progs/test_subprogs_extable.c | 6 +++---
- 2 files changed, 4 insertions(+), 4 deletions(-)
-
-diff --git a/tools/testing/selftests/bpf/progs/test_module_attach.c b/tools/testing/selftests/bpf/progs/test_module_attach.c
-index fb07f5773888..7f3c233943b3 100644
---- a/tools/testing/selftests/bpf/progs/test_module_attach.c
-+++ b/tools/testing/selftests/bpf/progs/test_module_attach.c
-@@ -117,7 +117,7 @@ int BPF_PROG(handle_fexit_ret, int arg, struct file *ret)
- 
- 	bpf_probe_read_kernel(&buf, 8, ret);
- 	bpf_probe_read_kernel(&buf, 8, (char *)ret + 256);
--	*(volatile long long *)ret;
-+	*(volatile int *)ret;
- 	*(volatile int *)&ret->f_mode;
- 	return 0;
- }
-diff --git a/tools/testing/selftests/bpf/progs/test_subprogs_extable.c b/tools/testing/selftests/bpf/progs/test_subprogs_extable.c
-index e2a21fbd4e44..dcac69f5928a 100644
---- a/tools/testing/selftests/bpf/progs/test_subprogs_extable.c
-+++ b/tools/testing/selftests/bpf/progs/test_subprogs_extable.c
-@@ -21,7 +21,7 @@ static __u64 test_cb(struct bpf_map *map, __u32 *key, __u64 *val, void *data)
- SEC("fexit/bpf_testmod_return_ptr")
- int BPF_PROG(handle_fexit_ret_subprogs, int arg, struct file *ret)
- {
--	*(volatile long *)ret;
-+	*(volatile int *)ret;
- 	*(volatile int *)&ret->f_mode;
- 	bpf_for_each_map_elem(&test_array, test_cb, NULL, 0);
- 	triggered++;
-@@ -31,7 +31,7 @@ int BPF_PROG(handle_fexit_ret_subprogs, int arg, struct file *ret)
- SEC("fexit/bpf_testmod_return_ptr")
- int BPF_PROG(handle_fexit_ret_subprogs2, int arg, struct file *ret)
- {
--	*(volatile long *)ret;
-+	*(volatile int *)ret;
- 	*(volatile int *)&ret->f_mode;
- 	bpf_for_each_map_elem(&test_array, test_cb, NULL, 0);
- 	triggered++;
-@@ -41,7 +41,7 @@ int BPF_PROG(handle_fexit_ret_subprogs2, int arg, struct file *ret)
- SEC("fexit/bpf_testmod_return_ptr")
- int BPF_PROG(handle_fexit_ret_subprogs3, int arg, struct file *ret)
- {
--	*(volatile long *)ret;
-+	*(volatile int *)ret;
- 	*(volatile int *)&ret->f_mode;
- 	bpf_for_each_map_elem(&test_array, test_cb, NULL, 0);
- 	triggered++;
--- 
-2.49.0
-

ci/diffs/4001-selftests-bpf-Fix-verifier_bpf_fastcall-test.patch

@@ -1,71 +0,0 @@
-From 8be3a12f9f266aaf3f06f0cfe0e90cfe4d956f3d Mon Sep 17 00:00:00 2001
-From: Song Liu <song@kernel.org>
-Date: Fri, 28 Mar 2025 12:31:24 -0700
-Subject: [PATCH 4001/4002] selftests/bpf: Fix verifier_bpf_fastcall test
-
-Commit [1] moves percpu data on x86 from address 0x000... to address
-0xfff...
-
-Before [1]:
-
-159020: 0000000000030700     0 OBJECT  GLOBAL DEFAULT   23 pcpu_hot
-
-After [1]:
-
-152602: ffffffff83a3e034     4 OBJECT  GLOBAL DEFAULT   35 pcpu_hot
-
-As a result, verifier_bpf_fastcall tests should now expect a negative
-value for pcpu_hot, IOW, the disassemble should show "r=" instead of
-"w=".
-
-Fix this in the test.
-
-Note that, a later change created a new variable "cpu_number" for
-bpf_get_smp_processor_id() [2]. The inlining logic is updated properly
-as part of this change, so there is no need to fix anything on the
-kernel side.
-
-[1] commit 9d7de2aa8b41 ("x86/percpu/64: Use relative percpu offsets")
-[2] commit 01c7bc5198e9 ("x86/smp: Move cpu number to percpu hot section")
-Reported-by: Jakub Kicinski <kuba@kernel.org>
-Signed-off-by: Song Liu <song@kernel.org>
-Link: https://lore.kernel.org/r/20250328193124.808784-1-song@kernel.org
-Signed-off-by: Alexei Starovoitov <ast@kernel.org>
----
- tools/testing/selftests/bpf/progs/verifier_bpf_fastcall.c | 6 +++---
- 1 file changed, 3 insertions(+), 3 deletions(-)
-
-diff --git a/tools/testing/selftests/bpf/progs/verifier_bpf_fastcall.c b/tools/testing/selftests/bpf/progs/verifier_bpf_fastcall.c
-index a9be6ae49454..c258b0722e04 100644
---- a/tools/testing/selftests/bpf/progs/verifier_bpf_fastcall.c
-+++ b/tools/testing/selftests/bpf/progs/verifier_bpf_fastcall.c
-@@ -12,7 +12,7 @@ SEC("raw_tp")
- __arch_x86_64
- __log_level(4) __msg("stack depth 8")
- __xlated("4: r5 = 5")
--__xlated("5: w0 = ")
-+__xlated("5: r0 = ")
- __xlated("6: r0 = &(void __percpu *)(r0)")
- __xlated("7: r0 = *(u32 *)(r0 +0)")
- __xlated("8: exit")
-@@ -704,7 +704,7 @@ SEC("raw_tp")
- __arch_x86_64
- __log_level(4) __msg("stack depth 32+0")
- __xlated("2: r1 = 1")
--__xlated("3: w0 =")
-+__xlated("3: r0 =")
- __xlated("4: r0 = &(void __percpu *)(r0)")
- __xlated("5: r0 = *(u32 *)(r0 +0)")
- /* bpf_loop params setup */
-@@ -753,7 +753,7 @@ __arch_x86_64
- __log_level(4) __msg("stack depth 40+0")
- /* call bpf_get_smp_processor_id */
- __xlated("2: r1 = 42")
--__xlated("3: w0 =")
-+__xlated("3: r0 =")
- __xlated("4: r0 = &(void __percpu *)(r0)")
- __xlated("5: r0 = *(u32 *)(r0 +0)")
- /* call bpf_get_prandom_u32 */
--- 
-2.49.0
-

ci/diffs/4002-selftests-bpf-Fix-verifier_private_stack-test-failur.patch

@@ -1,71 +0,0 @@
-From 07be1f644ff9eeb842fd0490ddd824df0828cb0e Mon Sep 17 00:00:00 2001
-From: Yonghong Song <yonghong.song@linux.dev>
-Date: Sun, 30 Mar 2025 20:38:28 -0700
-Subject: [PATCH 4002/4002] selftests/bpf: Fix verifier_private_stack test
- failure
-
-Several verifier_private_stack tests failed with latest bpf-next.
-For example, for 'Private stack, single prog' subtest, the
-jitted code:
-  func #0:
-  0:      f3 0f 1e fa                             endbr64
-  4:      0f 1f 44 00 00                          nopl    (%rax,%rax)
-  9:      0f 1f 00                                nopl    (%rax)
-  c:      55                                      pushq   %rbp
-  d:      48 89 e5                                movq    %rsp, %rbp
-  10:     f3 0f 1e fa                             endbr64
-  14:     49 b9 58 74 8a 8f 7d 60 00 00           movabsq $0x607d8f8a7458, %r9
-  1e:     65 4c 03 0c 25 28 c0 48 87              addq    %gs:-0x78b73fd8, %r9
-  27:     bf 2a 00 00 00                          movl    $0x2a, %edi
-  2c:     49 89 b9 00 ff ff ff                    movq    %rdi, -0x100(%r9)
-  33:     31 c0                                   xorl    %eax, %eax
-  35:     c9                                      leave
-  36:     e9 20 5d 0f e1                          jmp     0xffffffffe10f5d5b
-
-The insn 'addq %gs:-0x78b73fd8, %r9' does not match the expected
-regex 'addq %gs:0x{{.*}}, %r9' and this caused test failure.
-
-Fix it by changing '%gs:0x{{.*}}' to '%gs:{{.*}}' to accommodate the
-possible negative offset. A few other subtests are fixed in a similar way.
-
-Signed-off-by: Yonghong Song <yonghong.song@linux.dev>
-Link: https://lore.kernel.org/r/20250331033828.365077-1-yonghong.song@linux.dev
-Signed-off-by: Alexei Starovoitov <ast@kernel.org>
----
- tools/testing/selftests/bpf/progs/verifier_private_stack.c | 6 +++---
- 1 file changed, 3 insertions(+), 3 deletions(-)
-
-diff --git a/tools/testing/selftests/bpf/progs/verifier_private_stack.c b/tools/testing/selftests/bpf/progs/verifier_private_stack.c
-index b1fbdf119553..fc91b414364e 100644
---- a/tools/testing/selftests/bpf/progs/verifier_private_stack.c
-+++ b/tools/testing/selftests/bpf/progs/verifier_private_stack.c
-@@ -27,7 +27,7 @@ __description("Private stack, single prog")
- __success
- __arch_x86_64
- __jited("	movabsq	$0x{{.*}}, %r9")
--__jited("	addq	%gs:0x{{.*}}, %r9")
-+__jited("	addq	%gs:{{.*}}, %r9")
- __jited("	movl	$0x2a, %edi")
- __jited("	movq	%rdi, -0x100(%r9)")
- __naked void private_stack_single_prog(void)
-@@ -74,7 +74,7 @@ __success
- __arch_x86_64
- /* private stack fp for the main prog */
- __jited("	movabsq	$0x{{.*}}, %r9")
--__jited("	addq	%gs:0x{{.*}}, %r9")
-+__jited("	addq	%gs:{{.*}}, %r9")
- __jited("	movl	$0x2a, %edi")
- __jited("	movq	%rdi, -0x200(%r9)")
- __jited("	pushq	%r9")
-@@ -122,7 +122,7 @@ __jited("	pushq	%rbp")
- __jited("	movq	%rsp, %rbp")
- __jited("	endbr64")
- __jited("	movabsq	$0x{{.*}}, %r9")
--__jited("	addq	%gs:0x{{.*}}, %r9")
-+__jited("	addq	%gs:{{.*}}, %r9")
- __jited("	pushq	%r9")
- __jited("	callq")
- __jited("	popq	%r9")
--- 
-2.49.0
-

ci/vmtest/configs/ALLOWLIST-4.9.0

@@ -0,0 +1,8 @@
+# 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

@@ -0,0 +1,49 @@
+# 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-5.5.0

@@ -0,0 +1,5 @@
+# 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/run-vmtest.env

@@ -1,37 +0,0 @@
-#!/bin/bash
-
-# This file is sourced by libbpf/ci/run-vmtest Github Action scripts.
-
-# $SELFTESTS_BPF and $VMTEST_CONFIGS are set in the workflow, before
-# libbpf/ci/run-vmtest action is called
-# See .github/workflows/kernel-test.yml
-
-ALLOWLIST_FILES=(
-    "${SELFTESTS_BPF}/ALLOWLIST"
-    "${SELFTESTS_BPF}/ALLOWLIST.${ARCH}"
-    "${VMTEST_CONFIGS}/ALLOWLIST"
-    "${VMTEST_CONFIGS}/ALLOWLIST-${KERNEL}"
-    "${VMTEST_CONFIGS}/ALLOWLIST-${KERNEL}.${ARCH}"
-)
-
-DENYLIST_FILES=(
-    "${SELFTESTS_BPF}/DENYLIST"
-    "${SELFTESTS_BPF}/DENYLIST.${ARCH}"
-    "${VMTEST_CONFIGS}/DENYLIST"
-    "${VMTEST_CONFIGS}/DENYLIST-${KERNEL}"
-    "${VMTEST_CONFIGS}/DENYLIST-${KERNEL}.${ARCH}"
-)
-
-# Export pipe-separated strings, because bash doesn't support array export
-export SELFTESTS_BPF_ALLOWLIST_FILES=$(IFS="|"; echo "${ALLOWLIST_FILES[*]}")
-export SELFTESTS_BPF_DENYLIST_FILES=$(IFS="|"; echo "${DENYLIST_FILES[*]}")
-
-if [[ "${LLVM_VERSION}" -lt 18 ]]; then
-    echo "KERNEL_TEST=test_progs test_progs_no_alu32 test_maps test_verifier" >> $GITHUB_ENV
-else # all
-    echo "KERNEL_TEST=test_progs test_progs_cpuv4 test_progs_no_alu32 test_maps test_verifier" >> $GITHUB_ENV
-fi
-
-echo "cp -R ${SELFTESTS_BPF} ${GITHUB_WORKSPACE}/selftests"
-mkdir -p "${GITHUB_WORKSPACE}/selftests"
-cp -R "${SELFTESTS_BPF}" "${GITHUB_WORKSPACE}/selftests"

ci/vmtest/helpers.sh

@@ -0,0 +1,38 @@
+# 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

@@ -0,0 +1,96 @@
+#!/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

include/uapi/linux/bpf.h

@@ -51,9 +51,6 @@
 #define BPF_XCHG	(0xe0 | BPF_FETCH)	/* atomic exchange */
 #define BPF_CMPXCHG	(0xf0 | BPF_FETCH)	/* atomic compare-and-write */
 
-#define BPF_LOAD_ACQ	0x100	/* load-acquire */
-#define BPF_STORE_REL	0x110	/* store-release */
-
 enum bpf_cond_pseudo_jmp {
 	BPF_MAY_GOTO = 0,
 };
@@ -1119,7 +1116,6 @@ enum bpf_attach_type {
 	BPF_NETKIT_PRIMARY,
 	BPF_NETKIT_PEER,
 	BPF_TRACE_KPROBE_SESSION,
-	BPF_TRACE_UPROBE_SESSION,
 	__MAX_BPF_ATTACH_TYPE
 };
 
@@ -1210,7 +1206,6 @@ enum bpf_perf_event_type {
 #define BPF_F_BEFORE		(1U << 3)
 #define BPF_F_AFTER		(1U << 4)
 #define BPF_F_ID		(1U << 5)
-#define BPF_F_PREORDER		(1U << 6)
 #define BPF_F_LINK		BPF_F_LINK /* 1 << 13 */
 
 /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the
@@ -1506,7 +1501,7 @@ union bpf_attr {
 		__s32	map_token_fd;
 	};
 
-	struct { /* anonymous struct used by BPF_MAP_*_ELEM and BPF_MAP_FREEZE commands */
+	struct { /* anonymous struct used by BPF_MAP_*_ELEM commands */
 		__u32		map_fd;
 		__aligned_u64	key;
 		union {
@@ -1577,16 +1572,6 @@ union bpf_attr {
 		 * If provided, prog_flags should have BPF_F_TOKEN_FD flag set.
 		 */
 		__s32		prog_token_fd;
-		/* The fd_array_cnt can be used to pass the length of the
-		 * fd_array array. In this case all the [map] file descriptors
-		 * passed in this array will be bound to the program, even if
-		 * the maps are not referenced directly. The functionality is
-		 * similar to the BPF_PROG_BIND_MAP syscall, but maps can be
-		 * used by the verifier during the program load. If provided,
-		 * then the fd_array[0,...,fd_array_cnt-1] is expected to be
-		 * continuous.
-		 */
-		__u32		fd_array_cnt;
 	};
 
 	struct { /* anonymous struct used by BPF_OBJ_* commands */
@@ -1652,7 +1637,6 @@ union bpf_attr {
 		};
 		__u32		next_id;
 		__u32		open_flags;
-		__s32		fd_by_id_token_fd;
 	};
 
 	struct { /* anonymous struct used by BPF_OBJ_GET_INFO_BY_FD */
@@ -1995,15 +1979,11 @@ union bpf_attr {
  * long bpf_skb_store_bytes(struct sk_buff *skb, u32 offset, const void *from, u32 len, u64 flags)
  * 	Description
  * 		Store *len* bytes from address *from* into the packet
- * 		associated to *skb*, at *offset*. The *flags* are a combination
- * 		of the following values:
- *
- * 		**BPF_F_RECOMPUTE_CSUM**
- * 			Automatically update *skb*\ **->csum** after storing the
- * 			bytes.
- * 		**BPF_F_INVALIDATE_HASH**
- * 			Set *skb*\ **->hash**, *skb*\ **->swhash** and *skb*\
- * 			**->l4hash** to 0.
+ * 		associated to *skb*, at *offset*. *flags* are a combination of
+ * 		**BPF_F_RECOMPUTE_CSUM** (automatically recompute the
+ * 		checksum for the packet after storing the bytes) and
+ * 		**BPF_F_INVALIDATE_HASH** (set *skb*\ **->hash**, *skb*\
+ * 		**->swhash** and *skb*\ **->l4hash** to 0).
  *
  * 		A call to this helper is susceptible to change the underlying
  * 		packet buffer. Therefore, at load time, all checks on pointers
@@ -2055,7 +2035,7 @@ union bpf_attr {
  * 		untouched (unless **BPF_F_MARK_ENFORCE** is added as well), and
  * 		for updates resulting in a null checksum the value is set to
  * 		**CSUM_MANGLED_0** instead. Flag **BPF_F_PSEUDO_HDR** indicates
- * 		that the modified header field is part of the pseudo-header.
+ * 		the checksum is to be computed against a pseudo-header.
  *
  * 		This helper works in combination with **bpf_csum_diff**\ (),
  * 		which does not update the checksum in-place, but offers more
@@ -6028,10 +6008,7 @@ union bpf_attr {
 	FN(user_ringbuf_drain, 209, ##ctx)		\
 	FN(cgrp_storage_get, 210, ##ctx)		\
 	FN(cgrp_storage_delete, 211, ##ctx)		\
-	/* This helper list is effectively frozen. If you are trying to	\
-	 * add a new helper, you should add a kfunc instead which has	\
-	 * less stability guarantees. See Documentation/bpf/kfuncs.rst	\
-	 */
+	/* */
 
 /* backwards-compatibility macros for users of __BPF_FUNC_MAPPER that don't
  * know or care about integer value that is now passed as second argument
@@ -6724,7 +6701,6 @@ struct bpf_link_info {
 					__u32 name_len;
 					__u32 offset; /* offset from file_name */
 					__u64 cookie;
-					__u64 ref_ctr_offset;
 				} uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */
 				struct {
 					__aligned_u64 func_name; /* in/out */
@@ -6926,12 +6902,6 @@ enum {
 	BPF_SOCK_OPS_ALL_CB_FLAGS       = 0x7F,
 };
 
-enum {
-	SK_BPF_CB_TX_TIMESTAMPING	= 1<<0,
-	SK_BPF_CB_MASK			= (SK_BPF_CB_TX_TIMESTAMPING - 1) |
-					   SK_BPF_CB_TX_TIMESTAMPING
-};
-
 /* List of known BPF sock_ops operators.
  * New entries can only be added at the end
  */
@@ -7044,29 +7014,6 @@ enum {
 					 * by the kernel or the
 					 * earlier bpf-progs.
 					 */
-	BPF_SOCK_OPS_TSTAMP_SCHED_CB,	/* Called when skb is passing
-					 * through dev layer when
-					 * SK_BPF_CB_TX_TIMESTAMPING
-					 * feature is on.
-					 */
-	BPF_SOCK_OPS_TSTAMP_SND_SW_CB,	/* Called when skb is about to send
-					 * to the nic when SK_BPF_CB_TX_TIMESTAMPING
-					 * feature is on.
-					 */
-	BPF_SOCK_OPS_TSTAMP_SND_HW_CB,	/* Called in hardware phase when
-					 * SK_BPF_CB_TX_TIMESTAMPING feature
-					 * is on.
-					 */
-	BPF_SOCK_OPS_TSTAMP_ACK_CB,	/* Called when all the skbs in the
-					 * same sendmsg call are acked
-					 * when SK_BPF_CB_TX_TIMESTAMPING
-					 * feature is on.
-					 */
-	BPF_SOCK_OPS_TSTAMP_SENDMSG_CB,	/* Called when every sendmsg syscall
-					 * is triggered. It's used to correlate
-					 * sendmsg timestamp with corresponding
-					 * tskey.
-					 */
 };
 
 /* List of TCP states. There is a build check in net/ipv4/tcp.c to detect
@@ -7133,7 +7080,6 @@ enum {
 	TCP_BPF_SYN_IP		= 1006, /* Copy the IP[46] and TCP header */
 	TCP_BPF_SYN_MAC         = 1007, /* Copy the MAC, IP[46], and TCP header */
 	TCP_BPF_SOCK_OPS_CB_FLAGS = 1008, /* Get or Set TCP sock ops flags */
-	SK_BPF_CB_FLAGS		= 1009, /* Get or set sock ops flags in socket */
 };
 
 enum {

include/uapi/linux/btf.h

@@ -36,8 +36,7 @@ struct btf_type {
 	 * bits 24-28: kind (e.g. int, ptr, array...etc)
 	 * bits 29-30: unused
 	 * bit     31: kind_flag, currently used by
-	 *             struct, union, enum, fwd, enum64,
-	 *             decl_tag and type_tag
+	 *             struct, union, enum, fwd and enum64
 	 */
 	__u32 info;
 	/* "size" is used by INT, ENUM, STRUCT, UNION, DATASEC and ENUM64.

include/uapi/linux/if_link.h

@@ -377,7 +377,6 @@ enum {
 	IFLA_GSO_IPV4_MAX_SIZE,
 	IFLA_GRO_IPV4_MAX_SIZE,
 	IFLA_DPLL_PIN,
-	IFLA_MAX_PACING_OFFLOAD_HORIZON,
 	__IFLA_MAX
 };
 
@@ -462,286 +461,6 @@ enum in6_addr_gen_mode {
 
 /* Bridge section */
 
-/**
- * DOC: Bridge enum definition
- *
- * Please *note* that the timer values in the following section are expected
- * in clock_t format, which is seconds multiplied by USER_HZ (generally
- * defined as 100).
- *
- * @IFLA_BR_FORWARD_DELAY
- *   The bridge forwarding delay is the time spent in LISTENING state
- *   (before moving to LEARNING) and in LEARNING state (before moving
- *   to FORWARDING). Only relevant if STP is enabled.
- *
- *   The valid values are between (2 * USER_HZ) and (30 * USER_HZ).
- *   The default value is (15 * USER_HZ).
- *
- * @IFLA_BR_HELLO_TIME
- *   The time between hello packets sent by the bridge, when it is a root
- *   bridge or a designated bridge. Only relevant if STP is enabled.
- *
- *   The valid values are between (1 * USER_HZ) and (10 * USER_HZ).
- *   The default value is (2 * USER_HZ).
- *
- * @IFLA_BR_MAX_AGE
- *   The hello packet timeout is the time until another bridge in the
- *   spanning tree is assumed to be dead, after reception of its last hello
- *   message. Only relevant if STP is enabled.
- *
- *   The valid values are between (6 * USER_HZ) and (40 * USER_HZ).
- *   The default value is (20 * USER_HZ).
- *
- * @IFLA_BR_AGEING_TIME
- *   Configure the bridge's FDB entries aging time. It is the time a MAC
- *   address will be kept in the FDB after a packet has been received from
- *   that address. After this time has passed, entries are cleaned up.
- *   Allow values outside the 802.1 standard specification for special cases:
- *
- *     * 0 - entry never ages (all permanent)
- *     * 1 - entry disappears (no persistence)
- *
- *   The default value is (300 * USER_HZ).
- *
- * @IFLA_BR_STP_STATE
- *   Turn spanning tree protocol on (*IFLA_BR_STP_STATE* > 0) or off
- *   (*IFLA_BR_STP_STATE* == 0) for this bridge.
- *
- *   The default value is 0 (disabled).
- *
- * @IFLA_BR_PRIORITY
- *   Set this bridge's spanning tree priority, used during STP root bridge
- *   election.
- *
- *   The valid values are between 0 and 65535.
- *
- * @IFLA_BR_VLAN_FILTERING
- *   Turn VLAN filtering on (*IFLA_BR_VLAN_FILTERING* > 0) or off
- *   (*IFLA_BR_VLAN_FILTERING* == 0). When disabled, the bridge will not
- *   consider the VLAN tag when handling packets.
- *
- *   The default value is 0 (disabled).
- *
- * @IFLA_BR_VLAN_PROTOCOL
- *   Set the protocol used for VLAN filtering.
- *
- *   The valid values are 0x8100(802.1Q) or 0x88A8(802.1AD). The default value
- *   is 0x8100(802.1Q).
- *
- * @IFLA_BR_GROUP_FWD_MASK
- *   The group forwarding mask. This is the bitmask that is applied to
- *   decide whether to forward incoming frames destined to link-local
- *   addresses (of the form 01:80:C2:00:00:0X).
- *
- *   The default value is 0, which means the bridge does not forward any
- *   link-local frames coming on this port.
- *
- * @IFLA_BR_ROOT_ID
- *   The bridge root id, read only.
- *
- * @IFLA_BR_BRIDGE_ID
- *   The bridge id, read only.
- *
- * @IFLA_BR_ROOT_PORT
- *   The bridge root port, read only.
- *
- * @IFLA_BR_ROOT_PATH_COST
- *   The bridge root path cost, read only.
- *
- * @IFLA_BR_TOPOLOGY_CHANGE
- *   The bridge topology change, read only.
- *
- * @IFLA_BR_TOPOLOGY_CHANGE_DETECTED
- *   The bridge topology change detected, read only.
- *
- * @IFLA_BR_HELLO_TIMER
- *   The bridge hello timer, read only.
- *
- * @IFLA_BR_TCN_TIMER
- *   The bridge tcn timer, read only.
- *
- * @IFLA_BR_TOPOLOGY_CHANGE_TIMER
- *   The bridge topology change timer, read only.
- *
- * @IFLA_BR_GC_TIMER
- *   The bridge gc timer, read only.
- *
- * @IFLA_BR_GROUP_ADDR
- *   Set the MAC address of the multicast group this bridge uses for STP.
- *   The address must be a link-local address in standard Ethernet MAC address
- *   format. It is an address of the form 01:80:C2:00:00:0X, with X in [0, 4..f].
- *
- *   The default value is 0.
- *
- * @IFLA_BR_FDB_FLUSH
- *   Flush bridge's fdb dynamic entries.
- *
- * @IFLA_BR_MCAST_ROUTER
- *   Set bridge's multicast router if IGMP snooping is enabled.
- *   The valid values are:
- *
- *     * 0 - disabled.
- *     * 1 - automatic (queried).
- *     * 2 - permanently enabled.
- *
- *   The default value is 1.
- *
- * @IFLA_BR_MCAST_SNOOPING
- *   Turn multicast snooping on (*IFLA_BR_MCAST_SNOOPING* > 0) or off
- *   (*IFLA_BR_MCAST_SNOOPING* == 0).
- *
- *   The default value is 1.
- *
- * @IFLA_BR_MCAST_QUERY_USE_IFADDR
- *   If enabled use the bridge's own IP address as source address for IGMP
- *   queries (*IFLA_BR_MCAST_QUERY_USE_IFADDR* > 0) or the default of 0.0.0.0
- *   (*IFLA_BR_MCAST_QUERY_USE_IFADDR* == 0).
- *
- *   The default value is 0 (disabled).
- *
- * @IFLA_BR_MCAST_QUERIER
- *   Enable (*IFLA_BR_MULTICAST_QUERIER* > 0) or disable
- *   (*IFLA_BR_MULTICAST_QUERIER* == 0) IGMP querier, ie sending of multicast
- *   queries by the bridge.
- *
- *   The default value is 0 (disabled).
- *
- * @IFLA_BR_MCAST_HASH_ELASTICITY
- *   Set multicast database hash elasticity, It is the maximum chain length in
- *   the multicast hash table. This attribute is *deprecated* and the value
- *   is always 16.
- *
- * @IFLA_BR_MCAST_HASH_MAX
- *   Set maximum size of the multicast hash table
- *
- *   The default value is 4096, the value must be a power of 2.
- *
- * @IFLA_BR_MCAST_LAST_MEMBER_CNT
- *   The Last Member Query Count is the number of Group-Specific Queries
- *   sent before the router assumes there are no local members. The Last
- *   Member Query Count is also the number of Group-and-Source-Specific
- *   Queries sent before the router assumes there are no listeners for a
- *   particular source.
- *
- *   The default value is 2.
- *
- * @IFLA_BR_MCAST_STARTUP_QUERY_CNT
- *   The Startup Query Count is the number of Queries sent out on startup,
- *   separated by the Startup Query Interval.
- *
- *   The default value is 2.
- *
- * @IFLA_BR_MCAST_LAST_MEMBER_INTVL
- *   The Last Member Query Interval is the Max Response Time inserted into
- *   Group-Specific Queries sent in response to Leave Group messages, and
- *   is also the amount of time between Group-Specific Query messages.
- *
- *   The default value is (1 * USER_HZ).
- *
- * @IFLA_BR_MCAST_MEMBERSHIP_INTVL
- *   The interval after which the bridge will leave a group, if no membership
- *   reports for this group are received.
- *
- *   The default value is (260 * USER_HZ).
- *
- * @IFLA_BR_MCAST_QUERIER_INTVL
- *   The interval between queries sent by other routers. if no queries are
- *   seen after this delay has passed, the bridge will start to send its own
- *   queries (as if *IFLA_BR_MCAST_QUERIER_INTVL* was enabled).
- *
- *   The default value is (255 * USER_HZ).
- *
- * @IFLA_BR_MCAST_QUERY_INTVL
- *   The Query Interval is the interval between General Queries sent by
- *   the Querier.
- *
- *   The default value is (125 * USER_HZ). The minimum value is (1 * USER_HZ).
- *
- * @IFLA_BR_MCAST_QUERY_RESPONSE_INTVL
- *   The Max Response Time used to calculate the Max Resp Code inserted
- *   into the periodic General Queries.
- *
- *   The default value is (10 * USER_HZ).
- *
- * @IFLA_BR_MCAST_STARTUP_QUERY_INTVL
- *   The interval between queries in the startup phase.
- *
- *   The default value is (125 * USER_HZ) / 4. The minimum value is (1 * USER_HZ).
- *
- * @IFLA_BR_NF_CALL_IPTABLES
- *   Enable (*NF_CALL_IPTABLES* > 0) or disable (*NF_CALL_IPTABLES* == 0)
- *   iptables hooks on the bridge.
- *
- *   The default value is 0 (disabled).
- *
- * @IFLA_BR_NF_CALL_IP6TABLES
- *   Enable (*NF_CALL_IP6TABLES* > 0) or disable (*NF_CALL_IP6TABLES* == 0)
- *   ip6tables hooks on the bridge.
- *
- *   The default value is 0 (disabled).
- *
- * @IFLA_BR_NF_CALL_ARPTABLES
- *   Enable (*NF_CALL_ARPTABLES* > 0) or disable (*NF_CALL_ARPTABLES* == 0)
- *   arptables hooks on the bridge.
- *
- *   The default value is 0 (disabled).
- *
- * @IFLA_BR_VLAN_DEFAULT_PVID
- *   VLAN ID applied to untagged and priority-tagged incoming packets.
- *
- *   The default value is 1. Setting to the special value 0 makes all ports of
- *   this bridge not have a PVID by default, which means that they will
- *   not accept VLAN-untagged traffic.
- *
- * @IFLA_BR_PAD
- *   Bridge attribute padding type for netlink message.
- *
- * @IFLA_BR_VLAN_STATS_ENABLED
- *   Enable (*IFLA_BR_VLAN_STATS_ENABLED* == 1) or disable
- *   (*IFLA_BR_VLAN_STATS_ENABLED* == 0) per-VLAN stats accounting.
- *
- *   The default value is 0 (disabled).
- *
- * @IFLA_BR_MCAST_STATS_ENABLED
- *   Enable (*IFLA_BR_MCAST_STATS_ENABLED* > 0) or disable
- *   (*IFLA_BR_MCAST_STATS_ENABLED* == 0) multicast (IGMP/MLD) stats
- *   accounting.
- *
- *   The default value is 0 (disabled).
- *
- * @IFLA_BR_MCAST_IGMP_VERSION
- *   Set the IGMP version.
- *
- *   The valid values are 2 and 3. The default value is 2.
- *
- * @IFLA_BR_MCAST_MLD_VERSION
- *   Set the MLD version.
- *
- *   The valid values are 1 and 2. The default value is 1.
- *
- * @IFLA_BR_VLAN_STATS_PER_PORT
- *   Enable (*IFLA_BR_VLAN_STATS_PER_PORT* == 1) or disable
- *   (*IFLA_BR_VLAN_STATS_PER_PORT* == 0) per-VLAN per-port stats accounting.
- *   Can be changed only when there are no port VLANs configured.
- *
- *   The default value is 0 (disabled).
- *
- * @IFLA_BR_MULTI_BOOLOPT
- *   The multi_boolopt is used to control new boolean options to avoid adding
- *   new netlink attributes. You can look at ``enum br_boolopt_id`` for those
- *   options.
- *
- * @IFLA_BR_MCAST_QUERIER_STATE
- *   Bridge mcast querier states, read only.
- *
- * @IFLA_BR_FDB_N_LEARNED
- *   The number of dynamically learned FDB entries for the current bridge,
- *   read only.
- *
- * @IFLA_BR_FDB_MAX_LEARNED
- *   Set the number of max dynamically learned FDB entries for the current
- *   bridge.
- */
 enum {
 	IFLA_BR_UNSPEC,
 	IFLA_BR_FORWARD_DELAY,
@@ -791,8 +510,6 @@ enum {
 	IFLA_BR_VLAN_STATS_PER_PORT,
 	IFLA_BR_MULTI_BOOLOPT,
 	IFLA_BR_MCAST_QUERIER_STATE,
-	IFLA_BR_FDB_N_LEARNED,
-	IFLA_BR_FDB_MAX_LEARNED,
 	__IFLA_BR_MAX,
 };
 
@@ -803,252 +520,11 @@ struct ifla_bridge_id {
 	__u8	addr[6]; /* ETH_ALEN */
 };
 
-/**
- * DOC: Bridge mode enum definition
- *
- * @BRIDGE_MODE_HAIRPIN
- *   Controls whether traffic may be sent back out of the port on which it
- *   was received. This option is also called reflective relay mode, and is
- *   used to support basic VEPA (Virtual Ethernet Port Aggregator)
- *   capabilities. By default, this flag is turned off and the bridge will
- *   not forward traffic back out of the receiving port.
- */
 enum {
 	BRIDGE_MODE_UNSPEC,
 	BRIDGE_MODE_HAIRPIN,
 };
 
-/**
- * DOC: Bridge port enum definition
- *
- * @IFLA_BRPORT_STATE
- *   The operation state of the port. Here are the valid values.
- *
- *     * 0 - port is in STP *DISABLED* state. Make this port completely
- *       inactive for STP. This is also called BPDU filter and could be used
- *       to disable STP on an untrusted port, like a leaf virtual device.
- *       The traffic forwarding is also stopped on this port.
- *     * 1 - port is in STP *LISTENING* state. Only valid if STP is enabled
- *       on the bridge. In this state the port listens for STP BPDUs and
- *       drops all other traffic frames.
- *     * 2 - port is in STP *LEARNING* state. Only valid if STP is enabled on
- *       the bridge. In this state the port will accept traffic only for the
- *       purpose of updating MAC address tables.
- *     * 3 - port is in STP *FORWARDING* state. Port is fully active.
- *     * 4 - port is in STP *BLOCKING* state. Only valid if STP is enabled on
- *       the bridge. This state is used during the STP election process.
- *       In this state, port will only process STP BPDUs.
- *
- * @IFLA_BRPORT_PRIORITY
- *   The STP port priority. The valid values are between 0 and 255.
- *
- * @IFLA_BRPORT_COST
- *   The STP path cost of the port. The valid values are between 1 and 65535.
- *
- * @IFLA_BRPORT_MODE
- *   Set the bridge port mode. See *BRIDGE_MODE_HAIRPIN* for more details.
- *
- * @IFLA_BRPORT_GUARD
- *   Controls whether STP BPDUs will be processed by the bridge port. By
- *   default, the flag is turned off to allow BPDU processing. Turning this
- *   flag on will disable the bridge port if a STP BPDU packet is received.
- *
- *   If the bridge has Spanning Tree enabled, hostile devices on the network
- *   may send BPDU on a port and cause network failure. Setting *guard on*
- *   will detect and stop this by disabling the port. The port will be
- *   restarted if the link is brought down, or removed and reattached.
- *
- * @IFLA_BRPORT_PROTECT
- *   Controls whether a given port is allowed to become a root port or not.
- *   Only used when STP is enabled on the bridge. By default the flag is off.
- *
- *   This feature is also called root port guard. If BPDU is received from a
- *   leaf (edge) port, it should not be elected as root port. This could
- *   be used if using STP on a bridge and the downstream bridges are not fully
- *   trusted; this prevents a hostile guest from rerouting traffic.
- *
- * @IFLA_BRPORT_FAST_LEAVE
- *   This flag allows the bridge to immediately stop multicast traffic
- *   forwarding on a port that receives an IGMP Leave message. It is only used
- *   when IGMP snooping is enabled on the bridge. By default the flag is off.
- *
- * @IFLA_BRPORT_LEARNING
- *   Controls whether a given port will learn *source* MAC addresses from
- *   received traffic or not. Also controls whether dynamic FDB entries
- *   (which can also be added by software) will be refreshed by incoming
- *   traffic. By default this flag is on.
- *
- * @IFLA_BRPORT_UNICAST_FLOOD
- *   Controls whether unicast traffic for which there is no FDB entry will
- *   be flooded towards this port. By default this flag is on.
- *
- * @IFLA_BRPORT_PROXYARP
- *   Enable proxy ARP on this port.
- *
- * @IFLA_BRPORT_LEARNING_SYNC
- *   Controls whether a given port will sync MAC addresses learned on device
- *   port to bridge FDB.
- *
- * @IFLA_BRPORT_PROXYARP_WIFI
- *   Enable proxy ARP on this port which meets extended requirements by
- *   IEEE 802.11 and Hotspot 2.0 specifications.
- *
- * @IFLA_BRPORT_ROOT_ID
- *
- * @IFLA_BRPORT_BRIDGE_ID
- *
- * @IFLA_BRPORT_DESIGNATED_PORT
- *
- * @IFLA_BRPORT_DESIGNATED_COST
- *
- * @IFLA_BRPORT_ID
- *
- * @IFLA_BRPORT_NO
- *
- * @IFLA_BRPORT_TOPOLOGY_CHANGE_ACK
- *
- * @IFLA_BRPORT_CONFIG_PENDING
- *
- * @IFLA_BRPORT_MESSAGE_AGE_TIMER
- *
- * @IFLA_BRPORT_FORWARD_DELAY_TIMER
- *
- * @IFLA_BRPORT_HOLD_TIMER
- *
- * @IFLA_BRPORT_FLUSH
- *   Flush bridge ports' fdb dynamic entries.
- *
- * @IFLA_BRPORT_MULTICAST_ROUTER
- *   Configure the port's multicast router presence. A port with
- *   a multicast router will receive all multicast traffic.
- *   The valid values are:
- *
- *     * 0 disable multicast routers on this port
- *     * 1 let the system detect the presence of routers (default)
- *     * 2 permanently enable multicast traffic forwarding on this port
- *     * 3 enable multicast routers temporarily on this port, not depending
- *         on incoming queries.
- *
- * @IFLA_BRPORT_PAD
- *
- * @IFLA_BRPORT_MCAST_FLOOD
- *   Controls whether a given port will flood multicast traffic for which
- *   there is no MDB entry. By default this flag is on.
- *
- * @IFLA_BRPORT_MCAST_TO_UCAST
- *   Controls whether a given port will replicate packets using unicast
- *   instead of multicast. By default this flag is off.
- *
- *   This is done by copying the packet per host and changing the multicast
- *   destination MAC to a unicast one accordingly.
- *
- *   *mcast_to_unicast* works on top of the multicast snooping feature of the
- *   bridge. Which means unicast copies are only delivered to hosts which
- *   are interested in unicast and signaled this via IGMP/MLD reports previously.
- *
- *   This feature is intended for interface types which have a more reliable
- *   and/or efficient way to deliver unicast packets than broadcast ones
- *   (e.g. WiFi).
- *
- *   However, it should only be enabled on interfaces where no IGMPv2/MLDv1
- *   report suppression takes place. IGMP/MLD report suppression issue is
- *   usually overcome by the network daemon (supplicant) enabling AP isolation
- *   and by that separating all STAs.
- *
- *   Delivery of STA-to-STA IP multicast is made possible again by enabling
- *   and utilizing the bridge hairpin mode, which considers the incoming port
- *   as a potential outgoing port, too (see *BRIDGE_MODE_HAIRPIN* option).
- *   Hairpin mode is performed after multicast snooping, therefore leading
- *   to only deliver reports to STAs running a multicast router.
- *
- * @IFLA_BRPORT_VLAN_TUNNEL
- *   Controls whether vlan to tunnel mapping is enabled on the port.
- *   By default this flag is off.
- *
- * @IFLA_BRPORT_BCAST_FLOOD
- *   Controls flooding of broadcast traffic on the given port. By default
- *   this flag is on.
- *
- * @IFLA_BRPORT_GROUP_FWD_MASK
- *   Set the group forward mask. This is a bitmask that is applied to
- *   decide whether to forward incoming frames destined to link-local
- *   addresses. The addresses of the form are 01:80:C2:00:00:0X (defaults
- *   to 0, which means the bridge does not forward any link-local frames
- *   coming on this port).
- *
- * @IFLA_BRPORT_NEIGH_SUPPRESS
- *   Controls whether neighbor discovery (arp and nd) proxy and suppression
- *   is enabled on the port. By default this flag is off.
- *
- * @IFLA_BRPORT_ISOLATED
- *   Controls whether a given port will be isolated, which means it will be
- *   able to communicate with non-isolated ports only. By default this
- *   flag is off.
- *
- * @IFLA_BRPORT_BACKUP_PORT
- *   Set a backup port. If the port loses carrier all traffic will be
- *   redirected to the configured backup port. Set the value to 0 to disable
- *   it.
- *
- * @IFLA_BRPORT_MRP_RING_OPEN
- *
- * @IFLA_BRPORT_MRP_IN_OPEN
- *
- * @IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT
- *   The number of per-port EHT hosts limit. The default value is 512.
- *   Setting to 0 is not allowed.
- *
- * @IFLA_BRPORT_MCAST_EHT_HOSTS_CNT
- *   The current number of tracked hosts, read only.
- *
- * @IFLA_BRPORT_LOCKED
- *   Controls whether a port will be locked, meaning that hosts behind the
- *   port will not be able to communicate through the port unless an FDB
- *   entry with the unit's MAC address is in the FDB. The common use case is
- *   that hosts are allowed access through authentication with the IEEE 802.1X
- *   protocol or based on whitelists. By default this flag is off.
- *
- *   Please note that secure 802.1X deployments should always use the
- *   *BR_BOOLOPT_NO_LL_LEARN* flag, to not permit the bridge to populate its
- *   FDB based on link-local (EAPOL) traffic received on the port.
- *
- * @IFLA_BRPORT_MAB
- *   Controls whether a port will use MAC Authentication Bypass (MAB), a
- *   technique through which select MAC addresses may be allowed on a locked
- *   port, without using 802.1X authentication. Packets with an unknown source
- *   MAC address generates a "locked" FDB entry on the incoming bridge port.
- *   The common use case is for user space to react to these bridge FDB
- *   notifications and optionally replace the locked FDB entry with a normal
- *   one, allowing traffic to pass for whitelisted MAC addresses.
- *
- *   Setting this flag also requires *IFLA_BRPORT_LOCKED* and
- *   *IFLA_BRPORT_LEARNING*. *IFLA_BRPORT_LOCKED* ensures that unauthorized
- *   data packets are dropped, and *IFLA_BRPORT_LEARNING* allows the dynamic
- *   FDB entries installed by user space (as replacements for the locked FDB
- *   entries) to be refreshed and/or aged out.
- *
- * @IFLA_BRPORT_MCAST_N_GROUPS
- *
- * @IFLA_BRPORT_MCAST_MAX_GROUPS
- *   Sets the maximum number of MDB entries that can be registered for a
- *   given port. Attempts to register more MDB entries at the port than this
- *   limit allows will be rejected, whether they are done through netlink
- *   (e.g. the bridge tool), or IGMP or MLD membership reports. Setting a
- *   limit of 0 disables the limit. The default value is 0.
- *
- * @IFLA_BRPORT_NEIGH_VLAN_SUPPRESS
- *   Controls whether neighbor discovery (arp and nd) proxy and suppression is
- *   enabled for a given port. By default this flag is off.
- *
- *   Note that this option only takes effect when *IFLA_BRPORT_NEIGH_SUPPRESS*
- *   is enabled for a given port.
- *
- * @IFLA_BRPORT_BACKUP_NHID
- *   The FDB nexthop object ID to attach to packets being redirected to a
- *   backup port that has VLAN tunnel mapping enabled (via the
- *   *IFLA_BRPORT_VLAN_TUNNEL* option). Setting a value of 0 (default) has
- *   the effect of not attaching any ID.
- */
 enum {
 	IFLA_BRPORT_UNSPEC,
 	IFLA_BRPORT_STATE,	/* Spanning tree state     */
@@ -1293,19 +769,6 @@ enum netkit_mode {
 	NETKIT_L3,
 };
 
-/* NETKIT_SCRUB_NONE leaves clearing skb->{mark,priority} up to
- * the BPF program if attached. This also means the latter can
- * consume the two fields if they were populated earlier.
- *
- * NETKIT_SCRUB_DEFAULT zeroes skb->{mark,priority} fields before
- * invoking the attached BPF program when the peer device resides
- * in a different network namespace. This is the default behavior.
- */
-enum netkit_scrub {
-	NETKIT_SCRUB_NONE,
-	NETKIT_SCRUB_DEFAULT,
-};
-
 enum {
 	IFLA_NETKIT_UNSPEC,
 	IFLA_NETKIT_PEER_INFO,
@@ -1313,10 +776,6 @@ enum {
 	IFLA_NETKIT_POLICY,
 	IFLA_NETKIT_PEER_POLICY,
 	IFLA_NETKIT_MODE,
-	IFLA_NETKIT_SCRUB,
-	IFLA_NETKIT_PEER_SCRUB,
-	IFLA_NETKIT_HEADROOM,
-	IFLA_NETKIT_TAILROOM,
 	__IFLA_NETKIT_MAX,
 };
 #define IFLA_NETKIT_MAX	(__IFLA_NETKIT_MAX - 1)
@@ -1395,7 +854,6 @@ enum {
 	IFLA_VXLAN_DF,
 	IFLA_VXLAN_VNIFILTER, /* only applicable with COLLECT_METADATA mode */
 	IFLA_VXLAN_LOCALBYPASS,
-	IFLA_VXLAN_LABEL_POLICY, /* IPv6 flow label policy; ifla_vxlan_label_policy */
 	__IFLA_VXLAN_MAX
 };
 #define IFLA_VXLAN_MAX	(__IFLA_VXLAN_MAX - 1)
@@ -1413,13 +871,6 @@ enum ifla_vxlan_df {
 	VXLAN_DF_MAX = __VXLAN_DF_END - 1,
 };
 
-enum ifla_vxlan_label_policy {
-	VXLAN_LABEL_FIXED = 0,
-	VXLAN_LABEL_INHERIT = 1,
-	__VXLAN_LABEL_END,
-	VXLAN_LABEL_MAX = __VXLAN_LABEL_END - 1,
-};
-
 /* GENEVE section */
 enum {
 	IFLA_GENEVE_UNSPEC,
@@ -1484,8 +935,6 @@ enum {
 	IFLA_GTP_ROLE,
 	IFLA_GTP_CREATE_SOCKETS,
 	IFLA_GTP_RESTART_COUNT,
-	IFLA_GTP_LOCAL,
-	IFLA_GTP_LOCAL6,
 	__IFLA_GTP_MAX,
 };
 #define IFLA_GTP_MAX (__IFLA_GTP_MAX - 1)
@@ -1791,7 +1240,6 @@ enum {
 	IFLA_HSR_PROTOCOL,		/* Indicate different protocol than
 					 * HSR. For example PRP.
 					 */
-	IFLA_HSR_INTERLINK,		/* HSR interlink network device */
 	__IFLA_HSR_MAX,
 };
 
@@ -1969,9 +1417,7 @@ enum {
 
 enum {
 	IFLA_DSA_UNSPEC,
-	IFLA_DSA_CONDUIT,
-	/* Deprecated, use IFLA_DSA_CONDUIT instead */
-	IFLA_DSA_MASTER = IFLA_DSA_CONDUIT,
+	IFLA_DSA_MASTER,
 	__IFLA_DSA_MAX,
 };
 

include/uapi/linux/if_xdp.h

@@ -117,22 +117,16 @@ struct xdp_options {
 	((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1)
 
 /* Request transmit timestamp. Upon completion, put it into tx_timestamp
- * field of struct xsk_tx_metadata.
+ * 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 struct
+ * are communicated via csum_start and csum_offset fields of union
  * xsk_tx_metadata.
  */
 #define XDP_TXMD_FLAGS_CHECKSUM			(1 << 1)
 
-/* Request launch time hardware offload. The device will schedule the packet for
- * transmission at a pre-determined time called launch time. The value of
- * launch time is communicated via launch_time field of struct xsk_tx_metadata.
- */
-#define XDP_TXMD_FLAGS_LAUNCH_TIME		(1 << 2)
-
 /* 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.
@@ -148,10 +142,6 @@ struct xsk_tx_metadata {
 			__u16 csum_start;
 			/* Offset from csum_start where checksum should be stored. */
 			__u16 csum_offset;
-
-			/* XDP_TXMD_FLAGS_LAUNCH_TIME */
-			/* Launch time in nanosecond against the PTP HW Clock */
-			__u64 launch_time;
 		} request;
 
 		struct {

include/uapi/linux/netdev.h

@@ -59,13 +59,10 @@ enum netdev_xdp_rx_metadata {
  *   by the driver.
  * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the
  *   driver.
- * @NETDEV_XSK_FLAGS_TX_LAUNCH_TIME_FIFO: Launch time HW offload is supported
- *   by the driver.
  */
 enum netdev_xsk_flags {
 	NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1,
 	NETDEV_XSK_FLAGS_TX_CHECKSUM = 2,
-	NETDEV_XSK_FLAGS_TX_LAUNCH_TIME_FIFO = 4,
 };
 
 enum netdev_queue_type {
@@ -89,11 +86,6 @@ enum {
 	NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1)
 };
 
-enum {
-	__NETDEV_A_IO_URING_PROVIDER_INFO_MAX,
-	NETDEV_A_IO_URING_PROVIDER_INFO_MAX = (__NETDEV_A_IO_URING_PROVIDER_INFO_MAX - 1)
-};
-
 enum {
 	NETDEV_A_PAGE_POOL_ID = 1,
 	NETDEV_A_PAGE_POOL_IFINDEX,
@@ -102,7 +94,6 @@ enum {
 	NETDEV_A_PAGE_POOL_INFLIGHT_MEM,
 	NETDEV_A_PAGE_POOL_DETACH_TIME,
 	NETDEV_A_PAGE_POOL_DMABUF,
-	NETDEV_A_PAGE_POOL_IO_URING,
 
 	__NETDEV_A_PAGE_POOL_MAX,
 	NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1)
@@ -131,27 +122,17 @@ enum {
 	NETDEV_A_NAPI_ID,
 	NETDEV_A_NAPI_IRQ,
 	NETDEV_A_NAPI_PID,
-	NETDEV_A_NAPI_DEFER_HARD_IRQS,
-	NETDEV_A_NAPI_GRO_FLUSH_TIMEOUT,
-	NETDEV_A_NAPI_IRQ_SUSPEND_TIMEOUT,
 
 	__NETDEV_A_NAPI_MAX,
 	NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1)
 };
 
-enum {
-	__NETDEV_A_XSK_INFO_MAX,
-	NETDEV_A_XSK_INFO_MAX = (__NETDEV_A_XSK_INFO_MAX - 1)
-};
-
 enum {
 	NETDEV_A_QUEUE_ID = 1,
 	NETDEV_A_QUEUE_IFINDEX,
 	NETDEV_A_QUEUE_TYPE,
 	NETDEV_A_QUEUE_NAPI_ID,
 	NETDEV_A_QUEUE_DMABUF,
-	NETDEV_A_QUEUE_IO_URING,
-	NETDEV_A_QUEUE_XSK,
 
 	__NETDEV_A_QUEUE_MAX,
 	NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1)
@@ -218,7 +199,6 @@ enum {
 	NETDEV_CMD_NAPI_GET,
 	NETDEV_CMD_QSTATS_GET,
 	NETDEV_CMD_BIND_RX,
-	NETDEV_CMD_NAPI_SET,
 
 	__NETDEV_CMD_MAX,
 	NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1)

include/uapi/linux/perf_event.h

@@ -385,8 +385,6 @@ enum perf_event_read_format {
  *
  * @sample_max_stack: Max number of frame pointers in a callchain,
  *		      should be < /proc/sys/kernel/perf_event_max_stack
- *		      Max number of entries of branch stack
- *		      should be < hardware limit
  */
 struct perf_event_attr {
 
@@ -513,16 +511,7 @@ struct perf_event_attr {
 	__u16	sample_max_stack;
 	__u16	__reserved_2;
 	__u32	aux_sample_size;
-
-	union {
-		__u32	aux_action;
-		struct {
-			__u32	aux_start_paused :  1, /* start AUX area tracing paused */
-				aux_pause        :  1, /* on overflow, pause AUX area tracing */
-				aux_resume       :  1, /* on overflow, resume AUX area tracing */
-				__reserved_3     : 29;
-		};
-	};
+	__u32	__reserved_3;
 
 	/*
 	 * User provided data if sigtrap=1, passed back to user via

src/Makefile

@@ -9,7 +9,7 @@ else
 endif
 
 LIBBPF_MAJOR_VERSION := 1
-LIBBPF_MINOR_VERSION := 6
+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
@@ -26,7 +26,6 @@ endef
 
 $(call allow-override,CC,$(CROSS_COMPILE)cc)
 $(call allow-override,LD,$(CROSS_COMPILE)ld)
-PKG_CONFIG ?= pkg-config
 
 TOPDIR = ..
 
@@ -42,12 +41,10 @@ ALL_CFLAGS += $(CFLAGS) 						\
 	      $(EXTRA_CFLAGS)
 ALL_LDFLAGS += $(LDFLAGS) $(EXTRA_LDFLAGS)
 
-ifeq ($(shell command -v $(PKG_CONFIG) 2> /dev/null),)
-NO_PKG_CONFIG := 1
-endif
 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)
 endif

src/bpf.c

@@ -238,7 +238,7 @@ int bpf_prog_load(enum bpf_prog_type prog_type,
 		  const struct bpf_insn *insns, size_t insn_cnt,
 		  struct bpf_prog_load_opts *opts)
 {
-	const size_t attr_sz = offsetofend(union bpf_attr, fd_array_cnt);
+	const size_t attr_sz = offsetofend(union bpf_attr, prog_token_fd);
 	void *finfo = NULL, *linfo = NULL;
 	const char *func_info, *line_info;
 	__u32 log_size, log_level, attach_prog_fd, attach_btf_obj_fd;
@@ -311,7 +311,6 @@ int bpf_prog_load(enum bpf_prog_type prog_type,
 	attr.line_info_cnt = OPTS_GET(opts, line_info_cnt, 0);
 
 	attr.fd_array = ptr_to_u64(OPTS_GET(opts, fd_array, NULL));
-	attr.fd_array_cnt = OPTS_GET(opts, fd_array_cnt, 0);
 
 	if (log_level) {
 		attr.log_buf = ptr_to_u64(log_buf);
@@ -777,7 +776,6 @@ int bpf_link_create(int prog_fd, int target_fd,
 			return libbpf_err(-EINVAL);
 		break;
 	case BPF_TRACE_UPROBE_MULTI:
-	case BPF_TRACE_UPROBE_SESSION:
 		attr.link_create.uprobe_multi.flags = OPTS_GET(opts, uprobe_multi.flags, 0);
 		attr.link_create.uprobe_multi.cnt = OPTS_GET(opts, uprobe_multi.cnt, 0);
 		attr.link_create.uprobe_multi.path = ptr_to_u64(OPTS_GET(opts, uprobe_multi.path, 0));
@@ -1097,7 +1095,7 @@ int bpf_map_get_fd_by_id(__u32 id)
 int bpf_btf_get_fd_by_id_opts(__u32 id,
 			      const struct bpf_get_fd_by_id_opts *opts)
 {
-	const size_t attr_sz = offsetofend(union bpf_attr, fd_by_id_token_fd);
+	const size_t attr_sz = offsetofend(union bpf_attr, open_flags);
 	union bpf_attr attr;
 	int fd;
 
@@ -1107,7 +1105,6 @@ int bpf_btf_get_fd_by_id_opts(__u32 id,
 	memset(&attr, 0, attr_sz);
 	attr.btf_id = id;
 	attr.open_flags = OPTS_GET(opts, open_flags, 0);
-	attr.fd_by_id_token_fd = OPTS_GET(opts, token_fd, 0);
 
 	fd = sys_bpf_fd(BPF_BTF_GET_FD_BY_ID, &attr, attr_sz);
 	return libbpf_err_errno(fd);

src/bpf.h

@@ -107,12 +107,9 @@ struct bpf_prog_load_opts {
 	 */
 	__u32 log_true_size;
 	__u32 token_fd;
-
-	/* if set, provides the length of fd_array */
-	__u32 fd_array_cnt;
 	size_t :0;
 };
-#define bpf_prog_load_opts__last_field fd_array_cnt
+#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,
@@ -487,10 +484,9 @@ 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 */
-	__u32 token_fd;
 	size_t :0;
 };
-#define bpf_get_fd_by_id_opts__last_field token_fd
+#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,

src/bpf_core_read.h

@@ -388,13 +388,7 @@ extern void *bpf_rdonly_cast(const void *obj, __u32 btf_id) __ksym __weak;
 #define ___arrow10(a, b, c, d, e, f, g, h, i, j) a->b->c->d->e->f->g->h->i->j
 #define ___arrow(...) ___apply(___arrow, ___narg(__VA_ARGS__))(__VA_ARGS__)
 
-#if defined(__clang__) && (__clang_major__ >= 19)
-#define ___type(...) __typeof_unqual__(___arrow(__VA_ARGS__))
-#elif defined(__GNUC__) && (__GNUC__ >= 14)
-#define ___type(...) __typeof_unqual__(___arrow(__VA_ARGS__))
-#else
 #define ___type(...) typeof(___arrow(__VA_ARGS__))
-#endif
 
 #define ___read(read_fn, dst, src_type, src, accessor)			    \
 	read_fn((void *)(dst), sizeof(*(dst)), &((src_type)(src))->accessor)

src/bpf_helper_defs.h

@@ -217,15 +217,11 @@ static __bpf_fastcall __u32 (* const bpf_get_smp_processor_id)(void) = (void *)
  * bpf_skb_store_bytes
  *
  * 	Store *len* bytes from address *from* into the packet
- * 	associated to *skb*, at *offset*. The *flags* are a combination
- * 	of the following values:
- *
- * 	**BPF_F_RECOMPUTE_CSUM**
- * 		Automatically update *skb*\ **->csum** after storing the
- * 		bytes.
- * 	**BPF_F_INVALIDATE_HASH**
- * 		Set *skb*\ **->hash**, *skb*\ **->swhash** and *skb*\
- * 		**->l4hash** to 0.
+ * 	associated to *skb*, at *offset*. *flags* are a combination of
+ * 	**BPF_F_RECOMPUTE_CSUM** (automatically recompute the
+ * 	checksum for the packet after storing the bytes) and
+ * 	**BPF_F_INVALIDATE_HASH** (set *skb*\ **->hash**, *skb*\
+ * 	**->swhash** and *skb*\ **->l4hash** to 0).
  *
  * 	A call to this helper is susceptible to change the underlying
  * 	packet buffer. Therefore, at load time, all checks on pointers
@@ -285,7 +281,7 @@ static long (* const bpf_l3_csum_replace)(struct __sk_buff *skb, __u32 offset, _
  * 	untouched (unless **BPF_F_MARK_ENFORCE** is added as well), and
  * 	for updates resulting in a null checksum the value is set to
  * 	**CSUM_MANGLED_0** instead. Flag **BPF_F_PSEUDO_HDR** indicates
- * 	that the modified header field is part of the pseudo-header.
+ * 	the checksum is to be computed against a pseudo-header.
  *
  * 	This helper works in combination with **bpf_csum_diff**\ (),
  * 	which does not update the checksum in-place, but offers more

src/bpf_helpers.h

@@ -15,14 +15,6 @@
 #define __array(name, val) typeof(val) *name[]
 #define __ulong(name, val) enum { ___bpf_concat(__unique_value, __COUNTER__) = val } name
 
-#ifndef likely
-#define likely(x)      (__builtin_expect(!!(x), 1))
-#endif
-
-#ifndef unlikely
-#define unlikely(x)    (__builtin_expect(!!(x), 0))
-#endif
-
 /*
  * Helper macro to place programs, maps, license in
  * different sections in elf_bpf file. Section names

src/btf.c

@@ -22,7 +22,6 @@
 #include "libbpf_internal.h"
 #include "hashmap.h"
 #include "strset.h"
-#include "str_error.h"
 
 #define BTF_MAX_NR_TYPES 0x7fffffffU
 #define BTF_MAX_STR_OFFSET 0x7fffffffU
@@ -283,7 +282,7 @@ static int btf_parse_str_sec(struct btf *btf)
 		return -EINVAL;
 	}
 	if (!btf->base_btf && start[0]) {
-		pr_debug("Malformed BTF string section, did you forget to provide base BTF?\n");
+		pr_debug("Invalid BTF string section\n");
 		return -EINVAL;
 	}
 	return 0;
@@ -1148,12 +1147,6 @@ static int btf_find_elf_sections(Elf *elf, const char *path, struct btf_elf_secs
 		else
 			continue;
 
-		if (sh.sh_type != SHT_PROGBITS) {
-			pr_warn("unexpected section type (%d) of section(%d, %s) from %s\n",
-				sh.sh_type, idx, name, path);
-			goto err;
-		}
-
 		data = elf_getdata(scn, 0);
 		if (!data) {
 			pr_warn("failed to get section(%d, %s) data from %s\n",
@@ -1186,13 +1179,12 @@ static struct btf *btf_parse_elf(const char *path, struct btf *base_btf,
 	fd = open(path, O_RDONLY | O_CLOEXEC);
 	if (fd < 0) {
 		err = -errno;
-		pr_warn("failed to open %s: %s\n", path, errstr(err));
+		pr_warn("failed to open %s: %s\n", path, strerror(errno));
 		return ERR_PTR(err);
 	}
 
 	elf = elf_begin(fd, ELF_C_READ, NULL);
 	if (!elf) {
-		err = -LIBBPF_ERRNO__FORMAT;
 		pr_warn("failed to open %s as ELF file\n", path);
 		goto done;
 	}
@@ -1453,7 +1445,7 @@ retry_load:
 			goto retry_load;
 
 		err = -errno;
-		pr_warn("BTF loading error: %s\n", errstr(err));
+		pr_warn("BTF loading error: %d\n", err);
 		/* don't print out contents of custom log_buf */
 		if (!log_buf && buf[0])
 			pr_warn("-- BEGIN BTF LOAD LOG ---\n%s\n-- END BTF LOAD LOG --\n", buf);
@@ -1625,18 +1617,12 @@ exit_free:
 	return btf;
 }
 
-struct btf *btf_load_from_kernel(__u32 id, struct btf *base_btf, int token_fd)
+struct btf *btf__load_from_kernel_by_id_split(__u32 id, struct btf *base_btf)
 {
 	struct btf *btf;
 	int btf_fd;
-	LIBBPF_OPTS(bpf_get_fd_by_id_opts, opts);
 
-	if (token_fd) {
-		opts.open_flags |= BPF_F_TOKEN_FD;
-		opts.token_fd = token_fd;
-	}
-
-	btf_fd = bpf_btf_get_fd_by_id_opts(id, &opts);
+	btf_fd = bpf_btf_get_fd_by_id(id);
 	if (btf_fd < 0)
 		return libbpf_err_ptr(-errno);
 
@@ -1646,11 +1632,6 @@ struct btf *btf_load_from_kernel(__u32 id, struct btf *base_btf, int token_fd)
 	return libbpf_ptr(btf);
 }
 
-struct btf *btf__load_from_kernel_by_id_split(__u32 id, struct btf *base_btf)
-{
-	return btf_load_from_kernel(id, base_btf, 0);
-}
-
 struct btf *btf__load_from_kernel_by_id(__u32 id)
 {
 	return btf__load_from_kernel_by_id_split(id, NULL);
@@ -2107,7 +2088,7 @@ static int validate_type_id(int id)
 }
 
 /* generic append function for PTR, TYPEDEF, CONST/VOLATILE/RESTRICT */
-static int btf_add_ref_kind(struct btf *btf, int kind, const char *name, int ref_type_id, int kflag)
+static int btf_add_ref_kind(struct btf *btf, int kind, const char *name, int ref_type_id)
 {
 	struct btf_type *t;
 	int sz, name_off = 0;
@@ -2130,7 +2111,7 @@ static int btf_add_ref_kind(struct btf *btf, int kind, const char *name, int ref
 	}
 
 	t->name_off = name_off;
-	t->info = btf_type_info(kind, 0, kflag);
+	t->info = btf_type_info(kind, 0, 0);
 	t->type = ref_type_id;
 
 	return btf_commit_type(btf, sz);
@@ -2145,7 +2126,7 @@ static int btf_add_ref_kind(struct btf *btf, int kind, const char *name, int ref
  */
 int btf__add_ptr(struct btf *btf, int ref_type_id)
 {
-	return btf_add_ref_kind(btf, BTF_KIND_PTR, NULL, ref_type_id, 0);
+	return btf_add_ref_kind(btf, BTF_KIND_PTR, NULL, ref_type_id);
 }
 
 /*
@@ -2523,7 +2504,7 @@ int btf__add_fwd(struct btf *btf, const char *name, enum btf_fwd_kind fwd_kind)
 		struct btf_type *t;
 		int id;
 
-		id = btf_add_ref_kind(btf, BTF_KIND_FWD, name, 0, 0);
+		id = btf_add_ref_kind(btf, BTF_KIND_FWD, name, 0);
 		if (id <= 0)
 			return id;
 		t = btf_type_by_id(btf, id);
@@ -2553,7 +2534,7 @@ int btf__add_typedef(struct btf *btf, const char *name, int ref_type_id)
 	if (!name || !name[0])
 		return libbpf_err(-EINVAL);
 
-	return btf_add_ref_kind(btf, BTF_KIND_TYPEDEF, name, ref_type_id, 0);
+	return btf_add_ref_kind(btf, BTF_KIND_TYPEDEF, name, ref_type_id);
 }
 
 /*
@@ -2565,7 +2546,7 @@ int btf__add_typedef(struct btf *btf, const char *name, int ref_type_id)
  */
 int btf__add_volatile(struct btf *btf, int ref_type_id)
 {
-	return btf_add_ref_kind(btf, BTF_KIND_VOLATILE, NULL, ref_type_id, 0);
+	return btf_add_ref_kind(btf, BTF_KIND_VOLATILE, NULL, ref_type_id);
 }
 
 /*
@@ -2577,7 +2558,7 @@ int btf__add_volatile(struct btf *btf, int ref_type_id)
  */
 int btf__add_const(struct btf *btf, int ref_type_id)
 {
-	return btf_add_ref_kind(btf, BTF_KIND_CONST, NULL, ref_type_id, 0);
+	return btf_add_ref_kind(btf, BTF_KIND_CONST, NULL, ref_type_id);
 }
 
 /*
@@ -2589,7 +2570,7 @@ int btf__add_const(struct btf *btf, int ref_type_id)
  */
 int btf__add_restrict(struct btf *btf, int ref_type_id)
 {
-	return btf_add_ref_kind(btf, BTF_KIND_RESTRICT, NULL, ref_type_id, 0);
+	return btf_add_ref_kind(btf, BTF_KIND_RESTRICT, NULL, ref_type_id);
 }
 
 /*
@@ -2605,24 +2586,7 @@ int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id)
 	if (!value || !value[0])
 		return libbpf_err(-EINVAL);
 
-	return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id, 0);
-}
-
-/*
- * Append new BTF_KIND_TYPE_TAG type with:
- *   - *value*, non-empty/non-NULL tag value;
- *   - *ref_type_id* - referenced type ID, it might not exist yet;
- * Set info->kflag to 1, indicating this tag is an __attribute__
- * Returns:
- *   - >0, type ID of newly added BTF type;
- *   - <0, on error.
- */
-int btf__add_type_attr(struct btf *btf, const char *value, int ref_type_id)
-{
-	if (!value || !value[0])
-		return libbpf_err(-EINVAL);
-
-	return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id, 1);
+	return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id);
 }
 
 /*
@@ -2644,7 +2608,7 @@ int btf__add_func(struct btf *btf, const char *name,
 	    linkage != BTF_FUNC_EXTERN)
 		return libbpf_err(-EINVAL);
 
-	id = btf_add_ref_kind(btf, BTF_KIND_FUNC, name, proto_type_id, 0);
+	id = btf_add_ref_kind(btf, BTF_KIND_FUNC, name, proto_type_id);
 	if (id > 0) {
 		struct btf_type *t = btf_type_by_id(btf, id);
 
@@ -2879,8 +2843,18 @@ int btf__add_datasec_var_info(struct btf *btf, int var_type_id, __u32 offset, __
 	return 0;
 }
 
-static int btf_add_decl_tag(struct btf *btf, const char *value, int ref_type_id,
-			    int component_idx, int kflag)
+/*
+ * Append new BTF_KIND_DECL_TAG type with:
+ *   - *value* - non-empty/non-NULL string;
+ *   - *ref_type_id* - referenced type ID, it might not exist yet;
+ *   - *component_idx* - -1 for tagging reference type, otherwise struct/union
+ *     member or function argument index;
+ * Returns:
+ *   - >0, type ID of newly added BTF type;
+ *   - <0, on error.
+ */
+int btf__add_decl_tag(struct btf *btf, const char *value, int ref_type_id,
+		 int component_idx)
 {
 	struct btf_type *t;
 	int sz, value_off;
@@ -2904,46 +2878,13 @@ static int btf_add_decl_tag(struct btf *btf, const char *value, int ref_type_id,
 		return value_off;
 
 	t->name_off = value_off;
-	t->info = btf_type_info(BTF_KIND_DECL_TAG, 0, kflag);
+	t->info = btf_type_info(BTF_KIND_DECL_TAG, 0, false);
 	t->type = ref_type_id;
 	btf_decl_tag(t)->component_idx = component_idx;
 
 	return btf_commit_type(btf, sz);
 }
 
-/*
- * Append new BTF_KIND_DECL_TAG type with:
- *   - *value* - non-empty/non-NULL string;
- *   - *ref_type_id* - referenced type ID, it might not exist yet;
- *   - *component_idx* - -1 for tagging reference type, otherwise struct/union
- *     member or function argument index;
- * Returns:
- *   - >0, type ID of newly added BTF type;
- *   - <0, on error.
- */
-int btf__add_decl_tag(struct btf *btf, const char *value, int ref_type_id,
-		      int component_idx)
-{
-	return btf_add_decl_tag(btf, value, ref_type_id, component_idx, 0);
-}
-
-/*
- * Append new BTF_KIND_DECL_TAG type with:
- *   - *value* - non-empty/non-NULL string;
- *   - *ref_type_id* - referenced type ID, it might not exist yet;
- *   - *component_idx* - -1 for tagging reference type, otherwise struct/union
- *     member or function argument index;
- * Set info->kflag to 1, indicating this tag is an __attribute__
- * Returns:
- *   - >0, type ID of newly added BTF type;
- *   - <0, on error.
- */
-int btf__add_decl_attr(struct btf *btf, const char *value, int ref_type_id,
-		       int component_idx)
-{
-	return btf_add_decl_tag(btf, value, ref_type_id, component_idx, 1);
-}
-
 struct btf_ext_sec_info_param {
 	__u32 off;
 	__u32 len;
@@ -3072,6 +3013,8 @@ static int btf_ext_parse_info(struct btf_ext *btf_ext, bool is_native)
 		.desc = "line_info",
 	};
 	struct btf_ext_sec_info_param core_relo = {
+		.off = btf_ext->hdr->core_relo_off,
+		.len = btf_ext->hdr->core_relo_len,
 		.min_rec_size = sizeof(struct bpf_core_relo),
 		.ext_info = &btf_ext->core_relo_info,
 		.desc = "core_relo",
@@ -3089,8 +3032,6 @@ static int btf_ext_parse_info(struct btf_ext *btf_ext, bool is_native)
 	if (btf_ext->hdr->hdr_len < offsetofend(struct btf_ext_header, core_relo_len))
 		return 0; /* skip core relos parsing */
 
-	core_relo.off = btf_ext->hdr->core_relo_off;
-	core_relo.len = btf_ext->hdr->core_relo_len;
 	err = btf_ext_parse_sec_info(btf_ext, &core_relo, is_native);
 	if (err)
 		return err;
@@ -3523,42 +3464,42 @@ int btf__dedup(struct btf *btf, const struct btf_dedup_opts *opts)
 
 	err = btf_dedup_prep(d);
 	if (err) {
-		pr_debug("btf_dedup_prep failed: %s\n", errstr(err));
+		pr_debug("btf_dedup_prep failed:%d\n", err);
 		goto done;
 	}
 	err = btf_dedup_strings(d);
 	if (err < 0) {
-		pr_debug("btf_dedup_strings failed: %s\n", errstr(err));
+		pr_debug("btf_dedup_strings failed:%d\n", err);
 		goto done;
 	}
 	err = btf_dedup_prim_types(d);
 	if (err < 0) {
-		pr_debug("btf_dedup_prim_types failed: %s\n", errstr(err));
+		pr_debug("btf_dedup_prim_types failed:%d\n", err);
 		goto done;
 	}
 	err = btf_dedup_struct_types(d);
 	if (err < 0) {
-		pr_debug("btf_dedup_struct_types failed: %s\n", errstr(err));
+		pr_debug("btf_dedup_struct_types failed:%d\n", err);
 		goto done;
 	}
 	err = btf_dedup_resolve_fwds(d);
 	if (err < 0) {
-		pr_debug("btf_dedup_resolve_fwds failed: %s\n", errstr(err));
+		pr_debug("btf_dedup_resolve_fwds failed:%d\n", err);
 		goto done;
 	}
 	err = btf_dedup_ref_types(d);
 	if (err < 0) {
-		pr_debug("btf_dedup_ref_types failed: %s\n", errstr(err));
+		pr_debug("btf_dedup_ref_types failed:%d\n", err);
 		goto done;
 	}
 	err = btf_dedup_compact_types(d);
 	if (err < 0) {
-		pr_debug("btf_dedup_compact_types failed: %s\n", errstr(err));
+		pr_debug("btf_dedup_compact_types failed:%d\n", err);
 		goto done;
 	}
 	err = btf_dedup_remap_types(d);
 	if (err < 0) {
-		pr_debug("btf_dedup_remap_types failed: %s\n", errstr(err));
+		pr_debug("btf_dedup_remap_types failed:%d\n", err);
 		goto done;
 	}
 
@@ -3606,7 +3547,7 @@ struct btf_dedup {
 	struct strset *strs_set;
 };
 
-static unsigned long hash_combine(unsigned long h, unsigned long value)
+static long hash_combine(long h, long value)
 {
 	return h * 31 + value;
 }
@@ -4356,109 +4297,46 @@ static inline __u16 btf_fwd_kind(struct btf_type *t)
 	return btf_kflag(t) ? BTF_KIND_UNION : BTF_KIND_STRUCT;
 }
 
-static bool btf_dedup_identical_types(struct btf_dedup *d, __u32 id1, __u32 id2, int depth)
+/* Check if given two types are identical ARRAY definitions */
+static bool btf_dedup_identical_arrays(struct btf_dedup *d, __u32 id1, __u32 id2)
 {
 	struct btf_type *t1, *t2;
-	int k1, k2;
-recur:
-	if (depth <= 0)
+
+	t1 = btf_type_by_id(d->btf, id1);
+	t2 = btf_type_by_id(d->btf, id2);
+	if (!btf_is_array(t1) || !btf_is_array(t2))
 		return false;
 
+	return btf_equal_array(t1, t2);
+}
+
+/* Check if given two types are identical STRUCT/UNION definitions */
+static bool btf_dedup_identical_structs(struct btf_dedup *d, __u32 id1, __u32 id2)
+{
+	const struct btf_member *m1, *m2;
+	struct btf_type *t1, *t2;
+	int n, i;
+
 	t1 = btf_type_by_id(d->btf, id1);
 	t2 = btf_type_by_id(d->btf, id2);
 
-	k1 = btf_kind(t1);
-	k2 = btf_kind(t2);
-	if (k1 != k2)
+	if (!btf_is_composite(t1) || btf_kind(t1) != btf_kind(t2))
 		return false;
 
-	switch (k1) {
-	case BTF_KIND_UNKN: /* VOID */
-		return true;
-	case BTF_KIND_INT:
-		return btf_equal_int_tag(t1, t2);
-	case BTF_KIND_ENUM:
-	case BTF_KIND_ENUM64:
-		return btf_compat_enum(t1, t2);
-	case BTF_KIND_FWD:
-	case BTF_KIND_FLOAT:
-		return btf_equal_common(t1, t2);
-	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_TYPE_TAG:
-		if (t1->info != t2->info || t1->name_off != t2->name_off)
-			return false;
-		id1 = t1->type;
-		id2 = t2->type;
-		goto recur;
-	case BTF_KIND_ARRAY: {
-		struct btf_array *a1, *a2;
-
-		if (!btf_compat_array(t1, t2))
-			return false;
-
-		a1 = btf_array(t1);
-		a2 = btf_array(t1);
-
-		if (a1->index_type != a2->index_type &&
-		    !btf_dedup_identical_types(d, a1->index_type, a2->index_type, depth - 1))
-			return false;
-
-		if (a1->type != a2->type &&
-		    !btf_dedup_identical_types(d, a1->type, a2->type, depth - 1))
-			return false;
-
-		return true;
-	}
-	case BTF_KIND_STRUCT:
-	case BTF_KIND_UNION: {
-		const struct btf_member *m1, *m2;
-		int i, n;
-
-		if (!btf_shallow_equal_struct(t1, t2))
-			return false;
-
-		m1 = btf_members(t1);
-		m2 = btf_members(t2);
-		for (i = 0, n = btf_vlen(t1); i < n; i++, m1++, m2++) {
-			if (m1->type == m2->type)
-				continue;
-			if (!btf_dedup_identical_types(d, m1->type, m2->type, depth - 1))
-				return false;
-		}
-		return true;
-	}
-	case BTF_KIND_FUNC_PROTO: {
-		const struct btf_param *p1, *p2;
-		int i, n;
-
-		if (!btf_compat_fnproto(t1, t2))
-			return false;
-
-		if (t1->type != t2->type &&
-		    !btf_dedup_identical_types(d, t1->type, t2->type, depth - 1))
-			return false;
-
-		p1 = btf_params(t1);
-		p2 = btf_params(t2);
-		for (i = 0, n = btf_vlen(t1); i < n; i++, p1++, p2++) {
-			if (p1->type == p2->type)
-				continue;
-			if (!btf_dedup_identical_types(d, p1->type, p2->type, depth - 1))
-				return false;
-		}
-		return true;
-	}
-	default:
+	if (!btf_shallow_equal_struct(t1, t2))
 		return false;
+
+	m1 = btf_members(t1);
+	m2 = btf_members(t2);
+	for (i = 0, n = btf_vlen(t1); i < n; i++, m1++, m2++) {
+		if (m1->type != m2->type &&
+		    !btf_dedup_identical_arrays(d, m1->type, m2->type) &&
+		    !btf_dedup_identical_structs(d, m1->type, m2->type))
+			return false;
 	}
+	return true;
 }
 
-
 /*
  * Check equivalence of BTF type graph formed by candidate struct/union (we'll
  * call it "candidate graph" in this description for brevity) to a type graph
@@ -4577,13 +4455,19 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id,
 		 * different fields within the *same* struct. This breaks type
 		 * equivalence check, which makes an assumption that candidate
 		 * types sub-graph has a consistent and deduped-by-compiler
-		 * types within a single CU. And similar situation can happen
-		 * with struct/union sometimes, and event with pointers.
-		 * So accommodate cases like this doing a structural
-		 * comparison recursively, but avoiding being stuck in endless
-		 * loops by limiting the depth up to which we check.
+		 * types within a single CU. So work around that by explicitly
+		 * allowing identical array types here.
 		 */
-		if (btf_dedup_identical_types(d, hypot_type_id, cand_id, 16))
+		if (btf_dedup_identical_arrays(d, hypot_type_id, cand_id))
+			return 1;
+		/* It turns out that similar situation can happen with
+		 * struct/union sometimes, sigh... Handle the case where
+		 * structs/unions are exactly the same, down to the referenced
+		 * type IDs. Anything more complicated (e.g., if referenced
+		 * types are different, but equivalent) is *way more*
+		 * complicated and requires a many-to-many equivalence mapping.
+		 */
+		if (btf_dedup_identical_structs(d, hypot_type_id, cand_id))
 			return 1;
 		return 0;
 	}
@@ -5334,8 +5218,7 @@ struct btf *btf__load_vmlinux_btf(void)
 		btf = btf__parse(sysfs_btf_path, NULL);
 		if (!btf) {
 			err = -errno;
-			pr_warn("failed to read kernel BTF from '%s': %s\n",
-				sysfs_btf_path, errstr(err));
+			pr_warn("failed to read kernel BTF from '%s': %d\n", sysfs_btf_path, err);
 			return libbpf_err_ptr(err);
 		}
 		pr_debug("loaded kernel BTF from '%s'\n", sysfs_btf_path);
@@ -5352,7 +5235,7 @@ struct btf *btf__load_vmlinux_btf(void)
 
 		btf = btf__parse(path, NULL);
 		err = libbpf_get_error(btf);
-		pr_debug("loading kernel BTF '%s': %s\n", path, errstr(err));
+		pr_debug("loading kernel BTF '%s': %d\n", path, err);
 		if (err)
 			continue;
 

src/btf.h

@@ -227,7 +227,6 @@ 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);
-LIBBPF_API int btf__add_type_attr(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,
@@ -244,8 +243,6 @@ LIBBPF_API int btf__add_datasec_var_info(struct btf *btf, int var_type_id,
 /* 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 int btf__add_decl_attr(struct btf *btf, const char *value, int ref_type_id,
-				  int component_idx);
 
 struct btf_dedup_opts {
 	size_t sz;

src/btf_dump.c

@@ -21,7 +21,6 @@
 #include "hashmap.h"
 #include "libbpf.h"
 #include "libbpf_internal.h"
-#include "str_error.h"
 
 static const char PREFIXES[] = "\t\t\t\t\t\t\t\t\t\t\t\t\t";
 static const size_t PREFIX_CNT = sizeof(PREFIXES) - 1;
@@ -1305,7 +1304,7 @@ static void btf_dump_emit_type_decl(struct btf_dump *d, __u32 id,
 			 * chain, restore stack, emit warning, and try to
 			 * proceed nevertheless
 			 */
-			pr_warn("not enough memory for decl stack: %s\n", errstr(err));
+			pr_warn("not enough memory for decl stack: %d\n", err);
 			d->decl_stack_cnt = stack_start;
 			return;
 		}
@@ -1494,10 +1493,7 @@ static void btf_dump_emit_type_chain(struct btf_dump *d,
 		case BTF_KIND_TYPE_TAG:
 			btf_dump_emit_mods(d, decls);
 			name = btf_name_of(d, t->name_off);
-			if (btf_kflag(t))
-				btf_dump_printf(d, " __attribute__((%s))", name);
-			else
-				btf_dump_printf(d, " __attribute__((btf_type_tag(\"%s\")))", name);
+			btf_dump_printf(d, " __attribute__((btf_type_tag(\"%s\")))", name);
 			break;
 		case BTF_KIND_ARRAY: {
 			const struct btf_array *a = btf_array(t);

src/btf_relocate.c

@@ -212,7 +212,7 @@ static int btf_relocate_map_distilled_base(struct btf_relocate *r)
 	 * 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_dist_base_types + r->nr_split_types; id++) {
+	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;

src/elf.c

@@ -24,6 +24,7 @@
 
 int elf_open(const char *binary_path, struct elf_fd *elf_fd)
 {
+	char errmsg[STRERR_BUFSIZE];
 	int fd, ret;
 	Elf *elf;
 
@@ -37,7 +38,8 @@ int elf_open(const char *binary_path, struct elf_fd *elf_fd)
 	fd = open(binary_path, O_RDONLY | O_CLOEXEC);
 	if (fd < 0) {
 		ret = -errno;
-		pr_warn("elf: failed to open %s: %s\n", binary_path, errstr(ret));
+		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);

src/features.c

@@ -47,6 +47,7 @@ static int probe_kern_prog_name(int token_fd)
 
 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),
@@ -66,8 +67,9 @@ static int probe_kern_global_data(int token_fd)
 	map = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_global", sizeof(int), 32, 1, &map_opts);
 	if (map < 0) {
 		ret = -errno;
-		pr_warn("Error in %s(): %s. Couldn't create simple array map.\n",
-			__func__, errstr(ret));
+		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;
 	}
 
@@ -265,6 +267,7 @@ static int probe_kern_probe_read_kernel(int token_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(),
@@ -282,8 +285,9 @@ static int probe_prog_bind_map(int token_fd)
 	map = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_det_bind", sizeof(int), 32, 1, &map_opts);
 	if (map < 0) {
 		ret = -errno;
-		pr_warn("Error in %s(): %s. Couldn't create simple array map.\n",
-			__func__, errstr(ret));
+		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;
 	}
 
@@ -600,8 +604,7 @@ bool feat_supported(struct kern_feature_cache *cache, enum kern_feature_id feat_
 		} else if (ret == 0) {
 			WRITE_ONCE(cache->res[feat_id], FEAT_MISSING);
 		} else {
-			pr_warn("Detection of kernel %s support failed: %s\n",
-				feat->desc, errstr(ret));
+			pr_warn("Detection of kernel %s support failed: %d\n", feat->desc, ret);
 			WRITE_ONCE(cache->res[feat_id], FEAT_MISSING);
 		}
 	}

src/gen_loader.c

@@ -14,7 +14,6 @@
 #include "bpf_gen_internal.h"
 #include "skel_internal.h"
 #include <asm/byteorder.h>
-#include "str_error.h"
 
 #define MAX_USED_MAPS	64
 #define MAX_USED_PROGS	32
@@ -394,7 +393,7 @@ int bpf_gen__finish(struct bpf_gen *gen, int nr_progs, int nr_maps)
 			      blob_fd_array_off(gen, i));
 	emit(gen, BPF_MOV64_IMM(BPF_REG_0, 0));
 	emit(gen, BPF_EXIT_INSN());
-	pr_debug("gen: finish %s\n", errstr(gen->error));
+	pr_debug("gen: finish %d\n", gen->error);
 	if (!gen->error) {
 		struct gen_loader_opts *opts = gen->opts;
 

src/libbpf.h

@@ -241,19 +241,6 @@ LIBBPF_API struct bpf_object *
 bpf_object__open_mem(const void *obj_buf, size_t obj_buf_sz,
 		     const struct bpf_object_open_opts *opts);
 
-/**
- * @brief **bpf_object__prepare()** prepares BPF object for loading:
- * performs ELF processing, relocations, prepares final state of BPF program
- * instructions (accessible with bpf_program__insns()), creates and
- * (potentially) pins maps. Leaves BPF object in the state ready for program
- * loading.
- * @param obj Pointer to a valid BPF object instance returned by
- * **bpf_object__open*()** API
- * @return 0, on success; negative error code, otherwise, error code is
- * stored in errno
- */
-int bpf_object__prepare(struct bpf_object *obj);
-
 /**
  * @brief **bpf_object__load()** loads BPF object into kernel.
  * @param obj Pointer to a valid BPF object instance returned by
@@ -565,12 +552,10 @@ struct bpf_kprobe_multi_opts {
 	bool retprobe;
 	/* create session kprobes */
 	bool session;
-	/* enforce unique match */
-	bool unique_match;
 	size_t :0;
 };
 
-#define bpf_kprobe_multi_opts__last_field unique_match
+#define bpf_kprobe_multi_opts__last_field session
 
 LIBBPF_API struct bpf_link *
 bpf_program__attach_kprobe_multi_opts(const struct bpf_program *prog,
@@ -592,12 +577,10 @@ struct bpf_uprobe_multi_opts {
 	size_t cnt;
 	/* create return uprobes */
 	bool retprobe;
-	/* create session kprobes */
-	bool session;
 	size_t :0;
 };
 
-#define bpf_uprobe_multi_opts__last_field session
+#define bpf_uprobe_multi_opts__last_field retprobe
 
 /**
  * @brief **bpf_program__attach_uprobe_multi()** attaches a BPF program
@@ -940,12 +923,6 @@ LIBBPF_API int bpf_program__set_log_level(struct bpf_program *prog, __u32 log_le
 LIBBPF_API const char *bpf_program__log_buf(const struct bpf_program *prog, size_t *log_size);
 LIBBPF_API int bpf_program__set_log_buf(struct bpf_program *prog, char *log_buf, size_t log_size);
 
-LIBBPF_API struct bpf_func_info *bpf_program__func_info(const struct bpf_program *prog);
-LIBBPF_API __u32 bpf_program__func_info_cnt(const struct bpf_program *prog);
-
-LIBBPF_API struct bpf_line_info *bpf_program__line_info(const struct bpf_program *prog);
-LIBBPF_API __u32 bpf_program__line_info_cnt(const struct bpf_program *prog);
-
 /**
  * @brief **bpf_program__set_attach_target()** sets BTF-based attach target
  * for supported BPF program types:
@@ -1817,14 +1794,9 @@ struct bpf_linker_file_opts {
 struct bpf_linker;
 
 LIBBPF_API struct bpf_linker *bpf_linker__new(const char *filename, struct bpf_linker_opts *opts);
-LIBBPF_API struct bpf_linker *bpf_linker__new_fd(int fd, struct bpf_linker_opts *opts);
 LIBBPF_API int bpf_linker__add_file(struct bpf_linker *linker,
 				    const char *filename,
 				    const struct bpf_linker_file_opts *opts);
-LIBBPF_API int bpf_linker__add_fd(struct bpf_linker *linker, int fd,
-				  const struct bpf_linker_file_opts *opts);
-LIBBPF_API int bpf_linker__add_buf(struct bpf_linker *linker, void *buf, size_t buf_sz,
-				   const struct bpf_linker_file_opts *opts);
 LIBBPF_API int bpf_linker__finalize(struct bpf_linker *linker);
 LIBBPF_API void bpf_linker__free(struct bpf_linker *linker);
 

src/libbpf.map

@@ -430,17 +430,3 @@ LIBBPF_1.5.0 {
 		ring__consume_n;
 		ring_buffer__consume_n;
 } LIBBPF_1.4.0;
-
-LIBBPF_1.6.0 {
-	global:
-		bpf_linker__add_buf;
-		bpf_linker__add_fd;
-		bpf_linker__new_fd;
-		bpf_object__prepare;
-		bpf_program__func_info;
-		bpf_program__func_info_cnt;
-		bpf_program__line_info;
-		bpf_program__line_info_cnt;
-		btf__add_decl_attr;
-		btf__add_type_attr;
-} LIBBPF_1.5.0;

src/libbpf_internal.h

@@ -409,7 +409,6 @@ int libbpf__load_raw_btf(const char *raw_types, size_t types_len,
 int btf_load_into_kernel(struct btf *btf,
 			 char *log_buf, size_t log_sz, __u32 log_level,
 			 int token_fd);
-struct btf *btf_load_from_kernel(__u32 id, struct btf *base_btf, int token_fd);
 
 struct btf *btf_get_from_fd(int btf_fd, struct btf *base_btf);
 void btf_get_kernel_prefix_kind(enum bpf_attach_type attach_type,
@@ -667,15 +666,6 @@ static inline int sys_dup3(int oldfd, int newfd, int flags)
 	return syscall(__NR_dup3, oldfd, newfd, flags);
 }
 
-/* Some versions of Android don't provide memfd_create() in their libc
- * implementation, so avoid complications and just go straight to Linux
- * syscall.
- */
-static inline int sys_memfd_create(const char *name, unsigned flags)
-{
-	return syscall(__NR_memfd_create, name, flags);
-}
-
 /* Point *fixed_fd* to the same file that *tmp_fd* points to.
  * Regardless of success, *tmp_fd* is closed.
  * Whatever *fixed_fd* pointed to is closed silently.

src/libbpf_version.h

@@ -4,6 +4,6 @@
 #define __LIBBPF_VERSION_H
 
 #define LIBBPF_MAJOR_VERSION 1
-#define LIBBPF_MINOR_VERSION 6
+#define LIBBPF_MINOR_VERSION 5
 
 #endif /* __LIBBPF_VERSION_H */

src/linker.c

@@ -4,10 +4,6 @@
  *
  * Copyright (c) 2021 Facebook
  */
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdio.h>
@@ -20,12 +16,10 @@
 #include <elf.h>
 #include <libelf.h>
 #include <fcntl.h>
-#include <sys/mman.h>
 #include "libbpf.h"
 #include "btf.h"
 #include "libbpf_internal.h"
 #include "strset.h"
-#include "str_error.h"
 
 #define BTF_EXTERN_SEC ".extern"
 
@@ -157,19 +151,15 @@ struct bpf_linker {
 	/* global (including extern) ELF symbols */
 	int glob_sym_cnt;
 	struct glob_sym *glob_syms;
-
-	bool fd_is_owned;
 };
 
 #define pr_warn_elf(fmt, ...)									\
 	libbpf_print(LIBBPF_WARN, "libbpf: " fmt ": %s\n", ##__VA_ARGS__, elf_errmsg(-1))
 
-static int init_output_elf(struct bpf_linker *linker);
+static int init_output_elf(struct bpf_linker *linker, const char *file);
 
-static int bpf_linker_add_file(struct bpf_linker *linker, int fd,
-			       const char *filename);
-
-static int linker_load_obj_file(struct bpf_linker *linker,
+static int linker_load_obj_file(struct bpf_linker *linker, const char *filename,
+				const struct bpf_linker_file_opts *opts,
 				struct src_obj *obj);
 static int linker_sanity_check_elf(struct src_obj *obj);
 static int linker_sanity_check_elf_symtab(struct src_obj *obj, struct src_sec *sec);
@@ -200,7 +190,7 @@ void bpf_linker__free(struct bpf_linker *linker)
 	if (linker->elf)
 		elf_end(linker->elf);
 
-	if (linker->fd >= 0 && linker->fd_is_owned)
+	if (linker->fd >= 0)
 		close(linker->fd);
 
 	strset__free(linker->strtab_strs);
@@ -242,63 +232,9 @@ struct bpf_linker *bpf_linker__new(const char *filename, struct bpf_linker_opts
 	if (!linker)
 		return errno = ENOMEM, NULL;
 
-	linker->filename = strdup(filename);
-	if (!linker->filename) {
-		err = -ENOMEM;
-		goto err_out;
-	}
+	linker->fd = -1;
 
-	linker->fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
-	if (linker->fd < 0) {
-		err = -errno;
-		pr_warn("failed to create '%s': %d\n", filename, err);
-		goto err_out;
-	}
-	linker->fd_is_owned = true;
-
-	err = init_output_elf(linker);
-	if (err)
-		goto err_out;
-
-	return linker;
-
-err_out:
-	bpf_linker__free(linker);
-	return errno = -err, NULL;
-}
-
-struct bpf_linker *bpf_linker__new_fd(int fd, struct bpf_linker_opts *opts)
-{
-	struct bpf_linker *linker;
-	char filename[32];
-	int err;
-
-	if (fd < 0)
-		return errno = EINVAL, NULL;
-
-	if (!OPTS_VALID(opts, bpf_linker_opts))
-		return errno = EINVAL, NULL;
-
-	if (elf_version(EV_CURRENT) == EV_NONE) {
-		pr_warn_elf("libelf initialization failed");
-		return errno = EINVAL, NULL;
-	}
-
-	linker = calloc(1, sizeof(*linker));
-	if (!linker)
-		return errno = ENOMEM, NULL;
-
-	snprintf(filename, sizeof(filename), "fd:%d", fd);
-	linker->filename = strdup(filename);
-	if (!linker->filename) {
-		err = -ENOMEM;
-		goto err_out;
-	}
-
-	linker->fd = fd;
-	linker->fd_is_owned = false;
-
-	err = init_output_elf(linker);
+	err = init_output_elf(linker, filename);
 	if (err)
 		goto err_out;
 
@@ -357,12 +293,23 @@ static Elf64_Sym *add_new_sym(struct bpf_linker *linker, size_t *sym_idx)
 	return sym;
 }
 
-static int init_output_elf(struct bpf_linker *linker)
+static int init_output_elf(struct bpf_linker *linker, const char *file)
 {
 	int err, str_off;
 	Elf64_Sym *init_sym;
 	struct dst_sec *sec;
 
+	linker->filename = strdup(file);
+	if (!linker->filename)
+		return -ENOMEM;
+
+	linker->fd = open(file, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
+	if (linker->fd < 0) {
+		err = -errno;
+		pr_warn("failed to create '%s': %d\n", file, err);
+		return err;
+	}
+
 	linker->elf = elf_begin(linker->fd, ELF_C_WRITE, NULL);
 	if (!linker->elf) {
 		pr_warn_elf("failed to create ELF object");
@@ -488,16 +435,19 @@ static int init_output_elf(struct bpf_linker *linker)
 	return 0;
 }
 
-static int bpf_linker_add_file(struct bpf_linker *linker, int fd,
-			       const char *filename)
+int bpf_linker__add_file(struct bpf_linker *linker, const char *filename,
+			 const struct bpf_linker_file_opts *opts)
 {
 	struct src_obj obj = {};
 	int err = 0;
 
-	obj.filename = filename;
-	obj.fd = fd;
+	if (!OPTS_VALID(opts, bpf_linker_file_opts))
+		return libbpf_err(-EINVAL);
 
-	err = err ?: linker_load_obj_file(linker, &obj);
+	if (!linker->elf)
+		return libbpf_err(-EINVAL);
+
+	err = err ?: linker_load_obj_file(linker, filename, opts, &obj);
 	err = err ?: linker_append_sec_data(linker, &obj);
 	err = err ?: linker_append_elf_syms(linker, &obj);
 	err = err ?: linker_append_elf_relos(linker, &obj);
@@ -512,91 +462,12 @@ static int bpf_linker_add_file(struct bpf_linker *linker, int fd,
 	free(obj.sym_map);
 	if (obj.elf)
 		elf_end(obj.elf);
+	if (obj.fd >= 0)
+		close(obj.fd);
 
-	return err;
-}
-
-int bpf_linker__add_file(struct bpf_linker *linker, const char *filename,
-			 const struct bpf_linker_file_opts *opts)
-{
-	int fd, err;
-
-	if (!OPTS_VALID(opts, bpf_linker_file_opts))
-		return libbpf_err(-EINVAL);
-
-	if (!linker->elf)
-		return libbpf_err(-EINVAL);
-
-	fd = open(filename, O_RDONLY | O_CLOEXEC);
-	if (fd < 0) {
-		err = -errno;
-		pr_warn("failed to open file '%s': %s\n", filename, errstr(err));
-		return libbpf_err(err);
-	}
-
-	err = bpf_linker_add_file(linker, fd, filename);
-	close(fd);
 	return libbpf_err(err);
 }
 
-int bpf_linker__add_fd(struct bpf_linker *linker, int fd,
-		       const struct bpf_linker_file_opts *opts)
-{
-	char filename[32];
-	int err;
-
-	if (!OPTS_VALID(opts, bpf_linker_file_opts))
-		return libbpf_err(-EINVAL);
-
-	if (!linker->elf)
-		return libbpf_err(-EINVAL);
-
-	if (fd < 0)
-		return libbpf_err(-EINVAL);
-
-	snprintf(filename, sizeof(filename), "fd:%d", fd);
-	err = bpf_linker_add_file(linker, fd, filename);
-	return libbpf_err(err);
-}
-
-int bpf_linker__add_buf(struct bpf_linker *linker, void *buf, size_t buf_sz,
-			const struct bpf_linker_file_opts *opts)
-{
-	char filename[32];
-	int fd, written, ret;
-
-	if (!OPTS_VALID(opts, bpf_linker_file_opts))
-		return libbpf_err(-EINVAL);
-
-	if (!linker->elf)
-		return libbpf_err(-EINVAL);
-
-	snprintf(filename, sizeof(filename), "mem:%p+%zu", buf, buf_sz);
-
-	fd = sys_memfd_create(filename, 0);
-	if (fd < 0) {
-		ret = -errno;
-		pr_warn("failed to create memfd '%s': %s\n", filename, errstr(ret));
-		return libbpf_err(ret);
-	}
-
-	written = 0;
-	while (written < buf_sz) {
-		ret = write(fd, buf, buf_sz);
-		if (ret < 0) {
-			ret = -errno;
-			pr_warn("failed to write '%s': %s\n", filename, errstr(ret));
-			goto err_out;
-		}
-		written += ret;
-	}
-
-	ret = bpf_linker_add_file(linker, fd, filename);
-err_out:
-	close(fd);
-	return libbpf_err(ret);
-}
-
 static bool is_dwarf_sec_name(const char *name)
 {
 	/* approximation, but the actual list is too long */
@@ -662,7 +533,8 @@ static struct src_sec *add_src_sec(struct src_obj *obj, const char *sec_name)
 	return sec;
 }
 
-static int linker_load_obj_file(struct bpf_linker *linker,
+static int linker_load_obj_file(struct bpf_linker *linker, const char *filename,
+				const struct bpf_linker_file_opts *opts,
 				struct src_obj *obj)
 {
 	int err = 0;
@@ -681,26 +553,36 @@ static int linker_load_obj_file(struct bpf_linker *linker,
 #error "Unknown __BYTE_ORDER__"
 #endif
 
-	pr_debug("linker: adding object file '%s'...\n", obj->filename);
+	pr_debug("linker: adding object file '%s'...\n", filename);
 
+	obj->filename = filename;
+
+	obj->fd = open(filename, O_RDONLY | O_CLOEXEC);
+	if (obj->fd < 0) {
+		err = -errno;
+		pr_warn("failed to open file '%s': %d\n", filename, err);
+		return err;
+	}
 	obj->elf = elf_begin(obj->fd, ELF_C_READ_MMAP, NULL);
 	if (!obj->elf) {
-		pr_warn_elf("failed to parse ELF file '%s'", obj->filename);
-		return -EINVAL;
+		err = -errno;
+		pr_warn_elf("failed to parse ELF file '%s'", filename);
+		return err;
 	}
 
 	/* Sanity check ELF file high-level properties */
 	ehdr = elf64_getehdr(obj->elf);
 	if (!ehdr) {
-		pr_warn_elf("failed to get ELF header for %s", obj->filename);
-		return -EINVAL;
+		err = -errno;
+		pr_warn_elf("failed to get ELF header for %s", filename);
+		return err;
 	}
 
 	/* Linker output endianness set by first input object */
 	obj_byteorder = ehdr->e_ident[EI_DATA];
 	if (obj_byteorder != ELFDATA2LSB && obj_byteorder != ELFDATA2MSB) {
 		err = -EOPNOTSUPP;
-		pr_warn("unknown byte order of ELF file %s\n", obj->filename);
+		pr_warn("unknown byte order of ELF file %s\n", filename);
 		return err;
 	}
 	if (link_byteorder == ELFDATANONE) {
@@ -710,7 +592,7 @@ static int linker_load_obj_file(struct bpf_linker *linker,
 			 obj_byteorder == ELFDATA2MSB ? "big" : "little");
 	} else if (link_byteorder != obj_byteorder) {
 		err = -EOPNOTSUPP;
-		pr_warn("byte order mismatch with ELF file %s\n", obj->filename);
+		pr_warn("byte order mismatch with ELF file %s\n", filename);
 		return err;
 	}
 
@@ -718,13 +600,14 @@ static int linker_load_obj_file(struct bpf_linker *linker,
 	    || ehdr->e_machine != EM_BPF
 	    || ehdr->e_ident[EI_CLASS] != ELFCLASS64) {
 		err = -EOPNOTSUPP;
-		pr_warn_elf("unsupported kind of ELF file %s", obj->filename);
+		pr_warn_elf("unsupported kind of ELF file %s", filename);
 		return err;
 	}
 
 	if (elf_getshdrstrndx(obj->elf, &obj->shstrs_sec_idx)) {
-		pr_warn_elf("failed to get SHSTRTAB section index for %s", obj->filename);
-		return -EINVAL;
+		err = -errno;
+		pr_warn_elf("failed to get SHSTRTAB section index for %s", filename);
+		return err;
 	}
 
 	scn = NULL;
@@ -734,23 +617,26 @@ static int linker_load_obj_file(struct bpf_linker *linker,
 
 		shdr = elf64_getshdr(scn);
 		if (!shdr) {
+			err = -errno;
 			pr_warn_elf("failed to get section #%zu header for %s",
-				    sec_idx, obj->filename);
-			return -EINVAL;
+				    sec_idx, filename);
+			return err;
 		}
 
 		sec_name = elf_strptr(obj->elf, obj->shstrs_sec_idx, shdr->sh_name);
 		if (!sec_name) {
+			err = -errno;
 			pr_warn_elf("failed to get section #%zu name for %s",
-				    sec_idx, obj->filename);
-			return -EINVAL;
+				    sec_idx, filename);
+			return err;
 		}
 
 		data = elf_getdata(scn, 0);
 		if (!data) {
+			err = -errno;
 			pr_warn_elf("failed to get section #%zu (%s) data from %s",
-				    sec_idx, sec_name, obj->filename);
-			return -EINVAL;
+				    sec_idx, sec_name, filename);
+			return err;
 		}
 
 		sec = add_src_sec(obj, sec_name);
@@ -784,8 +670,7 @@ static int linker_load_obj_file(struct bpf_linker *linker,
 				obj->btf = btf__new(data->d_buf, shdr->sh_size);
 				err = libbpf_get_error(obj->btf);
 				if (err) {
-					pr_warn("failed to parse .BTF from %s: %s\n",
-						obj->filename, errstr(err));
+					pr_warn("failed to parse .BTF from %s: %d\n", filename, err);
 					return err;
 				}
 				sec->skipped = true;
@@ -795,8 +680,7 @@ static int linker_load_obj_file(struct bpf_linker *linker,
 				obj->btf_ext = btf_ext__new(data->d_buf, shdr->sh_size);
 				err = libbpf_get_error(obj->btf_ext);
 				if (err) {
-					pr_warn("failed to parse .BTF.ext from '%s': %s\n",
-						obj->filename, errstr(err));
+					pr_warn("failed to parse .BTF.ext from '%s': %d\n", filename, err);
 					return err;
 				}
 				sec->skipped = true;
@@ -813,7 +697,7 @@ static int linker_load_obj_file(struct bpf_linker *linker,
 			break;
 		default:
 			pr_warn("unrecognized section #%zu (%s) in %s\n",
-				sec_idx, sec_name, obj->filename);
+				sec_idx, sec_name, filename);
 			err = -EINVAL;
 			return err;
 		}
@@ -1376,7 +1260,7 @@ static int linker_append_sec_data(struct bpf_linker *linker, struct src_obj *obj
 		} else {
 			if (!secs_match(dst_sec, src_sec)) {
 				pr_warn("ELF sections %s are incompatible\n", src_sec->sec_name);
-				return -EINVAL;
+				return -1;
 			}
 
 			/* "license" and "version" sections are deduped */
@@ -2163,7 +2047,7 @@ add_sym:
 
 	obj->sym_map[src_sym_idx] = dst_sym_idx;
 
-	if (sym_type == STT_SECTION && dst_sec) {
+	if (sym_type == STT_SECTION && dst_sym) {
 		dst_sec->sec_sym_idx = dst_sym_idx;
 		dst_sym->st_value = 0;
 	}
@@ -2223,7 +2107,7 @@ static int linker_append_elf_relos(struct bpf_linker *linker, struct src_obj *ob
 			}
 		} else if (!secs_match(dst_sec, src_sec)) {
 			pr_warn("sections %s are not compatible\n", src_sec->sec_name);
-			return -EINVAL;
+			return -1;
 		}
 
 		/* shdr->sh_link points to SYMTAB */
@@ -2793,23 +2677,22 @@ int bpf_linker__finalize(struct bpf_linker *linker)
 
 	/* Finalize ELF layout */
 	if (elf_update(linker->elf, ELF_C_NULL) < 0) {
-		err = -EINVAL;
+		err = -errno;
 		pr_warn_elf("failed to finalize ELF layout");
 		return libbpf_err(err);
 	}
 
 	/* Write out final ELF contents */
 	if (elf_update(linker->elf, ELF_C_WRITE) < 0) {
-		err = -EINVAL;
+		err = -errno;
 		pr_warn_elf("failed to write ELF contents");
 		return libbpf_err(err);
 	}
 
 	elf_end(linker->elf);
-	linker->elf = NULL;
+	close(linker->fd);
 
-	if (linker->fd_is_owned)
-		close(linker->fd);
+	linker->elf = NULL;
 	linker->fd = -1;
 
 	return 0;
@@ -2891,14 +2774,14 @@ static int finalize_btf(struct bpf_linker *linker)
 
 	err = finalize_btf_ext(linker);
 	if (err) {
-		pr_warn(".BTF.ext generation failed: %s\n", errstr(err));
+		pr_warn(".BTF.ext generation failed: %d\n", err);
 		return err;
 	}
 
 	opts.btf_ext = linker->btf_ext;
 	err = btf__dedup(linker->btf, &opts);
 	if (err) {
-		pr_warn("BTF dedup failed: %s\n", errstr(err));
+		pr_warn("BTF dedup failed: %d\n", err);
 		return err;
 	}
 
@@ -2916,7 +2799,7 @@ static int finalize_btf(struct bpf_linker *linker)
 
 	err = emit_elf_data_sec(linker, BTF_ELF_SEC, 8, raw_data, raw_sz);
 	if (err) {
-		pr_warn("failed to write out .BTF ELF section: %s\n", errstr(err));
+		pr_warn("failed to write out .BTF ELF section: %d\n", err);
 		return err;
 	}
 
@@ -2928,7 +2811,7 @@ static int finalize_btf(struct bpf_linker *linker)
 
 		err = emit_elf_data_sec(linker, BTF_EXT_ELF_SEC, 8, raw_data, raw_sz);
 		if (err) {
-			pr_warn("failed to write out .BTF.ext ELF section: %s\n", errstr(err));
+			pr_warn("failed to write out .BTF.ext ELF section: %d\n", err);
 			return err;
 		}
 	}
@@ -3104,7 +2987,7 @@ static int finalize_btf_ext(struct bpf_linker *linker)
 	err = libbpf_get_error(linker->btf_ext);
 	if (err) {
 		linker->btf_ext = NULL;
-		pr_warn("failed to parse final .BTF.ext data: %s\n", errstr(err));
+		pr_warn("failed to parse final .BTF.ext data: %d\n", err);
 		goto out;
 	}
 

src/nlattr.c

@@ -63,16 +63,16 @@ static int validate_nla(struct nlattr *nla, int maxtype,
 		minlen = nla_attr_minlen[pt->type];
 
 	if (libbpf_nla_len(nla) < minlen)
-		return -EINVAL;
+		return -1;
 
 	if (pt->maxlen && libbpf_nla_len(nla) > pt->maxlen)
-		return -EINVAL;
+		return -1;
 
 	if (pt->type == LIBBPF_NLA_STRING) {
 		char *data = libbpf_nla_data(nla);
 
 		if (data[libbpf_nla_len(nla) - 1] != '\0')
-			return -EINVAL;
+			return -1;
 	}
 
 	return 0;
@@ -118,18 +118,19 @@ int libbpf_nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head,
 		if (policy) {
 			err = validate_nla(nla, maxtype, policy);
 			if (err < 0)
-				return err;
+				goto errout;
 		}
 
-		if (tb[type]) {
+		if (tb[type])
 			pr_warn("Attribute of type %#x found multiple times in message, "
 				"previous attribute is being ignored.\n", type);
-		}
 
 		tb[type] = nla;
 	}
 
-	return 0;
+	err = 0;
+errout:
+	return err;
 }
 
 /**

src/relo_core.c

@@ -683,7 +683,7 @@ static int bpf_core_calc_field_relo(const char *prog_name,
 {
 	const struct bpf_core_accessor *acc;
 	const struct btf_type *t;
-	__u32 byte_off, byte_sz, bit_off, bit_sz, field_type_id, elem_id;
+	__u32 byte_off, byte_sz, bit_off, bit_sz, field_type_id;
 	const struct btf_member *m;
 	const struct btf_type *mt;
 	bool bitfield;
@@ -706,14 +706,8 @@ static int bpf_core_calc_field_relo(const char *prog_name,
 	if (!acc->name) {
 		if (relo->kind == BPF_CORE_FIELD_BYTE_OFFSET) {
 			*val = spec->bit_offset / 8;
-			/* remember field size for load/store mem size;
-			 * note, for arrays we care about individual element
-			 * sizes, not the overall array size
-			 */
-			t = skip_mods_and_typedefs(spec->btf, acc->type_id, &elem_id);
-			while (btf_is_array(t))
-				t = skip_mods_and_typedefs(spec->btf, btf_array(t)->type, &elem_id);
-			sz = btf__resolve_size(spec->btf, elem_id);
+			/* remember field size for load/store mem size */
+			sz = btf__resolve_size(spec->btf, acc->type_id);
 			if (sz < 0)
 				return -EINVAL;
 			*field_sz = sz;
@@ -773,17 +767,7 @@ static int bpf_core_calc_field_relo(const char *prog_name,
 	case BPF_CORE_FIELD_BYTE_OFFSET:
 		*val = byte_off;
 		if (!bitfield) {
-			/* remember field size for load/store mem size;
-			 * note, for arrays we care about individual element
-			 * sizes, not the overall array size
-			 */
-			t = skip_mods_and_typedefs(spec->btf, field_type_id, &elem_id);
-			while (btf_is_array(t))
-				t = skip_mods_and_typedefs(spec->btf, btf_array(t)->type, &elem_id);
-			sz = btf__resolve_size(spec->btf, elem_id);
-			if (sz < 0)
-				return -EINVAL;
-			*field_sz = sz;
+			*field_sz = byte_sz;
 			*type_id = field_type_id;
 		}
 		break;

src/ringbuf.c

@@ -21,7 +21,6 @@
 #include "libbpf.h"
 #include "libbpf_internal.h"
 #include "bpf.h"
-#include "str_error.h"
 
 struct ring {
 	ring_buffer_sample_fn sample_cb;
@@ -89,8 +88,8 @@ int ring_buffer__add(struct ring_buffer *rb, int map_fd,
 	err = bpf_map_get_info_by_fd(map_fd, &info, &len);
 	if (err) {
 		err = -errno;
-		pr_warn("ringbuf: failed to get map info for fd=%d: %s\n",
-			map_fd, errstr(err));
+		pr_warn("ringbuf: failed to get map info for fd=%d: %d\n",
+			map_fd, err);
 		return libbpf_err(err);
 	}
 
@@ -124,8 +123,8 @@ int ring_buffer__add(struct ring_buffer *rb, int map_fd,
 	tmp = mmap(NULL, rb->page_size, PROT_READ | PROT_WRITE, MAP_SHARED, map_fd, 0);
 	if (tmp == MAP_FAILED) {
 		err = -errno;
-		pr_warn("ringbuf: failed to mmap consumer page for map fd=%d: %s\n",
-			map_fd, errstr(err));
+		pr_warn("ringbuf: failed to mmap consumer page for map fd=%d: %d\n",
+			map_fd, err);
 		goto err_out;
 	}
 	r->consumer_pos = tmp;
@@ -143,8 +142,8 @@ int ring_buffer__add(struct ring_buffer *rb, int map_fd,
 	tmp = mmap(NULL, (size_t)mmap_sz, PROT_READ, MAP_SHARED, map_fd, rb->page_size);
 	if (tmp == MAP_FAILED) {
 		err = -errno;
-		pr_warn("ringbuf: failed to mmap data pages for map fd=%d: %s\n",
-			map_fd, errstr(err));
+		pr_warn("ringbuf: failed to mmap data pages for map fd=%d: %d\n",
+			map_fd, err);
 		goto err_out;
 	}
 	r->producer_pos = tmp;
@@ -157,8 +156,8 @@ int ring_buffer__add(struct ring_buffer *rb, int map_fd,
 	e->data.fd = rb->ring_cnt;
 	if (epoll_ctl(rb->epoll_fd, EPOLL_CTL_ADD, map_fd, e) < 0) {
 		err = -errno;
-		pr_warn("ringbuf: failed to epoll add map fd=%d: %s\n",
-			map_fd, errstr(err));
+		pr_warn("ringbuf: failed to epoll add map fd=%d: %d\n",
+			map_fd, err);
 		goto err_out;
 	}
 
@@ -206,7 +205,7 @@ ring_buffer__new(int map_fd, ring_buffer_sample_fn sample_cb, void *ctx,
 	rb->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 	if (rb->epoll_fd < 0) {
 		err = -errno;
-		pr_warn("ringbuf: failed to create epoll instance: %s\n", errstr(err));
+		pr_warn("ringbuf: failed to create epoll instance: %d\n", err);
 		goto err_out;
 	}
 
@@ -459,8 +458,7 @@ static int user_ringbuf_map(struct user_ring_buffer *rb, int map_fd)
 	err = bpf_map_get_info_by_fd(map_fd, &info, &len);
 	if (err) {
 		err = -errno;
-		pr_warn("user ringbuf: failed to get map info for fd=%d: %s\n",
-			map_fd, errstr(err));
+		pr_warn("user ringbuf: failed to get map info for fd=%d: %d\n", map_fd, err);
 		return err;
 	}
 
@@ -476,8 +474,8 @@ static int user_ringbuf_map(struct user_ring_buffer *rb, int map_fd)
 	tmp = mmap(NULL, rb->page_size, PROT_READ, MAP_SHARED, map_fd, 0);
 	if (tmp == MAP_FAILED) {
 		err = -errno;
-		pr_warn("user ringbuf: failed to mmap consumer page for map fd=%d: %s\n",
-			map_fd, errstr(err));
+		pr_warn("user ringbuf: failed to mmap consumer page for map fd=%d: %d\n",
+			map_fd, err);
 		return err;
 	}
 	rb->consumer_pos = tmp;
@@ -496,8 +494,8 @@ static int user_ringbuf_map(struct user_ring_buffer *rb, int map_fd)
 		   map_fd, rb->page_size);
 	if (tmp == MAP_FAILED) {
 		err = -errno;
-		pr_warn("user ringbuf: failed to mmap data pages for map fd=%d: %s\n",
-			map_fd, errstr(err));
+		pr_warn("user ringbuf: failed to mmap data pages for map fd=%d: %d\n",
+			map_fd, err);
 		return err;
 	}
 
@@ -508,7 +506,7 @@ static int user_ringbuf_map(struct user_ring_buffer *rb, int map_fd)
 	rb_epoll->events = EPOLLOUT;
 	if (epoll_ctl(rb->epoll_fd, EPOLL_CTL_ADD, map_fd, rb_epoll) < 0) {
 		err = -errno;
-		pr_warn("user ringbuf: failed to epoll add map fd=%d: %s\n", map_fd, errstr(err));
+		pr_warn("user ringbuf: failed to epoll add map fd=%d: %d\n", map_fd, err);
 		return err;
 	}
 
@@ -533,7 +531,7 @@ user_ring_buffer__new(int map_fd, const struct user_ring_buffer_opts *opts)
 	rb->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 	if (rb->epoll_fd < 0) {
 		err = -errno;
-		pr_warn("user ringbuf: failed to create epoll instance: %s\n", errstr(err));
+		pr_warn("user ringbuf: failed to create epoll instance: %d\n", err);
 		goto err_out;
 	}
 

src/str_error.c

@@ -5,10 +5,6 @@
 #include <errno.h>
 #include "str_error.h"
 
-#ifndef ENOTSUPP
-#define ENOTSUPP	524
-#endif
-
 /* make sure libbpf doesn't use kernel-only integer typedefs */
 #pragma GCC poison u8 u16 u32 u64 s8 s16 s32 s64
 
@@ -35,70 +31,3 @@ char *libbpf_strerror_r(int err, char *dst, int len)
 	}
 	return dst;
 }
-
-const char *libbpf_errstr(int err)
-{
-	static __thread char buf[12];
-
-	if (err > 0)
-		err = -err;
-
-	switch (err) {
-	case -E2BIG:		return "-E2BIG";
-	case -EACCES:		return "-EACCES";
-	case -EADDRINUSE:	return "-EADDRINUSE";
-	case -EADDRNOTAVAIL:	return "-EADDRNOTAVAIL";
-	case -EAGAIN:		return "-EAGAIN";
-	case -EALREADY:		return "-EALREADY";
-	case -EBADF:		return "-EBADF";
-	case -EBADFD:		return "-EBADFD";
-	case -EBUSY:		return "-EBUSY";
-	case -ECANCELED:	return "-ECANCELED";
-	case -ECHILD:		return "-ECHILD";
-	case -EDEADLK:		return "-EDEADLK";
-	case -EDOM:		return "-EDOM";
-	case -EEXIST:		return "-EEXIST";
-	case -EFAULT:		return "-EFAULT";
-	case -EFBIG:		return "-EFBIG";
-	case -EILSEQ:		return "-EILSEQ";
-	case -EINPROGRESS:	return "-EINPROGRESS";
-	case -EINTR:		return "-EINTR";
-	case -EINVAL:		return "-EINVAL";
-	case -EIO:		return "-EIO";
-	case -EISDIR:		return "-EISDIR";
-	case -ELOOP:		return "-ELOOP";
-	case -EMFILE:		return "-EMFILE";
-	case -EMLINK:		return "-EMLINK";
-	case -EMSGSIZE:		return "-EMSGSIZE";
-	case -ENAMETOOLONG:	return "-ENAMETOOLONG";
-	case -ENFILE:		return "-ENFILE";
-	case -ENODATA:		return "-ENODATA";
-	case -ENODEV:		return "-ENODEV";
-	case -ENOENT:		return "-ENOENT";
-	case -ENOEXEC:		return "-ENOEXEC";
-	case -ENOLINK:		return "-ENOLINK";
-	case -ENOMEM:		return "-ENOMEM";
-	case -ENOSPC:		return "-ENOSPC";
-	case -ENOTBLK:		return "-ENOTBLK";
-	case -ENOTDIR:		return "-ENOTDIR";
-	case -ENOTSUPP:		return "-ENOTSUPP";
-	case -ENOTTY:		return "-ENOTTY";
-	case -ENXIO:		return "-ENXIO";
-	case -EOPNOTSUPP:	return "-EOPNOTSUPP";
-	case -EOVERFLOW:	return "-EOVERFLOW";
-	case -EPERM:		return "-EPERM";
-	case -EPIPE:		return "-EPIPE";
-	case -EPROTO:		return "-EPROTO";
-	case -EPROTONOSUPPORT:	return "-EPROTONOSUPPORT";
-	case -ERANGE:		return "-ERANGE";
-	case -EROFS:		return "-EROFS";
-	case -ESPIPE:		return "-ESPIPE";
-	case -ESRCH:		return "-ESRCH";
-	case -ETXTBSY:		return "-ETXTBSY";
-	case -EUCLEAN:		return "-EUCLEAN";
-	case -EXDEV:		return "-EXDEV";
-	default:
-		snprintf(buf, sizeof(buf), "%d", err);
-		return buf;
-	}
-}

src/str_error.h

@@ -6,14 +6,4 @@
 
 char *libbpf_strerror_r(int err, char *dst, int len);
 
-/**
- * @brief **libbpf_errstr()** returns string corresponding to numeric errno
- * @param err negative numeric errno
- * @return pointer to string representation of the errno, that is invalidated
- * upon the next call.
- */
-const char *libbpf_errstr(int err);
-
-#define errstr(err) libbpf_errstr(err)
-
 #endif /* __LIBBPF_STR_ERROR_H */

src/usdt.bpf.h

@@ -108,38 +108,6 @@ int bpf_usdt_arg_cnt(struct pt_regs *ctx)
 	return spec->arg_cnt;
 }
 
-/* Returns the size in bytes of the #*arg_num* (zero-indexed) USDT argument.
- * Returns negative error if argument is not found or arg_num is invalid.
- */
-static __always_inline
-int bpf_usdt_arg_size(struct pt_regs *ctx, __u64 arg_num)
-{
-	struct __bpf_usdt_arg_spec *arg_spec;
-	struct __bpf_usdt_spec *spec;
-	int spec_id;
-
-	spec_id = __bpf_usdt_spec_id(ctx);
-	if (spec_id < 0)
-		return -ESRCH;
-
-	spec = bpf_map_lookup_elem(&__bpf_usdt_specs, &spec_id);
-	if (!spec)
-		return -ESRCH;
-
-	if (arg_num >= BPF_USDT_MAX_ARG_CNT)
-		return -ENOENT;
-	barrier_var(arg_num);
-	if (arg_num >= spec->arg_cnt)
-		return -ENOENT;
-
-	arg_spec = &spec->args[arg_num];
-
-	/* arg_spec->arg_bitshift = 64 - arg_sz * 8
-	 * so: arg_sz = (64 - arg_spec->arg_bitshift) / 8
-	 */
-	return (unsigned int)(64 - arg_spec->arg_bitshift) / 8;
-}
-
 /* Fetch USDT argument #*arg_num* (zero-indexed) and put its value into *res.
  * Returns 0 on success; negative error, otherwise.
  * On error *res is guaranteed to be set to zero.

src/usdt.c

@@ -20,7 +20,6 @@
 #include "libbpf_common.h"
 #include "libbpf_internal.h"
 #include "hashmap.h"
-#include "str_error.h"
 
 /* libbpf's USDT support consists of BPF-side state/code and user-space
  * state/code working together in concert. BPF-side parts are defined in
@@ -466,8 +465,8 @@ static int parse_vma_segs(int pid, const char *lib_path, struct elf_seg **segs,
 		goto proceed;
 
 	if (!realpath(lib_path, path)) {
-		pr_warn("usdt: failed to get absolute path of '%s' (err %s), using path as is...\n",
-			lib_path, errstr(-errno));
+		pr_warn("usdt: failed to get absolute path of '%s' (err %d), using path as is...\n",
+			lib_path, -errno);
 		libbpf_strlcpy(path, lib_path, sizeof(path));
 	}
 
@@ -476,8 +475,8 @@ proceed:
 	f = fopen(line, "re");
 	if (!f) {
 		err = -errno;
-		pr_warn("usdt: failed to open '%s' to get base addr of '%s': %s\n",
-			line, lib_path, errstr(err));
+		pr_warn("usdt: failed to open '%s' to get base addr of '%s': %d\n",
+			line, lib_path, err);
 		return err;
 	}
 
@@ -607,8 +606,7 @@ static int collect_usdt_targets(struct usdt_manager *man, Elf *elf, const char *
 
 	err = parse_elf_segs(elf, path, &segs, &seg_cnt);
 	if (err) {
-		pr_warn("usdt: failed to process ELF program segments for '%s': %s\n",
-			path, errstr(err));
+		pr_warn("usdt: failed to process ELF program segments for '%s': %d\n", path, err);
 		goto err_out;
 	}
 
@@ -661,7 +659,7 @@ static int collect_usdt_targets(struct usdt_manager *man, Elf *elf, const char *
 		 *   [0] https://sourceware.org/systemtap/wiki/UserSpaceProbeImplementation
 		 */
 		usdt_abs_ip = note.loc_addr;
-		if (base_addr && note.base_addr)
+		if (base_addr)
 			usdt_abs_ip += base_addr - note.base_addr;
 
 		/* When attaching uprobes (which is what USDTs basically are)
@@ -710,8 +708,8 @@ static int collect_usdt_targets(struct usdt_manager *man, Elf *elf, const char *
 			if (vma_seg_cnt == 0) {
 				err = parse_vma_segs(pid, path, &vma_segs, &vma_seg_cnt);
 				if (err) {
-					pr_warn("usdt: failed to get memory segments in PID %d for shared library '%s': %s\n",
-						pid, path, errstr(err));
+					pr_warn("usdt: failed to get memory segments in PID %d for shared library '%s': %d\n",
+						pid, path, err);
 					goto err_out;
 				}
 			}
@@ -1049,8 +1047,8 @@ struct bpf_link *usdt_manager_attach_usdt(struct usdt_manager *man, const struct
 
 		if (is_new && bpf_map_update_elem(spec_map_fd, &spec_id, &target->spec, BPF_ANY)) {
 			err = -errno;
-			pr_warn("usdt: failed to set USDT spec #%d for '%s:%s' in '%s': %s\n",
-				spec_id, usdt_provider, usdt_name, path, errstr(err));
+			pr_warn("usdt: failed to set USDT spec #%d for '%s:%s' in '%s': %d\n",
+				spec_id, usdt_provider, usdt_name, path, err);
 			goto err_out;
 		}
 		if (!man->has_bpf_cookie &&
@@ -1060,9 +1058,9 @@ struct bpf_link *usdt_manager_attach_usdt(struct usdt_manager *man, const struct
 				pr_warn("usdt: IP collision detected for spec #%d for '%s:%s' in '%s'\n",
 				        spec_id, usdt_provider, usdt_name, path);
 			} else {
-				pr_warn("usdt: failed to map IP 0x%lx to spec #%d for '%s:%s' in '%s': %s\n",
+				pr_warn("usdt: failed to map IP 0x%lx to spec #%d for '%s:%s' in '%s': %d\n",
 					target->abs_ip, spec_id, usdt_provider, usdt_name,
-					path, errstr(err));
+					path, err);
 			}
 			goto err_out;
 		}
@@ -1078,8 +1076,8 @@ struct bpf_link *usdt_manager_attach_usdt(struct usdt_manager *man, const struct
 								      target->rel_ip, &opts);
 			err = libbpf_get_error(uprobe_link);
 			if (err) {
-				pr_warn("usdt: failed to attach uprobe #%d for '%s:%s' in '%s': %s\n",
-					i, usdt_provider, usdt_name, path, errstr(err));
+				pr_warn("usdt: failed to attach uprobe #%d for '%s:%s' in '%s': %d\n",
+					i, usdt_provider, usdt_name, path, err);
 				goto err_out;
 			}
 
@@ -1101,8 +1099,8 @@ struct bpf_link *usdt_manager_attach_usdt(struct usdt_manager *man, const struct
 								    NULL, &opts_multi);
 		if (!link->multi_link) {
 			err = -errno;
-			pr_warn("usdt: failed to attach uprobe multi for '%s:%s' in '%s': %s\n",
-				usdt_provider, usdt_name, path, errstr(err));
+			pr_warn("usdt: failed to attach uprobe multi for '%s:%s' in '%s': %d\n",
+				usdt_provider, usdt_name, path, err);
 			goto err_out;
 		}