From nobody Sun Feb 8 21:33:56 2026 Received: from mail-pj1-f41.google.com (mail-pj1-f41.google.com [209.85.216.41]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 42D74280324 for ; Sun, 1 Feb 2026 03:16:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.41 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769915791; cv=none; b=B6iahVewZSQQVk0jmoLh0YNH+ik18umcvNmsdu0J6gpWkhR9/QchUmICuvrzMcZ9alNgATo5a4vr+f7Q8r2StnIwrYiN1LmgnPJKFA54k8kqIJizN44Axuc9abY2oOAcwg/b1krztNjtbpqhZeP4tMEiT57PqddsilRWDskn9FY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769915791; c=relaxed/simple; bh=dwNUmlxcqa+1GX66MgxUDlnEQ+lIyB0CeInZdZx1Ebc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=E/HOYEh/uQ6E29Ywk0DGKiNbECFaKx8WyvAkymZn5RVR4tdsWYNt001WjSUoj1dUPIR3adOSFwv2pLpjrIhZlRzks1YLilrgzltsshvYgghzIBmMXuYLlk8BxotbnzKkim6Sqqy8Opw76lsgAU/J/6EbCWqKLNxGS7zjSwCmUx8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=TQt34JlX; arc=none smtp.client-ip=209.85.216.41 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="TQt34JlX" Received: by mail-pj1-f41.google.com with SMTP id 98e67ed59e1d1-3543b9f60e3so1061174a91.3 for ; Sat, 31 Jan 2026 19:16:30 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1769915789; x=1770520589; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=aGPWhoujPZMCC5voFQpQuLH7IyYWH0J71f2m4GWhuCE=; b=TQt34JlXm0gJ3jbTUuD5/jkvInSwTLJWZFnCz65fr+zlTpHBEMZpO+iQYhXZEZTVQg 3mDlCT1ZhvovzpkZVGjkVTjJBq5j9jEf/3YY2uhNQN0xkWHuTimRuNt32X0TjUsDGLyW yG6I/pjfk2Fh+rmN/tCp6XfGjwYMRnTz9dUuBRiIetbzdRCWs+KUZmf2yhNxsN4z32xt sDryAUVJpso9p8ioeHj9iYyNoVZnITQXcMQ7XTtmXURzpR3cxbz2ATlSvLWZ2/+l+96r tE6w054Kl/SOyIwlUCOxXzHLdF01OeFU7S6zbpygXMCAEcyx9CiO7bu5YsJ0bsFPyMkr ADig== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1769915789; x=1770520589; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=aGPWhoujPZMCC5voFQpQuLH7IyYWH0J71f2m4GWhuCE=; b=mVquk0sdhpkMXCaogxpAC2Cy1ELBwP9iKgWwhS+eqwnsHPG6Xi/IvPmuT2xXgB8w8Y ayrDdFUtNDE7UGZNA3L25NerY+iwV3msgyjejnOhTZp3FhqDq9/dSO6B8poQWfVEHjea qJWhFr8pg0Lj+jiJuhlbPILx27tTNZZnpkYTgr4I0DCbR8PKx/AyIeNLKtO/TasvHY2P bH1C6OCo2HIjFDISFuJI5wYhAZVOq/IXKl9WnFzZ7Ty73O3/LZ7laKInM8B4e1JykyFK aKe2XPO4xZ/HFipbrSEZMza6KSXPRx1PAqhnwkeh4ClgoiAnLCUeOyO5yw3tL0eoefQt 3GYQ== X-Gm-Message-State: AOJu0Yw+anb2SCx6Fs5ZjYxJC7945QVMYoYJnfSFXiQDl+6ek5nT/Xuc ynJtjAiqY02JaHBrDt1hiPFEMB5ZjK0xIeHKQYy95v1PWd3vEo5GxgOf X-Gm-Gg: AZuq6aK6GFA0BvHeW9JYgQ2okcaVvAEYRRrz7S3wnWlJ9TezOkJP14120m4Bxbyi/77 ECEnV/qHstj+bACFSnLkv7ksWztNCGLDvenoppxDgak0mF10cXWJusy237japGSGUNGlLQjjK4D qaU90ZRHWr/px+D9YpT6YgRwteFSIRdTf55zC+GQbHM0xrJgwb54NTwp4OHVscwXtnuM9yxjsXy SOMloloP6ML3OGLh/Nf2nlOhJLXVaYaDacTHbY5A7SbbEm4rE+rCAyXR5DMbHJSrl24ADjfD1NK XV3+Rxp246HCPwBY3sgfpXbN6z8N0WhnW6QD1rQuXvKbFjMBoC7fEYlzV8aO4hH4sDmEa24VagC JPqyAwTXrG1KYJfGxd2h7tv6uttDws/PL8nHIJdLMkn01O6Feubokf478rHmP6xmgJORaTAw8Is hAT3PmwpfH90J92pQddB989MI5yG/aiTlXL353XMwsvg== X-Received: by 2002:a17:90b:4c0f:b0:340:7b2e:64cc with SMTP id 98e67ed59e1d1-3543b32ae3emr8324057a91.15.1769915789441; Sat, 31 Jan 2026 19:16:29 -0800 (PST) Received: from localhost.localdomain ([113.218.252.120]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-82379b6b2bdsm11810818b3a.30.2026.01.31.19.16.25 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Sat, 31 Jan 2026 19:16:29 -0800 (PST) From: chengkaitao To: ast@kernel.org, daniel@iogearbox.net, john.fastabend@gmail.com, andrii@kernel.org, martin.lau@linux.dev, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, kpsingh@kernel.org, sdf@fomichev.me, haoluo@google.com, jolsa@kernel.org, shuah@kernel.org, yangfeng@kylinos.cn Cc: linux-kernel@vger.kernel.org, bpf@vger.kernel.org, linux-kselftest@vger.kernel.org, Chengkaitao Subject: [PATCH v2 3/3] selftests/bpf: Add supplementary tests for bpf_kptr_xchg Date: Sun, 1 Feb 2026 11:16:07 +0800 Message-ID: <20260201031607.32940-4-pilgrimtao@gmail.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260201031607.32940-1-pilgrimtao@gmail.com> References: <20260201031607.32940-1-pilgrimtao@gmail.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 Content-Type: text/plain; charset="utf-8" From: Chengkaitao 1. Allow using bpf_kptr_xchg under lock-held context. 2. The rb_node contains a __kptr pointer, eliminating the need to perform the remove-read-readd operation sequence. This patch implements the following workflow: 1. Construct a rbtree with 16 elements. 2. Traverse the rbtree, locate the kptr pointer in the target node, and read the content pointed to by the pointer. 3. Remove all nodes from the rbtree. Signed-off-by: Chengkaitao Signed-off-by: Feng Yang --- .../testing/selftests/bpf/prog_tests/rbtree.c | 6 + .../selftests/bpf/progs/rbtree_search_kptr.c | 164 ++++++++++++++++++ 2 files changed, 170 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/rbtree_search_kptr.c diff --git a/tools/testing/selftests/bpf/prog_tests/rbtree.c b/tools/testin= g/selftests/bpf/prog_tests/rbtree.c index d8f3d7a45fe9..a854fb38e418 100644 --- a/tools/testing/selftests/bpf/prog_tests/rbtree.c +++ b/tools/testing/selftests/bpf/prog_tests/rbtree.c @@ -9,6 +9,7 @@ #include "rbtree_btf_fail__wrong_node_type.skel.h" #include "rbtree_btf_fail__add_wrong_type.skel.h" #include "rbtree_search.skel.h" +#include "rbtree_search_kptr.skel.h" =20 static void test_rbtree_add_nodes(void) { @@ -193,3 +194,8 @@ void test_rbtree_search(void) { RUN_TESTS(rbtree_search); } + +void test_rbtree_search_kptr(void) +{ + RUN_TESTS(rbtree_search_kptr); +} diff --git a/tools/testing/selftests/bpf/progs/rbtree_search_kptr.c b/tools= /testing/selftests/bpf/progs/rbtree_search_kptr.c new file mode 100644 index 000000000000..5b853d6cb5a8 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/rbtree_search_kptr.c @@ -0,0 +1,164 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2026 KylinSoft Corporation. */ + +#include +#include +#include "bpf_misc.h" +#include "bpf_experimental.h" + +#define NR_NODES 16 + +struct node_data { + int data; +}; + +struct tree_node { + struct bpf_rb_node node; + u64 key; + struct node_data __kptr * node_data; +}; + +#define private(name) (SEC(".data." #name) __hidden __aligned(8)) + +private(A) struct bpf_rb_root root __contains(tree_node, node); +private(A) struct bpf_spin_lock lock; + +static bool less(struct bpf_rb_node *a, const struct bpf_rb_node *b) +{ + struct tree_node *node_a, *node_b; + + node_a =3D container_of(a, struct tree_node, node); + node_b =3D container_of(b, struct tree_node, node); + + return node_a->key < node_b->key; +} + +SEC("syscall") +__retval(0) +long rbtree_search_kptr(void *ctx) +{ + struct tree_node *tnode; + struct bpf_rb_node *rb_n; + struct node_data __kptr * node_data; + int lookup_key =3D NR_NODES / 2; + int lookup_data =3D NR_NODES / 2; + int i, data, ret =3D 0; + + for (i =3D 0; i < NR_NODES && can_loop; i++) { + tnode =3D bpf_obj_new(typeof(*tnode)); + if (!tnode) + return __LINE__; + + node_data =3D bpf_obj_new(typeof(*node_data)); + if (!node_data) { + bpf_obj_drop(tnode); + return __LINE__; + } + + tnode->key =3D i; + node_data->data =3D i; + + node_data =3D bpf_kptr_xchg(&tnode->node_data, node_data); + if (node_data) + bpf_obj_drop(node_data); + + bpf_spin_lock(&lock); + bpf_rbtree_add(&root, &tnode->node, less); + bpf_spin_unlock(&lock); + } + + bpf_spin_lock(&lock); + rb_n =3D bpf_rbtree_root(&root); + while (rb_n && can_loop) { + tnode =3D container_of(rb_n, struct tree_node, node); + node_data =3D bpf_kptr_xchg(&tnode->node_data, NULL); + if (!node_data) { + ret =3D __LINE__; + goto fail; + } + + data =3D node_data->data; + node_data =3D bpf_kptr_xchg(&tnode->node_data, node_data); + if (node_data) { + bpf_spin_unlock(&lock); + bpf_obj_drop(node_data); + return __LINE__; + } + + if (lookup_key =3D=3D tnode->key) { + if (data =3D=3D lookup_data) + break; + + ret =3D __LINE__; + goto fail; + } + + if (lookup_key < tnode->key) + rb_n =3D bpf_rbtree_left(&root, rb_n); + else + rb_n =3D bpf_rbtree_right(&root, rb_n); + } + bpf_spin_unlock(&lock); + + rb_n =3D NULL; + while (rb_n && can_loop) { + bpf_spin_lock(&lock); + rb_n =3D bpf_rbtree_first(&root); + if (!rb_n) { + ret =3D __LINE__; + goto fail; + } + + rb_n =3D bpf_rbtree_remove(&root, rb_n); + if (!rb_n) { + ret =3D __LINE__; + goto fail; + } + bpf_spin_unlock(&lock); + + tnode =3D container_of(rb_n, struct tree_node, node); + bpf_obj_drop(tnode->node_data); + bpf_obj_drop(tnode); + } + + return 0; +fail: + bpf_spin_unlock(&lock); + return ret; +} + + +SEC("syscall") +__failure __msg("R1 type=3Dscalar expected=3Dmap_value, ptr_, ptr_") +long non_own_ref_kptr_xchg_no_lock(void *ctx) +{ + struct tree_node *tnode; + struct bpf_rb_node *rb_n; + struct node_data __kptr * node_data; + int data; + + bpf_spin_lock(&lock); + rb_n =3D bpf_rbtree_first(&root); + if (!rb_n) { + bpf_spin_unlock(&lock); + return __LINE__; + } + bpf_spin_unlock(&lock); + + tnode =3D container_of(rb_n, struct tree_node, node); + node_data =3D bpf_kptr_xchg(&tnode->node_data, NULL); + if (!node_data) + return __LINE__; + + data =3D node_data->data; + if (data < 0) + return __LINE__; + + node_data =3D bpf_kptr_xchg(&tnode->node_data, node_data); + if (node_data) + return __LINE__; + + return 0; +} + +char _license[] SEC("license") =3D "GPL"; --=20 2.50.1 (Apple Git-155)