Message-Id: <20250411-many_args_arm64-v1-0-0a32fe72339e@bootlin.com>
Date: Fri, 11 Apr 2025 22:32:09 +0200
From: Alexis Lothoré (eBPF Foundation) <alexis.lothore@...tlin.com>
To: Alexei Starovoitov <ast@...nel.org>, 
 Daniel Borkmann <daniel@...earbox.net>, 
 John Fastabend <john.fastabend@...il.com>, 
 Andrii Nakryiko <andrii@...nel.org>, 
 Martin KaFai Lau <martin.lau@...ux.dev>, 
 Eduard Zingerman <eddyz87@...il.com>, Song Liu <song@...nel.org>, 
 Yonghong Song <yonghong.song@...ux.dev>, KP Singh <kpsingh@...nel.org>, 
 Stanislav Fomichev <sdf@...ichev.me>, Hao Luo <haoluo@...gle.com>, 
 Jiri Olsa <jolsa@...nel.org>, Puranjay Mohan <puranjay@...nel.org>, 
 Xu Kuohai <xukuohai@...weicloud.com>, 
 Catalin Marinas <catalin.marinas@....com>, Will Deacon <will@...nel.org>, 
 Mykola Lysenko <mykolal@...com>, Shuah Khan <shuah@...nel.org>, 
 Maxime Coquelin <mcoquelin.stm32@...il.com>, 
 Alexandre Torgue <alexandre.torgue@...s.st.com>, 
 Florent Revest <revest@...omium.org>
Cc: Bastien Curutchet <bastien.curutchet@...tlin.com>, 
 ebpf@...uxfoundation.org, Thomas Petazzoni <thomas.petazzoni@...tlin.com>, 
 bpf@...r.kernel.org, linux-kernel@...r.kernel.org, 
 linux-arm-kernel@...ts.infradead.org, linux-kselftest@...r.kernel.org, 
 linux-stm32@...md-mailman.stormreply.com, 
 Alexis Lothoré (eBPF Foundation) <alexis.lothore@...tlin.com>, 
 Xu Kuohai <xukuohai@...wei.com>
Subject: [PATCH RFC bpf-next 0/4] bpf, arm64: support up to 12 arguments

Hello,

this series is a revival of Xu Kuhoai's work to enable larger arguments
count for BPF programs on ARM64 ([1]). His initial series received some
positive feedback, but lacked some specific case handling around
arguments alignment (see AAPCS64 C.14 rule in section 6.8.2, [2]). There
as been another attempt from Puranjay Mohan, which was unfortunately
missing the same thing ([3]).  Since there has been some time between
those series and this new one, I chose to send it as a new series
rather than a new revision of the existing series.

To support the increased argument counts and arguments larger than
registers size (eg: structures), the trampoline does the following:
- for bpf  programs: arguments are retrieved from both registers and the
  function stack, and pushed in the trampoline stack as an array of u64
  to generate the programs context. It is then passed by pointer to the
  bpf programs
- when the trampoline is in charge of calling the original function: it
  restores the registers content, and generates a new stack layout for
  the additional arguments that do not fit in registers.

This new attempt is based on Xu's series and aims to handle the
missing alignment concern raised in the reviews discussions. The main
novelties are then around arguments alignments:
- the first commit is exposing some new info in the BTF function model
  passed to the JIT compiler to allow it to deduce the needed alignment
  when configuring the trampoline stack
- the second commit is taken from Xu's series, and received the
  following modifications:
  - the calc_aux_args computes an expected alignment for each argument
  - the calc_aux_args computes two different stack space sizes: the one
    needed to store the bpf programs context, and the original function
    stacked arguments (which needs alignment). Those stack sizes are in
    bytes instead of "slots"
  - when saving/restoring arguments for bpf program or for the original
    function, make sure to align the load/store accordingly, when
    relevant
  - a few typos fixes and some rewording, raised by the review on the
    original series
- the last commit introduces some explicit tests that ensure that the
  needed alignment is enforced by the trampoline

I marked the series as RFC because it appears that the new tests trigger
some failures in CI on x86 and s390, despite the series not touching any
code related to those architectures. Some very early investigation/gdb
debugging on the x86 side seems to hint that it could be related to the
same missing alignment too (based on section 3.2.3 in [4], and so the
x86 trampoline would need the same alignment handling ?). For s390 it
looks less clear, as all values captured from the bpf test program are
set to 0 in the CI output, and I don't have the proper setup yet to
check the low level details.  I am tempted to isolate those new tests
(which were actually useful to spot real issues while tuning the ARM64
trampoline) and add them to the relevant DENYLIST files for x86/s390,
but I guess this is not the right direction, so I would gladly take a
second opinion on this.

[1] https://lore.kernel.org/all/20230917150752.69612-1-xukuohai@huaweicloud.com/#t
[2] https://github.com/ARM-software/abi-aa/blob/main/aapcs64/aapcs64.rst#id82
[3] https://lore.kernel.org/bpf/20240705125336.46820-1-puranjay@kernel.org/
[4] https://refspecs.linuxbase.org/elf/x86_64-abi-0.99.pdf

Signed-off-by: Alexis Lothoré (eBPF Foundation) <alexis.lothore@...tlin.com>
---
Alexis Lothoré (eBPF Foundation) (3):
      bpf: add struct largest member size in func model
      bpf/selftests: add tests to validate proper arguments alignment on ARM64
      bpf/selftests: enable tracing tests for ARM64

Xu Kuohai (1):
      bpf, arm64: Support up to 12 function arguments

 arch/arm64/net/bpf_jit_comp.c                      | 235 ++++++++++++++++-----
 include/linux/bpf.h                                |   1 +
 kernel/bpf/btf.c                                   |  25 +++
 tools/testing/selftests/bpf/DENYLIST.aarch64       |   3 -
 .../selftests/bpf/prog_tests/tracing_struct.c      |  23 ++
 tools/testing/selftests/bpf/progs/tracing_struct.c |  10 +-
 .../selftests/bpf/progs/tracing_struct_many_args.c |  67 ++++++
 .../testing/selftests/bpf/test_kmods/bpf_testmod.c |  50 +++++
 8 files changed, 357 insertions(+), 57 deletions(-)
---
base-commit: 91e7eb701b4bc389e7ddfd80ef6e82d1a6d2d368
change-id: 20250220-many_args_arm64-8bd3747e6948

Best regards,
-- 
Alexis Lothoré, Bootlin
Embedded Linux and Kernel engineering
https://bootlin.com

Powered by blists - more mailing lists