From nobody Thu Dec 18 00:10:41 2025 Received: from m16.mail.163.com (m16.mail.163.com [220.197.31.4]) by smtp.subspace.kernel.org (Postfix) with ESMTP id 6735E286D7D; Mon, 18 Aug 2025 07:47:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=220.197.31.4 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755503230; cv=none; b=DmWcuteDcf97inGPqTwitHJoX054PWX1Yz7CdaOlxdT3lTTG9AfTticBdUBtwiOIUiPq/ciQN34ySERQyPZybQxySbr6FfC428SDClZ/+1EAvnOdw6efsdbwWzmT6pPURSdsc99x7O385DmePBtGUEdmXrQlsqdQzqfxOQfu7Ec= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755503230; c=relaxed/simple; bh=rPbxrG6DiKDjudUDxS0OBzpk+OOY8JHG8K9CbaYtaqc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=AC8HULMLDgLNlAMOaTaKuRRJREu1WbMDLgdqU4G5YOEc0nt8o/YXE6VjWn19fY8pTeAvE1a+ikhbbao6PBVW4J88J2K0Hg/k8H71d80Q1JReLWuRk/9D7Msr/3X2lcIu6wXX56T79O3Ujx8TnomqrRjWB8sOaof4UKnExPKlqYY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=163.com; spf=pass smtp.mailfrom=163.com; dkim=pass (1024-bit key) header.d=163.com header.i=@163.com header.b=FcnszTaw; arc=none smtp.client-ip=220.197.31.4 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=163.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=163.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=163.com header.i=@163.com header.b="FcnszTaw" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:To:Subject:Date:Message-ID:MIME-Version; bh=dY vma5Rn63lla7bKiqS7gekg8+4QdkOsCcO+uwGtMUQ=; b=FcnszTaw53YA7sMwQk wJRh/7I5vth+E2pNSCXg56iiVvi48+JihuxdZfJS2Gk2iZDH8mihNXUg492DmHYz y/lCRNRF8ItaD6Hs1RwwcQthW1QhI9mzYAWuWUeEyi+AQHN41Z+DF47eUt574ly2 2iD/Mklh1tCFtyTAW7fYozkG8= Received: from phoenix.. (unknown []) by gzga-smtp-mtada-g0-3 (Coremail) with SMTP id _____wBH_+VZ2qJoyxi9Cg--.52195S3; Mon, 18 Aug 2025 15:46:36 +0800 (CST) From: Jiawei Zhao To: ast@kernel.org Cc: daniel@iogearbox.net, andrii@kernel.org, yonghong.song@linux.dev, bpf@vger.kernel.org, linux-kselftest@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH bpf-next v11 1/3] libbpf: fix USDT SIB argument handling causing unrecognized register error Date: Mon, 18 Aug 2025 07:46:30 +0000 Message-ID: <20250818074632.433008-2-phoenix500526@163.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250818074632.433008-1-phoenix500526@163.com> References: <20250818074632.433008-1-phoenix500526@163.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-CM-TRANSID: _____wBH_+VZ2qJoyxi9Cg--.52195S3 X-Coremail-Antispam: 1Uf129KBjvJXoWxtryfArWkXF4kJr48Xw47urg_yoW3WFy7pa 109r9ayry8Jr4SvF4fX3WFya43CFs7Gr4rAr1kta4YvFWxWr4UXrySkF1Ykrn8Ka47tF43 XF4YqrWxCFy7Zr7anT9S1TB71UUUUU7qnTZGkaVYY2UrUUUUjbIjqfuFe4nvWSU5nxnvy2 9KBjDUYxBIdaVFxhVjvjDU0xZFpf9x07jzlksUUUUU= X-CM-SenderInfo: pskrv0dl0viiqvswqiywtou0bp/xtbBgB2tiGii15JBvwAAsJ Content-Type: text/plain; charset="utf-8" On x86-64, USDT arguments can be specified using Scale-Index-Base (SIB) addressing, e.g. "1@-96(%rbp,%rax,8)". The current USDT implementation in libbpf cannot parse this format, causing `bpf_program__attach_usdt()` to fail with -ENOENT (unrecognized register). This patch fixes this by implementing the necessary changes: - add correct handling for SIB-addressed arguments in `bpf_usdt_arg`. - add adaptive support to `__bpf_usdt_arg_type` and `__bpf_usdt_arg_spec` to represent SIB addressing parameters. Signed-off-by: Jiawei Zhao --- tools/lib/bpf/usdt.bpf.h | 54 +++++++++++++++++++++++++++++++++-- tools/lib/bpf/usdt.c | 61 ++++++++++++++++++++++++++++++++++++---- 2 files changed, 108 insertions(+), 7 deletions(-) diff --git a/tools/lib/bpf/usdt.bpf.h b/tools/lib/bpf/usdt.bpf.h index 2a7865c8e3fe..1e6de0afe65d 100644 --- a/tools/lib/bpf/usdt.bpf.h +++ b/tools/lib/bpf/usdt.bpf.h @@ -34,13 +34,31 @@ enum __bpf_usdt_arg_type { BPF_USDT_ARG_CONST, BPF_USDT_ARG_REG, BPF_USDT_ARG_REG_DEREF, + BPF_USDT_ARG_SIB, }; =20 +/* + * To preserve overall layout and avoid growing this struct while adding S= IB + * extras, we keep 4 bytes worth of space after val_off: + * + * - arg_type is stored as a single byte (values from enum below) + * - idx_packed is a 16-bit field packing idx_reg_off (high 12 bits) + * and scale shift (low 4 bits, i.e., scale =3D 1 << shift) + * - reserved is one spare byte for future use + * + * This keeps the offset of reg_off identical to the historical layout + * (val_off:8 + 4 bytes here), ensuring backwards/forwards compatibility f= or + * non-SIB modes that only rely on val_off/arg_type/reg_off/... offsets. + */ struct __bpf_usdt_arg_spec { /* u64 scalar interpreted depending on arg_type, see below */ __u64 val_off; /* arg location case, see bpf_usdt_arg() for details */ - enum __bpf_usdt_arg_type arg_type; + __u8 arg_type; + /* packed: [15:4] idx_reg_off, [3:0] scale_shift */ + __u16 idx_packed; + /* reserved for future use, keeps reg_off offset stable */ + __u8 reserved; /* offset of referenced register within struct pt_regs */ short reg_off; /* whether arg should be interpreted as signed value */ @@ -52,6 +70,10 @@ struct __bpf_usdt_arg_spec { char arg_bitshift; }; =20 +/* Helpers to (un)pack SIB extras from idx_packed without relying on bitfi= elds. */ +#define USDT_IDX_OFF(packed) ((packed) >> 4) +#define USDT_IDX_SCALE_SHIFT(packed) ((packed) & 0x000f) + /* should match USDT_MAX_ARG_CNT in usdt.c exactly */ #define BPF_USDT_MAX_ARG_CNT 12 struct __bpf_usdt_spec { @@ -149,8 +171,9 @@ int bpf_usdt_arg(struct pt_regs *ctx, __u64 arg_num, lo= ng *res) { struct __bpf_usdt_spec *spec; struct __bpf_usdt_arg_spec *arg_spec; - unsigned long val; + unsigned long val, idx; int err, spec_id; + int idx_off =3D 0, scale =3D 0; =20 *res =3D 0; =20 @@ -202,6 +225,33 @@ int bpf_usdt_arg(struct pt_regs *ctx, __u64 arg_num, l= ong *res) return err; #if __BYTE_ORDER__ =3D=3D __ORDER_BIG_ENDIAN__ val >>=3D arg_spec->arg_bitshift; +#endif + break; + case BPF_USDT_ARG_SIB: + /* Arg is in memory addressed by SIB (Scale-Index-Base) mode + * (e.g., "-1@-96(%rbp,%rax,8)" in USDT arg spec). Register + * is identified like with BPF_USDT_ARG_SIB case, the offset + * is in arg_spec->val_off, the scale factor is in arg_spec->scale. + * Firstly, we fetch the base register contents and the index + * register contents from pt_regs. Secondly, we multiply the + * index register contents by the scale factor, then add the + * base address and the offset to get the final address. Finally, + * we do another user-space probe read to fetch argument value + * itself. + */ + idx_off =3D USDT_IDX_OFF(arg_spec->idx_packed); + scale =3D 1UL << USDT_IDX_SCALE_SHIFT(arg_spec->idx_packed); + err =3D bpf_probe_read_kernel(&val, sizeof(val), (void *)ctx + arg_spec-= >reg_off); + if (err) + return err; + err =3D bpf_probe_read_kernel(&idx, sizeof(idx), (void *)ctx + idx_off); + if (err) + return err; + err =3D bpf_probe_read_user(&val, sizeof(val), (void *)val + idx * scale= + arg_spec->val_off); + if (err) + return err; +#if __BYTE_ORDER__ =3D=3D __ORDER_BIG_ENDIAN__ + val >>=3D arg_spec->arg_bitshift; #endif break; default: diff --git a/tools/lib/bpf/usdt.c b/tools/lib/bpf/usdt.c index 3373b9d45ac4..0a6499f654fc 100644 --- a/tools/lib/bpf/usdt.c +++ b/tools/lib/bpf/usdt.c @@ -200,12 +200,15 @@ enum usdt_arg_type { USDT_ARG_CONST, USDT_ARG_REG, USDT_ARG_REG_DEREF, + USDT_ARG_SIB, }; =20 /* should match exactly struct __bpf_usdt_arg_spec from usdt.bpf.h */ struct usdt_arg_spec { __u64 val_off; - enum usdt_arg_type arg_type; + __u8 arg_type; /* enum value stored as u8 */ + __u16 idx_packed; /* [15:4]=3Didx_reg_off, [3:0]=3Dscale_shift */ + __u8 reserved; /* keep reg_off offset stable */ short reg_off; bool arg_signed; char arg_bitshift; @@ -214,6 +217,10 @@ struct usdt_arg_spec { /* should match BPF_USDT_MAX_ARG_CNT in usdt.bpf.h */ #define USDT_MAX_ARG_CNT 12 =20 +/* Helpers to (un)pack SIB extras from idx_packed without relying on bitfi= elds. */ +#define BPF_USDT_IDX_PACK(idx_off, scale_shift) \ + ((__u16)(((__u16)((idx_off) & 0x0fff)) << 4) | (__u16)((scale_shift) & 0x= 000f)) + /* should match struct __bpf_usdt_spec from usdt.bpf.h */ struct usdt_spec { struct usdt_arg_spec args[USDT_MAX_ARG_CNT]; @@ -1283,11 +1290,54 @@ static int calc_pt_regs_off(const char *reg_name) =20 static int parse_usdt_arg(const char *arg_str, int arg_num, struct usdt_ar= g_spec *arg, int *arg_sz) { - char reg_name[16]; - int len, reg_off; - long off; + char reg_name[16] =3D {0}, idx_reg_name[16] =3D {0}; + int len, reg_off, idx_reg_off, scale =3D 1; + long off =3D 0; + __u16 scale_shift; + + if (sscanf(arg_str, " %d @ %ld ( %%%15[^,] , %%%15[^,] , %d ) %n", + arg_sz, &off, reg_name, idx_reg_name, &scale, &len) =3D=3D 5 || + sscanf(arg_str, " %d @ ( %%%15[^,] , %%%15[^,] , %d ) %n", + arg_sz, reg_name, idx_reg_name, &scale, &len) =3D=3D 4 || + sscanf(arg_str, " %d @ %ld ( %%%15[^,] , %%%15[^)] ) %n", + arg_sz, &off, reg_name, idx_reg_name, &len) =3D=3D 4 || + sscanf(arg_str, " %d @ ( %%%15[^,] , %%%15[^)] ) %n", + arg_sz, reg_name, idx_reg_name, &len) =3D=3D 3 + ) { + /* + * Scale Index Base case: + * 1@-96(%rbp,%rax,8) + * 1@(%rbp,%rax,8) + * 1@-96(%rbp,%rax) + * 1@(%rbp,%rax) + */ + arg->arg_type =3D USDT_ARG_SIB; + arg->val_off =3D off; =20 - if (sscanf(arg_str, " %d @ %ld ( %%%15[^)] ) %n", arg_sz, &off, reg_name,= &len) =3D=3D 3) { + reg_off =3D calc_pt_regs_off(reg_name); + if (reg_off < 0) + return reg_off; + arg->reg_off =3D reg_off; + + idx_reg_off =3D calc_pt_regs_off(idx_reg_name); + if (idx_reg_off < 0) + return idx_reg_off; + /* pack idx_reg_off and scale shift (scale in {1,2,4,8}) */ + if (scale =3D=3D 1) + scale_shift =3D 0; + else if (scale =3D=3D 2) + scale_shift =3D 1; + else if (scale =3D=3D 4) + scale_shift =3D 2; + else if (scale =3D=3D 8) + scale_shift =3D 3; + else { + pr_warn("usdt: invalid SIB scale %d, expected 1,2,4,8; defaulting to 1\= n", scale); + return -EINVAL; + } + arg->idx_packed =3D BPF_USDT_IDX_PACK(idx_reg_off, scale_shift); + } else if (sscanf(arg_str, " %d @ %ld ( %%%15[^)] ) %n", + arg_sz, &off, reg_name, &len) =3D=3D 3) { /* Memory dereference case, e.g., -4@-20(%rbp) */ arg->arg_type =3D USDT_ARG_REG_DEREF; arg->val_off =3D off; @@ -1306,6 +1356,7 @@ static int parse_usdt_arg(const char *arg_str, int ar= g_num, struct usdt_arg_spec } else if (sscanf(arg_str, " %d @ %%%15s %n", arg_sz, reg_name, &len) =3D= =3D 2) { /* Register read case, e.g., -4@%eax */ arg->arg_type =3D USDT_ARG_REG; + /* register read has no memory offset */ arg->val_off =3D 0; =20 reg_off =3D calc_pt_regs_off(reg_name); --=20 2.43.0 From nobody Thu Dec 18 00:10:41 2025 Received: from m16.mail.163.com (m16.mail.163.com [117.135.210.3]) by smtp.subspace.kernel.org (Postfix) with ESMTP id 18E89285CBB; Mon, 18 Aug 2025 07:47:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=117.135.210.3 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755503224; cv=none; b=Ki5316OWMxsjv/FnseJXOfRp+ZQ8kgG+Y9lRmyucJ5Zpp5zUjkcPttsDxSgcslqktKL7tg7c5rb3kYu9erZP/zR4RezLWRl/AsjYAnacDqjpFZG/b1JkTjVxJ75GdaczKVOO1pMjXeotxIT2xtIuNjZ50StJhQmvj1Qke6TIyKc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755503224; c=relaxed/simple; bh=g2jUZAuYi24+QU2qGp6Zb96EwojciRbSSB935od7Blk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=pbOl3XUBaJqGsAUsf3JwPLx7ER3aF/uNCPhR66JEW2cr++t4wTSFPVESdEatK6vMWbjjL3TM3hiF/wF1uFgr6X6YgOwUN2kBtHRVxdoMfKnoBnfPFoUqyJQifWZUYtpyaMk+4qSTkHIadfrJCzO3Hbcqrnvn46IQe/UK1I3P4Iw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=163.com; spf=pass smtp.mailfrom=163.com; dkim=pass (1024-bit key) header.d=163.com header.i=@163.com header.b=VGuWfVZs; arc=none smtp.client-ip=117.135.210.3 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=163.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=163.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=163.com header.i=@163.com header.b="VGuWfVZs" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:To:Subject:Date:Message-ID:MIME-Version; bh=c9 qrcvdxKocK0bjalVk19qiGqr1nlSGCxN8y/9RqBP4=; b=VGuWfVZswRrreXIbV3 KHlRJBLqXrn97jnlRqQlXK4A7fygVtFUlm/5PVDAuJlCIo1j7zJPlbz5o4pghVlb m79lZb3a949Uu2wXI2KI7VymDfYdfNGX1y7XjBWWbrdDvQGk1Ka62LM5JBfulfka p8oHdBWRQIDI3lJ+A4Ds7i/tc= Received: from phoenix.. (unknown []) by gzga-smtp-mtada-g0-3 (Coremail) with SMTP id _____wBH_+VZ2qJoyxi9Cg--.52195S4; Mon, 18 Aug 2025 15:46:36 +0800 (CST) From: Jiawei Zhao To: ast@kernel.org Cc: daniel@iogearbox.net, andrii@kernel.org, yonghong.song@linux.dev, bpf@vger.kernel.org, linux-kselftest@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH bpf-next v11 2/3] selftests/bpf: Add an usdt_o1 test case in selftests to cover SIB handling logic Date: Mon, 18 Aug 2025 07:46:31 +0000 Message-ID: <20250818074632.433008-3-phoenix500526@163.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250818074632.433008-1-phoenix500526@163.com> References: <20250818074632.433008-1-phoenix500526@163.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-CM-TRANSID: _____wBH_+VZ2qJoyxi9Cg--.52195S4 X-Coremail-Antispam: 1Uf129KBjvJXoWxWw4ktF4fArWkKr48WFyUJrb_yoWrWFyrpa 48XryFkFWIqF13Kw1Sqr4Uta1rtanayry8AFykXF1avr48WFWxXrn7Kr17tF93J3ykZF1r Aa9xtan8Kr48JF7anT9S1TB71UUUUU7qnTZGkaVYY2UrUUUUjbIjqfuFe4nvWSU5nxnvy2 9KBjDUYxBIdaVFxhVjvjDU0xZFpf9x07jqeHDUUUUU= X-CM-SenderInfo: pskrv0dl0viiqvswqiywtou0bp/1tbiFB+tiGii08WexQAAsp Content-Type: text/plain; charset="utf-8" When using GCC on x86-64 to compile an usdt prog with -O1 or higher optimization, the compiler will generate SIB addressing mode for global array and PC-relative addressing mode for global variable, e.g. "1@-96(%rbp,%rax,8)" and "-1@4+t1(%rip)". In this patch: - add usdt_o1 test case to cover SIB addressing usdt argument spec handling logic Signed-off-by: Jiawei Zhao --- .../selftests/bpf/prog_tests/usdt_o1.c | 70 +++++++++++++++++++ .../selftests/bpf/progs/test_usdt_o1.c | 37 ++++++++++ 2 files changed, 107 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/usdt_o1.c create mode 100644 tools/testing/selftests/bpf/progs/test_usdt_o1.c diff --git a/tools/testing/selftests/bpf/prog_tests/usdt_o1.c b/tools/testi= ng/selftests/bpf/prog_tests/usdt_o1.c new file mode 100644 index 000000000000..706168e804cb --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/usdt_o1.c @@ -0,0 +1,70 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2025 Jiawei Zhao . */ +#include + +#include "../sdt.h" +#include "test_usdt_o1.skel.h" + +#if (defined(__GNUC__) && !defined(__clang__)) +#pragma GCC optimize("O1") +#else +#pragma message("non-gcc compiler: the correct probes might not be install= ed") +#endif + + +#define test_value 0xFEDCBA9876543210ULL +#define SEC(name) __attribute__((section(name), used)) + +int lets_test_this(int); +static volatile __u64 array[1] =3D {test_value}; + +static __always_inline void trigger_func(void) +{ + /* Base address + offset + (index * scale) */ + for (volatile int i =3D 0; i <=3D 0; i++) + STAP_PROBE1(test, usdt1, array[i]); +} + +static void basic_sib_usdt(void) +{ + LIBBPF_OPTS(bpf_usdt_opts, opts); + struct test_usdt_o1 *skel; + struct test_usdt_o1__bss *bss; + int err; + + skel =3D test_usdt_o1__open_and_load(); + if (!ASSERT_OK_PTR(skel, "skel_open")) + return; + + bss =3D skel->bss; + bss->my_pid =3D getpid(); + + err =3D test_usdt_o1__attach(skel); + if (!ASSERT_OK(err, "skel_attach")) + goto cleanup; + + /* usdt1 won't be auto-attached */ + opts.usdt_cookie =3D 0xcafedeadbeeffeed; + skel->links.usdt1 =3D bpf_program__attach_usdt(skel->progs.usdt1, + 0 /*self*/, "/proc/self/exe", + "test", "usdt1", &opts); + if (!ASSERT_OK_PTR(skel->links.usdt1, "usdt1_link")) + goto cleanup; + + trigger_func(); + + ASSERT_EQ(bss->usdt1_called, 1, "usdt1_called"); + ASSERT_EQ(bss->usdt1_cookie, 0xcafedeadbeeffeed, "usdt1_cookie"); + ASSERT_EQ(bss->usdt1_arg_cnt, 1, "usdt1_arg_cnt"); + ASSERT_EQ(bss->usdt1_arg, test_value, "usdt1_arg"); + ASSERT_EQ(bss->usdt1_arg_ret, 0, "usdt1_arg_ret"); + ASSERT_EQ(bss->usdt1_arg_size, sizeof(array[0]), "usdt1_arg_size"); + +cleanup: + test_usdt_o1__destroy(skel); +} + +void test_usdt_o1(void) +{ + basic_sib_usdt(); +} diff --git a/tools/testing/selftests/bpf/progs/test_usdt_o1.c b/tools/testi= ng/selftests/bpf/progs/test_usdt_o1.c new file mode 100644 index 000000000000..14602aa54578 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/test_usdt_o1.c @@ -0,0 +1,37 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2022 Meta Platforms, Inc. and affiliates. */ + +#include "vmlinux.h" +#include +#include + +int my_pid; + +int usdt1_called; +u64 usdt1_cookie; +int usdt1_arg_cnt; +int usdt1_arg_ret; +u64 usdt1_arg; +int usdt1_arg_size; + +SEC("usdt") +int usdt1(struct pt_regs *ctx) +{ + long tmp; + + if (my_pid !=3D (bpf_get_current_pid_tgid() >> 32)) + return 0; + + __sync_fetch_and_add(&usdt1_called, 1); + + usdt1_cookie =3D bpf_usdt_cookie(ctx); + usdt1_arg_cnt =3D bpf_usdt_arg_cnt(ctx); + + usdt1_arg_ret =3D bpf_usdt_arg(ctx, 0, &tmp); + usdt1_arg =3D (u64)tmp; + usdt1_arg_size =3D bpf_usdt_arg_size(ctx, 0); + + return 0; +} + +char _license[] SEC("license") =3D "GPL"; --=20 2.43.0 From nobody Thu Dec 18 00:10:41 2025 Received: from m16.mail.163.com (m16.mail.163.com [220.197.31.5]) by smtp.subspace.kernel.org (Postfix) with ESMTP id E4AD328724A; Mon, 18 Aug 2025 07:47:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=220.197.31.5 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755503230; cv=none; b=r1bHn9FeEjkNGTCmZ+jKjxdzVEVOB70gF+86sg/xx3gtegdenCwJpOCTdcpCEtO6zR+3O1Ip3PVMTcdEX5uBvrwBgmo1YFXNXpViwKDq5k9uNB0rXmAR2juFPUoDQ3Vrjn3ad1X0sLhfhaAJQm3JwLV3Qc48Chw/BYXB6Hsb4OE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755503230; c=relaxed/simple; bh=afPpq7m4/xuyQ3D2C1DuWGZ7+Me4LQ35vmaUTT4sl1c=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=qdt0BKfQ9C82KkVA3f5ee0AGM9fEsF/Dxd8d8TxrAGhIwFYxF9Zfy7rJ/amcpwx3MdL8iA/N+dhkmmbdTSu72DvwE8Ef1bdBIGEs0/R4zvI0eQ7se4Qy1xflhr7KhX2eqlS65G2P9Wvqq/CEl3hL78wb8EpR8Ticu461jnTeYBM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=163.com; spf=pass smtp.mailfrom=163.com; dkim=pass (1024-bit key) header.d=163.com header.i=@163.com header.b=K+BiXooO; arc=none smtp.client-ip=220.197.31.5 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=163.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=163.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=163.com header.i=@163.com header.b="K+BiXooO" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:To:Subject:Date:Message-ID:MIME-Version; bh=4r rb74iAfdmka58R5C+cn4MZVGRAiWBiJRY75p/xBeA=; b=K+BiXooO1hq+hl1XlT rAdRNKAtb6XOHn6unPJVI5Nqy2jFv8Qy2nhcqvL7/IlRCLOcuK9QeZei+e+mS+M/ b1o7BEzncHL7K29hT7ImD8WO0DcaDu3KB6iy6HWKocm+GmLNkDkGHxTHK8E/hlTO rNXL8tnNRMhPmIPUkxVMQZkg4= Received: from phoenix.. (unknown []) by gzga-smtp-mtada-g0-3 (Coremail) with SMTP id _____wBH_+VZ2qJoyxi9Cg--.52195S5; Mon, 18 Aug 2025 15:46:37 +0800 (CST) From: Jiawei Zhao To: ast@kernel.org Cc: daniel@iogearbox.net, andrii@kernel.org, yonghong.song@linux.dev, bpf@vger.kernel.org, linux-kselftest@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH bpf-next v11 3/3] selftests/bpf: make usdt_o1 reliably generate SIB USDT arg spec Date: Mon, 18 Aug 2025 07:46:32 +0000 Message-ID: <20250818074632.433008-4-phoenix500526@163.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250818074632.433008-1-phoenix500526@163.com> References: <20250818074632.433008-1-phoenix500526@163.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-CM-TRANSID: _____wBH_+VZ2qJoyxi9Cg--.52195S5 X-Coremail-Antispam: 1Uf129KBjvJXoWxZF13Ww47CFWfur45Aw1rtFb_yoW5Xr4fpa 4kGayYkF1vqFyfA34fXr47Z3WrKF1kZFW8AFWktr1j9F1UXry8Xr4xK3WYvr9Yk3yF934Y v3y8t3s8uF48Aw7anT9S1TB71UUUUU7qnTZGkaVYY2UrUUUUjbIjqfuFe4nvWSU5nxnvy2 9KBjDUYxBIdaVFxhVjvjDU0xZFpf9x07j-F4_UUUUU= X-CM-SenderInfo: pskrv0dl0viiqvswqiywtou0bp/1tbiFB+tiGii08WexQABso Content-Type: text/plain; charset="utf-8" usdt_o1 is intended to exercise the SIB (Scale-Index-Base) argument handling in libbpf's USDT path. With GCC 13 this reliably produced a SIB-form argument (e.g. 8@(%rdx,%rax,8)), but with newer GCC (e.g. 15) the compiler frequently optimizes the probe argument into a plain register (e.g. 8@%rax) or a stack slot, so the test stops covering the SIB code path and becomes flaky across toolchains. Force a SIB memory operand in the probe by: * placing the base pointer into %rdx and the index into %rax using an empty inline asm with output constraints ("=3Dd", "=3Da") and matching inputs * immediately passing base[idx] to STAP_PROBE1. * only enable on x86 platform. This makes the compiler encode the operand as SIB (base + index8), which in .note.stapsdt shows up as 8@(%rdx,%rax,8) regardless of GCC version. A memory clobber and noinline prevent reordering/re-allocation around the probe site. This change is x86_64-specific and does not alter program semantics; it only stabilizes the USDT argument shape so the test consistently validates SIB handling. Clang historically prefers stack temporaries for such operands, but the selftests build with GCC, and this keeps behavior stable across GCC versions without introducing a separate .S file. Signed-off-by: Jiawei Zhao --- .../testing/selftests/bpf/prog_tests/usdt_o1.c | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/tools/testing/selftests/bpf/prog_tests/usdt_o1.c b/tools/testi= ng/selftests/bpf/prog_tests/usdt_o1.c index 706168e804cb..6c04519b3757 100644 --- a/tools/testing/selftests/bpf/prog_tests/usdt_o1.c +++ b/tools/testing/selftests/bpf/prog_tests/usdt_o1.c @@ -18,11 +18,19 @@ int lets_test_this(int); static volatile __u64 array[1] =3D {test_value}; =20 -static __always_inline void trigger_func(void) +static noinline void trigger_func(void) { +#if defined(__x86_64__) || defined(__i386__) /* Base address + offset + (index * scale) */ - for (volatile int i =3D 0; i <=3D 0; i++) - STAP_PROBE1(test, usdt1, array[i]); + /* Force SIB addressing with inline assembly */ + const __u64 *base; + __u32 idx; + /* binding base to %rdx and idx to %rax */ + asm volatile("" : "=3Dd"(base), "=3Da"(idx) : "0"(array), "1"((__u32)0) := "memory"); + STAP_PROBE1(test, usdt1, base[idx]); +#else + STAP_PROBE1(test, usdt1, array[0]); +#endif } =20 static void basic_sib_usdt(void) @@ -66,5 +74,9 @@ static void basic_sib_usdt(void) =20 void test_usdt_o1(void) { +#if !defined(__x86_64__) && !defined(__i386__) + test__skip(); + return; +#endif basic_sib_usdt(); } --=20 2.43.0