From patchwork Sun Aug 7 17:51:16 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yonghong Song X-Patchwork-Id: 12938192 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CB6FBC19F2A for ; Sun, 7 Aug 2022 17:51:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230262AbiHGRv3 (ORCPT ); Sun, 7 Aug 2022 13:51:29 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40652 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229501AbiHGRv2 (ORCPT ); Sun, 7 Aug 2022 13:51:28 -0400 Received: from mx0b-00082601.pphosted.com (mx0b-00082601.pphosted.com [67.231.153.30]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4FD4360C3 for ; Sun, 7 Aug 2022 10:51:27 -0700 (PDT) Received: from pps.filterd (m0109331.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 277EkQOc012001 for ; Sun, 7 Aug 2022 10:51:26 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=facebook; bh=FtcTkn3LrWRN7wtepF2RfbXRfi33ZXDmkZfqK4+clLA=; b=pmA6GTLfpN6vIqvS7SSPt2CTSpWN02iUf7njefJc51JOGF2ExiqOA//UeEXp5JEnyoZA iqiKXQCdVc30pJe6/tQMHbLdMcL5TGV0LmbtkbCW20eOer+kqjEdOb6XOW/2oTAby3Jk +B6TquviYVN94ghZ7YjgMLVxLL15qwo9R18= Received: from maileast.thefacebook.com ([163.114.130.16]) by mx0a-00082601.pphosted.com (PPS) with ESMTPS id 3hsp4uwgdh-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Sun, 07 Aug 2022 10:51:26 -0700 Received: from twshared22934.08.ash9.facebook.com (2620:10d:c0a8:1b::d) by mail.thefacebook.com (2620:10d:c0a8:83::4) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.28; Sun, 7 Aug 2022 10:51:25 -0700 Received: by devbig309.ftw3.facebook.com (Postfix, from userid 128203) id 7D772DC759A6; Sun, 7 Aug 2022 10:51:16 -0700 (PDT) From: Yonghong Song To: CC: Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , , Tejun Heo Subject: [PATCH bpf-next 1/3] bpf: Always return corresponding btf_type in __get_type_size() Date: Sun, 7 Aug 2022 10:51:16 -0700 Message-ID: <20220807175116.4179242-1-yhs@fb.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20220807175111.4178812-1-yhs@fb.com> References: <20220807175111.4178812-1-yhs@fb.com> MIME-Version: 1.0 X-FB-Internal: Safe X-Proofpoint-GUID: FiII6U7rBFfSXvYj2yDmfszfQzf-aNBk X-Proofpoint-ORIG-GUID: FiII6U7rBFfSXvYj2yDmfszfQzf-aNBk X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.883,Hydra:6.0.517,FMLib:17.11.122.1 definitions=2022-08-07_11,2022-08-05_01,2022-06-22_01 Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net Currently in funciton __get_type_size(), the corresponding btf_type is returned only in invalid cases. Let us always return btf_type regardless of valid or invalid cases. Such a new functionality will be used in subsequent patches. Signed-off-by: Yonghong Song --- kernel/bpf/btf.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index 7e64447659f3..8119dc3994db 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -5864,26 +5864,25 @@ bool btf_struct_ids_match(struct bpf_verifier_log *log, } static int __get_type_size(struct btf *btf, u32 btf_id, - const struct btf_type **bad_type) + const struct btf_type **ret_type) { const struct btf_type *t; + *ret_type = btf_type_by_id(btf, 0); if (!btf_id) /* void */ return 0; t = btf_type_by_id(btf, btf_id); while (t && btf_type_is_modifier(t)) t = btf_type_by_id(btf, t->type); - if (!t) { - *bad_type = btf_type_by_id(btf, 0); + if (!t) return -EINVAL; - } + *ret_type = t; if (btf_type_is_ptr(t)) /* kernel size of pointer. Not BPF's size of pointer*/ return sizeof(void *); if (btf_type_is_int(t) || btf_is_any_enum(t)) return t->size; - *bad_type = t; return -EINVAL; } From patchwork Sun Aug 7 17:51:21 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yonghong Song X-Patchwork-Id: 12938194 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id E4A9AC19F2A for ; Sun, 7 Aug 2022 17:51:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231160AbiHGRvg (ORCPT ); Sun, 7 Aug 2022 13:51:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40722 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229501AbiHGRvg (ORCPT ); Sun, 7 Aug 2022 13:51:36 -0400 Received: from mx0a-00082601.pphosted.com (mx0a-00082601.pphosted.com [67.231.145.42]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 676BA5FC7 for ; Sun, 7 Aug 2022 10:51:35 -0700 (PDT) Received: from pps.filterd (m0148461.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 277DFj9K023624 for ; Sun, 7 Aug 2022 10:51:35 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : content-type : content-transfer-encoding : mime-version; s=facebook; bh=AEFWEz2gb7k07AEp2VCM2So/EzbcasoLsLHcb+6r+wY=; b=qW+zM+l7AonIeLThKx0WYzkPAQ9XAgBLGG892HwdUxkqItYFsw6UIqwf91uIi6QLBolf d6MD9KtuJU7HuI06O/DewDV8mucaFs5jYZvTtnoW8cvzMxL9OvRpRnLbQyO97JSroEqU Q1aDzBEYYfSi9BZCkxp7DGr5cAO4jdTH/YI= Received: from mail.thefacebook.com ([163.114.132.120]) by mx0a-00082601.pphosted.com (PPS) with ESMTPS id 3hsndtdkj1-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Sun, 07 Aug 2022 10:51:35 -0700 Received: from twshared22413.18.frc3.facebook.com (2620:10d:c085:208::11) by mail.thefacebook.com (2620:10d:c085:21d::6) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.28; Sun, 7 Aug 2022 10:51:33 -0700 Received: by devbig309.ftw3.facebook.com (Postfix, from userid 128203) id BA03ADC759B6; Sun, 7 Aug 2022 10:51:21 -0700 (PDT) From: Yonghong Song To: CC: Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , , Tejun Heo Subject: [PATCH bpf-next 2/3] bpf: Perform necessary sign/zero extension for kfunc return values Date: Sun, 7 Aug 2022 10:51:21 -0700 Message-ID: <20220807175121.4179410-1-yhs@fb.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20220807175111.4178812-1-yhs@fb.com> References: <20220807175111.4178812-1-yhs@fb.com> X-FB-Internal: Safe X-Proofpoint-GUID: EdsNtMlxSCaTUHZRksPRWEBWpR7slfis X-Proofpoint-ORIG-GUID: EdsNtMlxSCaTUHZRksPRWEBWpR7slfis X-Proofpoint-UnRewURL: 0 URL was un-rewritten MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.883,Hydra:6.0.517,FMLib:17.11.122.1 definitions=2022-08-07_11,2022-08-05_01,2022-06-22_01 Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net Tejun reported a bpf program kfunc return value mis-handling which may cause incorrect result. The following is an example to show the problem. $ cat t.c unsigned char bar(); int foo() { if (bar() != 10) return 0; else return 1; } $ clang -target bpf -O2 -c t.c $ llvm-objdump -d t.o ... 0000000000000000 : 0: 85 10 00 00 ff ff ff ff call -1 1: bf 01 00 00 00 00 00 00 r1 = r0 2: b7 00 00 00 01 00 00 00 r0 = 1 3: 15 01 01 00 0a 00 00 00 if r1 == 10 goto +1 4: b7 00 00 00 00 00 00 00 r0 = 0 0000000000000028 : 5: 95 00 00 00 00 00 00 00 exit $ In the above example, the return type for bar() is 'unsigned char'. But in the disassembly code, the whole register 'r1' is used to compare to 10 without truncating upper 56 bits. If function bar() is implemented as a bpf function, everything should be okay since bpf ABI will make sure the caller do proper truncation of upper 56 bits. But if function bar() is implemented as a non-bpf kfunc, there could a mismatch between bar() implementation and bpf program. For example, if the host arch is x86_64, the bar() function may just put the return value in lower 8-bit subregister and all upper 56 bits could contain garbage. This is not a problem if bar() is called in x86_64 context as the caller will use %al to get the value. But this could be a problem if bar() is called in bpf context and there is a mismatch expectation between bpf and native architecture. Currently, bpf programs use the default llvm ABI ([1], function isPromotableIntegerTypeForABI()) such that if an integer type size is less than int type size, it is assumed proper sign or zero extension has been done to the return value. There will be a problem if the kfunc return value type is u8/s8/u16/s16. This patch intends to address this issue by doing proper sign or zero extension for the kfunc return value before it is used later. [1] https://github.com/llvm/llvm-project/blob/main/clang/lib/CodeGen/TargetInfo.cpp Reported-by: Tejun Heo Signed-off-by: Yonghong Song --- include/linux/bpf.h | 2 ++ kernel/bpf/btf.c | 9 +++++++++ kernel/bpf/verifier.c | 35 +++++++++++++++++++++++++++++++++-- 3 files changed, 44 insertions(+), 2 deletions(-) diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 20c26aed7896..b6f6bb1b707d 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -727,6 +727,8 @@ enum bpf_cgroup_storage_type { #define MAX_BPF_FUNC_REG_ARGS 5 struct btf_func_model { + u8 ret_integer:1; + u8 ret_integer_signed:1; u8 ret_size; u8 nr_args; u8 arg_size[MAX_BPF_FUNC_ARGS]; diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index 8119dc3994db..f30a02018701 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -5897,6 +5897,7 @@ int btf_distill_func_proto(struct bpf_verifier_log *log, u32 i, nargs; int ret; + m->ret_integer = false; if (!func) { /* BTF function prototype doesn't match the verifier types. * Fall back to MAX_BPF_FUNC_REG_ARGS u64 args. @@ -5923,6 +5924,14 @@ int btf_distill_func_proto(struct bpf_verifier_log *log, return -EINVAL; } m->ret_size = ret; + if (btf_type_is_int(t)) { + m->ret_integer = true; + /* BTF_INT_BOOL is considered as unsigned */ + if (BTF_INT_ENCODING(btf_type_int(t)) == BTF_INT_SIGNED) + m->ret_integer_signed = true; + else + m->ret_integer_signed = false; + } for (i = 0; i < nargs; i++) { if (i == nargs - 1 && args[i].type == 0) { diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 096fdac70165..684f8606f341 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -13834,8 +13834,9 @@ static int fixup_call_args(struct bpf_verifier_env *env) } static int fixup_kfunc_call(struct bpf_verifier_env *env, - struct bpf_insn *insn) + struct bpf_insn *insn, struct bpf_insn *insn_buf, int *cnt) { + u8 ret_size, shift_cnt, rshift_opcode; const struct bpf_kfunc_desc *desc; if (!insn->imm) { @@ -13855,6 +13856,26 @@ static int fixup_kfunc_call(struct bpf_verifier_env *env, insn->imm = desc->imm; + *cnt = 0; + ret_size = desc->func_model.ret_size; + + /* If the kfunc return type is an integer and the type size is one byte or two + * bytes, currently llvm/bpf assumes proper sign/zero extension has been done + * in the caller. But such an asumption may not hold for non-bpf architectures. + * For example, for x86_64, if the return type is 'u8', it is possible that only + * %al register is set properly and upper 56 bits of %rax register may contain + * garbage. To resolve this case, Let us do a necessary truncation to zero-out + * or properly sign-extend upper 56 bits. + */ + if (desc->func_model.ret_integer && ret_size < sizeof(int)) { + shift_cnt = (sizeof(u64) - ret_size) * 8; + rshift_opcode = desc->func_model.ret_integer_signed ? BPF_ARSH : BPF_RSH; + insn_buf[0] = *insn; + insn_buf[1] = BPF_ALU64_IMM(BPF_LSH, BPF_REG_0, shift_cnt); + insn_buf[2] = BPF_ALU64_IMM(rshift_opcode, BPF_REG_0, shift_cnt); + *cnt = 3; + } + return 0; } @@ -13996,9 +14017,19 @@ static int do_misc_fixups(struct bpf_verifier_env *env) if (insn->src_reg == BPF_PSEUDO_CALL) continue; if (insn->src_reg == BPF_PSEUDO_KFUNC_CALL) { - ret = fixup_kfunc_call(env, insn); + ret = fixup_kfunc_call(env, insn, insn_buf, &cnt); if (ret) return ret; + if (cnt == 0) + continue; + + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); + if (!new_prog) + return -ENOMEM; + + delta += cnt - 1; + env->prog = prog = new_prog; + insn = new_prog->insnsi + i + delta; continue; } From patchwork Sun Aug 7 17:51:26 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yonghong Song X-Patchwork-Id: 12938193 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5A401C19F2A for ; Sun, 7 Aug 2022 17:51:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232292AbiHGRve (ORCPT ); Sun, 7 Aug 2022 13:51:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40678 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231160AbiHGRvc (ORCPT ); Sun, 7 Aug 2022 13:51:32 -0400 Received: from mx0a-00082601.pphosted.com (mx0a-00082601.pphosted.com [67.231.145.42]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id F16755FC7 for ; Sun, 7 Aug 2022 10:51:31 -0700 (PDT) Received: from pps.filterd (m0044010.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 277DR1fU001046 for ; Sun, 7 Aug 2022 10:51:31 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=facebook; bh=wM2JykMaqBkqcD8bYFA4Dc3w1MA5CPTTb9Nix03SiOM=; b=dsNlk1WMySTPCOeOTTcEDfTIaE5v7IM2XuQuemaSee3lnVVNMjgTH/7UDXgbO0CWGmsd NOnVji3cmBetKDg2bKqvKAX6mgRFHwU4YHIJL2p1KTXcy/qA+RUzI1QjPqxwMKeRrR6c U1BNcnssBYoEslS461XMBz0izbJrM8CCZt0= Received: from mail.thefacebook.com ([163.114.132.120]) by mx0a-00082601.pphosted.com (PPS) with ESMTPS id 3hskmndyk4-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Sun, 07 Aug 2022 10:51:31 -0700 Received: from twshared5413.23.frc3.facebook.com (2620:10d:c085:108::8) by mail.thefacebook.com (2620:10d:c085:11d::7) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.28; Sun, 7 Aug 2022 10:51:30 -0700 Received: by devbig309.ftw3.facebook.com (Postfix, from userid 128203) id 02194DC759C4; Sun, 7 Aug 2022 10:51:27 -0700 (PDT) From: Yonghong Song To: CC: Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , , Tejun Heo Subject: [PATCH bpf-next 3/3] selftests/bpf: Add tests with u8/s16 kfunc return types Date: Sun, 7 Aug 2022 10:51:26 -0700 Message-ID: <20220807175126.4179877-1-yhs@fb.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20220807175111.4178812-1-yhs@fb.com> References: <20220807175111.4178812-1-yhs@fb.com> MIME-Version: 1.0 X-FB-Internal: Safe X-Proofpoint-ORIG-GUID: Zo2DvCL0wPmYUfModJt8brimn6AXSeQ9 X-Proofpoint-GUID: Zo2DvCL0wPmYUfModJt8brimn6AXSeQ9 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.883,Hydra:6.0.517,FMLib:17.11.122.1 definitions=2022-08-07_11,2022-08-05_01,2022-06-22_01 Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net Add two program tests with kfunc return types u8/s16. With previous patch, xlated codes looks like below: ... ; return bpf_kfunc_call_test4((struct sock *)sk, (1 << 16) + 0xff00, (1 << 16) + 0xff); 5: (bf) r1 = r0 6: (b4) w2 = 130816 7: (b4) w3 = 65791 8: (85) call bpf_kfunc_call_test4#8931696 9: (67) r0 <<= 48 10: (c7) r0 s>>= 48 11: (bc) w6 = w0 ; } 12: (bc) w0 = w6 13: (95) exit ... ; return bpf_kfunc_call_test5((struct sock *)sk, (1 << 8) + 1, (1 << 8) + 2); 5: (bf) r1 = r0 6: (b4) w2 = 257 7: (b4) w3 = 258 8: (85) call bpf_kfunc_call_test5#8931712 9: (67) r0 <<= 56 10: (77) r0 >>= 56 11: (bc) w6 = w0 ; } 12: (bc) w0 = w6 13: (95) exit For return type s16, proper sign extension for the return value is done for kfunc bpf_kfunc_call_test4(). For return type s8, proper zero extension for the return value is done for bpf_kfunc_call_test5(). Without the previous patch, the test kfunc_call will fail with ... test_main:FAIL:test4-retval unexpected test4-retval: actual 196607 != expected 4294967295 ... test_main:FAIL:test5-retval unexpected test5-retval: actual 515 != expected 3 Signed-off-by: Yonghong Song --- net/bpf/test_run.c | 12 +++++++ .../selftests/bpf/prog_tests/kfunc_call.c | 10 ++++++ .../selftests/bpf/progs/kfunc_call_test.c | 32 +++++++++++++++++++ 3 files changed, 54 insertions(+) diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c index cbc9cd5058cb..3a17ab4107f5 100644 --- a/net/bpf/test_run.c +++ b/net/bpf/test_run.c @@ -551,6 +551,16 @@ struct sock * noinline bpf_kfunc_call_test3(struct sock *sk) return sk; } +s16 noinline bpf_kfunc_call_test4(struct sock *sk, u32 a, u32 b) +{ + return a + b; +} + +u8 noinline bpf_kfunc_call_test5(struct sock *sk, u32 a, u32 b) +{ + return a + b; +} + struct prog_test_member1 { int a; }; @@ -703,6 +713,8 @@ BTF_SET8_START(test_sk_check_kfunc_ids) BTF_ID_FLAGS(func, bpf_kfunc_call_test1) BTF_ID_FLAGS(func, bpf_kfunc_call_test2) BTF_ID_FLAGS(func, bpf_kfunc_call_test3) +BTF_ID_FLAGS(func, bpf_kfunc_call_test4) +BTF_ID_FLAGS(func, bpf_kfunc_call_test5) BTF_ID_FLAGS(func, bpf_kfunc_call_test_acquire, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_kfunc_call_memb_acquire, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_kfunc_call_test_release, KF_RELEASE) diff --git a/tools/testing/selftests/bpf/prog_tests/kfunc_call.c b/tools/testing/selftests/bpf/prog_tests/kfunc_call.c index c00eb974eb85..a355c98080f2 100644 --- a/tools/testing/selftests/bpf/prog_tests/kfunc_call.c +++ b/tools/testing/selftests/bpf/prog_tests/kfunc_call.c @@ -35,6 +35,16 @@ static void test_main(void) ASSERT_OK(err, "bpf_prog_test_run(test_ref_btf_id)"); ASSERT_EQ(topts.retval, 0, "test_ref_btf_id-retval"); + prog_fd = skel->progs.kfunc_call_test4.prog_fd; + err = bpf_prog_test_run_opts(prog_fd, &topts); + ASSERT_OK(err, "bpf_prog_test_run(test4)"); + ASSERT_EQ(topts.retval, 0xffffffff, "test4-retval"); + + prog_fd = skel->progs.kfunc_call_test5.prog_fd; + err = bpf_prog_test_run_opts(prog_fd, &topts); + ASSERT_OK(err, "bpf_prog_test_run(test5)"); + ASSERT_EQ(topts.retval, 3, "test5-retval"); + kfunc_call_test_lskel__destroy(skel); } diff --git a/tools/testing/selftests/bpf/progs/kfunc_call_test.c b/tools/testing/selftests/bpf/progs/kfunc_call_test.c index 5aecbb9fdc68..0636cb13e574 100644 --- a/tools/testing/selftests/bpf/progs/kfunc_call_test.c +++ b/tools/testing/selftests/bpf/progs/kfunc_call_test.c @@ -6,6 +6,8 @@ extern int bpf_kfunc_call_test2(struct sock *sk, __u32 a, __u32 b) __ksym; extern __u64 bpf_kfunc_call_test1(struct sock *sk, __u32 a, __u64 b, __u32 c, __u64 d) __ksym; +extern __s16 bpf_kfunc_call_test4(struct sock *sk, __u32 a, __u32 b) __ksym; +extern __u8 bpf_kfunc_call_test5(struct sock *sk, __u32 a, __u32 b) __ksym; extern struct prog_test_ref_kfunc *bpf_kfunc_call_test_acquire(unsigned long *sp) __ksym; extern void bpf_kfunc_call_test_release(struct prog_test_ref_kfunc *p) __ksym; @@ -30,6 +32,36 @@ int kfunc_call_test2(struct __sk_buff *skb) return bpf_kfunc_call_test2((struct sock *)sk, 1, 2); } +SEC("tc") +int kfunc_call_test4(struct __sk_buff *skb) +{ + struct bpf_sock *sk = skb->sk; + + if (!sk) + return -1; + + sk = bpf_sk_fullsock(sk); + if (!sk) + return -1; + + return bpf_kfunc_call_test4((struct sock *)sk, (1 << 16) + 0xff00, (1 << 16) + 0xff); +} + +SEC("tc") +int kfunc_call_test5(struct __sk_buff *skb) +{ + struct bpf_sock *sk = skb->sk; + + if (!sk) + return -1; + + sk = bpf_sk_fullsock(sk); + if (!sk) + return -1; + + return bpf_kfunc_call_test5((struct sock *)sk, (1 << 8) + 1, (1 << 8) + 2); +} + SEC("tc") int kfunc_call_test1(struct __sk_buff *skb) {