From patchwork Wed Oct 6 00:28:48 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kumar Kartikeya Dwivedi X-Patchwork-Id: 12538257 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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 77760C433FE for ; Wed, 6 Oct 2021 00:29:05 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 6037C6120C for ; Wed, 6 Oct 2021 00:29:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230218AbhJFAaz (ORCPT ); Tue, 5 Oct 2021 20:30:55 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43992 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236953AbhJFAav (ORCPT ); Tue, 5 Oct 2021 20:30:51 -0400 Received: from mail-pf1-x442.google.com (mail-pf1-x442.google.com [IPv6:2607:f8b0:4864:20::442]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 503CEC061749; Tue, 5 Oct 2021 17:29:00 -0700 (PDT) Received: by mail-pf1-x442.google.com with SMTP id m14so871799pfc.9; Tue, 05 Oct 2021 17:29:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=JBSHnmxpgcVzNICL2o7nU9ev7SyKN2x4XxRSRTTs49Y=; b=JV5doS18wjAWJHMvK8zcBXAILGVgwJk0PELUUVvg9aJPiCqZLmp8jKAe851KaCW9/B pHT5CHR9dP4aYcckMCHQR4js5naQYmdyUVBtB4eXWTLvLiDmtf1yF/c9Q3QItaVkNkAd Kxo59bv1WqNykC/3YZRGNq35Khu86dwu6tDMsuC0EZ28ZQhkLjjDE60b0YMT6T7ZO0m3 t0lDp5rQ6L+QbPhbJg3EYazZl9JGWU9SnH2ifYGXOm93lGvpIMfdYAzHS2yFseoGjgWZ qqWrJnSMS9H+5u/b7Uqwle2BDXc2Nr+80iSeTwSm2UMTvis7AIicFZCxnRDAqLucANdo D4Vg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=JBSHnmxpgcVzNICL2o7nU9ev7SyKN2x4XxRSRTTs49Y=; b=rBDTDYXIzxIRsajK4jqOUMWTmnhuSnpbDiu+HmaMhi2eL84Vo7XwyIDCE+qXBmI8tS we76IJjQK7pv48EBfzT8x9bcKLjBX8N8/6NOyQi0oQ1565eRQPlfdcmibUk66eCe3YlI Fsha0tnZk5qpJ/7LYPSoY3tXQzIZg+S7e2OXrKdNLWDwqcd/z1m2BvRIHhzWkM6ynbps 9aBbgCTFznVFy7qAj4J1U25YCmGvolaiyMSiLBE4mCPepDsVzChNUJLAek+m54jJxVSA SJcs5KoyKpfHsfqapGlcWSrcWEdmzC/sqdLJtyMKzGVLgqqHCCDKgOkvhaCL8sSKET22 dnWw== X-Gm-Message-State: AOAM5314gSAMnRSZfWG4orBHa63/TCKCa5WctnbfghAw7uo5liibvsGS UkRsxD3bmhVs1NsXfhTKJYQ3RxIqSo0= X-Google-Smtp-Source: ABdhPJxJqDkALKpiDadPHSbFQIxO7mPTdgKqDcpxqbOrAbP75fgGr2Niw2wz2JWWjDSx7E16ZlCWYA== X-Received: by 2002:a63:f749:: with SMTP id f9mr17811128pgk.77.1633480139666; Tue, 05 Oct 2021 17:28:59 -0700 (PDT) Received: from localhost ([2405:201:6014:d058:a28d:3909:6ed5:29e7]) by smtp.gmail.com with ESMTPSA id e6sm3393392pfm.212.2021.10.05.17.28.58 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Oct 2021 17:28:59 -0700 (PDT) From: Kumar Kartikeya Dwivedi To: bpf@vger.kernel.org Cc: Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Martin KaFai Lau , Song Liu , Yonghong Song , Jesper Dangaard Brouer , =?utf-8?q?Toke_H=C3=B8iland-J=C3=B8rgensen?= , netdev@vger.kernel.org Subject: [PATCH bpf-next v1 1/6] bpf: Add bpf_kallsyms_lookup_name helper Date: Wed, 6 Oct 2021 05:58:48 +0530 Message-Id: <20211006002853.308945-2-memxor@gmail.com> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20211006002853.308945-1-memxor@gmail.com> References: <20211006002853.308945-1-memxor@gmail.com> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=4623; h=from:subject; bh=qZbR9WNQ0ZlHNxJ/lEWKq/Wg1g1idI3u1N6c55dzyKI=; b=owEBbQKS/ZANAwAIAUzgyIZIvxHKAcsmYgBhXOxPCBzWz8TbxGxoblvl3YLe3HjIklPVIOXl6ZZd /U0fs1CJAjMEAAEIAB0WIQRLvip+Buz51YI8YRFM4MiGSL8RygUCYVzsTwAKCRBM4MiGSL8Ryq+REA C6K6f3HZwnmGv4Cp7EpWHh1dZy/M7SdupNOfnZ4zn6vhW085KZaL6sbIv2RLV10V/DQPdM2bg6RthK Dy5nIKg9IY+Zr/qx1spTJ44BTiJ+y4+v5OUSHOevsFf0Q3CKlZFlKeBablFnT0M/NC8zE67AoeB0wy DtYFyjp42xEbjFKgoFz7yuWy5xoo4Wsaze25euz0PzmoHFoFaD2d66Ny7s37SP/k3oobbOz94g36VP gTHkN2K018vfiYCmkDEDOUPOQa9kbl6LlBonxy1hKMjdmigHWLzz7dn2cj1CqHmQoqlM9bLm1G5evW dKTY6NTsa4eMq1of83mS5ChMZ5AQggWfn1aUkKVAXLze/NuyzX7HpY/CdtBGeJ0ZqrtvdQTVbX7l8d bwJ04g/atpSlVBBuaeqpEjzNNYP+GtISGkKt8J7oY398Fch6I3BXlOh2rMz9+6VlLve338kCTjhY1l Dyn5KxSI2B0Y13HBOlYU2S448RzPN03wrpaJ3tqoKKHu2sXowMjW9W4qc5RDaRLkEh99QTnIwDzfU8 /iXr27PH6u9c/hqcdD77BcJtdnlNBep5RI+n2M53LOUjRPnQDWQZVLXbg/TaGdVGlPhAVvSfvLD+o5 u9tjvSDH60D2G7RFSgjaQTbxN3lY9+UJu0PKUP3ee5x9wok2oCNW4g+ozjWQ== X-Developer-Key: i=memxor@gmail.com; a=openpgp; fpr=4BBE2A7E06ECF9D5823C61114CE0C88648BF11CA Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net This helper allows us to get the address of a kernel symbol from inside a BPF_PROG_TYPE_SYSCALL prog (used by gen_loader), so that we can relocate weak and typeless ksym vars. Signed-off-by: Kumar Kartikeya Dwivedi Acked-by: Song Liu --- include/linux/bpf.h | 1 + include/uapi/linux/bpf.h | 14 ++++++++++++++ kernel/bpf/syscall.c | 24 ++++++++++++++++++++++++ tools/include/uapi/linux/bpf.h | 14 ++++++++++++++ 4 files changed, 53 insertions(+) diff --git a/include/linux/bpf.h b/include/linux/bpf.h index d604c8251d88..17206aae329d 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -2107,6 +2107,7 @@ extern const struct bpf_func_proto bpf_for_each_map_elem_proto; extern const struct bpf_func_proto bpf_btf_find_by_name_kind_proto; extern const struct bpf_func_proto bpf_sk_setsockopt_proto; extern const struct bpf_func_proto bpf_sk_getsockopt_proto; +extern const struct bpf_func_proto bpf_kallsyms_lookup_name_proto; const struct bpf_func_proto *tracing_prog_func_proto( enum bpf_func_id func_id, const struct bpf_prog *prog); diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 6fc59d61937a..bbd0a3f4e5f6 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -4909,6 +4909,19 @@ union bpf_attr { * Return * The number of bytes written to the buffer, or a negative error * in case of failure. + * + * long bpf_kallsyms_lookup_name(const char *name, int name_sz, int flags, u64 *res) + * Description + * Get the address of a kernel symbol, returned in *res*. *res* is + * set to 0 if the symbol is not found. + * Return + * On success, zero. On error, a negative value. + * + * **-EINVAL** if *flags* is not zero. + * + * **-EINVAL** if string *name* is not the same size as *name_sz*. + * + * **-ENOENT** if symbol is not found. */ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ @@ -5089,6 +5102,7 @@ union bpf_attr { FN(task_pt_regs), \ FN(get_branch_snapshot), \ FN(trace_vprintk), \ + FN(kallsyms_lookup_name), \ /* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c index 4e50c0bfdb7d..073ca9ebe58b 100644 --- a/kernel/bpf/syscall.c +++ b/kernel/bpf/syscall.c @@ -4753,6 +4753,28 @@ static const struct bpf_func_proto bpf_sys_close_proto = { .arg1_type = ARG_ANYTHING, }; +BPF_CALL_4(bpf_kallsyms_lookup_name, const char *, name, int, name_sz, int, flags, u64 *, res) +{ + if (flags) + return -EINVAL; + + if (name_sz <= 1 || name[name_sz - 1]) + return -EINVAL; + + *res = kallsyms_lookup_name(name); + return *res ? 0 : -ENOENT; +} + +const struct bpf_func_proto bpf_kallsyms_lookup_name_proto = { + .func = bpf_kallsyms_lookup_name, + .gpl_only = true, + .ret_type = RET_INTEGER, + .arg1_type = ARG_PTR_TO_MEM, + .arg2_type = ARG_CONST_SIZE, + .arg3_type = ARG_ANYTHING, + .arg4_type = ARG_PTR_TO_LONG, +}; + static const struct bpf_func_proto * syscall_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) { @@ -4763,6 +4785,8 @@ syscall_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) return &bpf_btf_find_by_name_kind_proto; case BPF_FUNC_sys_close: return &bpf_sys_close_proto; + case BPF_FUNC_kallsyms_lookup_name: + return &bpf_kallsyms_lookup_name_proto; default: return tracing_prog_func_proto(func_id, prog); } diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h index 6fc59d61937a..bbd0a3f4e5f6 100644 --- a/tools/include/uapi/linux/bpf.h +++ b/tools/include/uapi/linux/bpf.h @@ -4909,6 +4909,19 @@ union bpf_attr { * Return * The number of bytes written to the buffer, or a negative error * in case of failure. + * + * long bpf_kallsyms_lookup_name(const char *name, int name_sz, int flags, u64 *res) + * Description + * Get the address of a kernel symbol, returned in *res*. *res* is + * set to 0 if the symbol is not found. + * Return + * On success, zero. On error, a negative value. + * + * **-EINVAL** if *flags* is not zero. + * + * **-EINVAL** if string *name* is not the same size as *name_sz*. + * + * **-ENOENT** if symbol is not found. */ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ @@ -5089,6 +5102,7 @@ union bpf_attr { FN(task_pt_regs), \ FN(get_branch_snapshot), \ FN(trace_vprintk), \ + FN(kallsyms_lookup_name), \ /* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper From patchwork Wed Oct 6 00:28:49 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kumar Kartikeya Dwivedi X-Patchwork-Id: 12538259 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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 78425C4332F for ; Wed, 6 Oct 2021 00:29:06 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5FB0661207 for ; Wed, 6 Oct 2021 00:29:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237027AbhJFAa4 (ORCPT ); Tue, 5 Oct 2021 20:30:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44010 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237007AbhJFAay (ORCPT ); Tue, 5 Oct 2021 20:30:54 -0400 Received: from mail-pj1-x1043.google.com (mail-pj1-x1043.google.com [IPv6:2607:f8b0:4864:20::1043]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4D83CC061762; Tue, 5 Oct 2021 17:29:03 -0700 (PDT) Received: by mail-pj1-x1043.google.com with SMTP id ls14-20020a17090b350e00b001a00e2251c8so950997pjb.4; Tue, 05 Oct 2021 17:29:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Uh/Ou0s/CMNDG6mn/Axnv2eioDOJrkUwiVyx/o94Fl0=; b=T1Ds1AEIhXHNuFfK6prnn7mWThF2AZSrSJ0pSP0xqHEV/vs0YPwIKvIwtF3uUTtHNw rAVztRnnBrCixFMPmdpBh8/+61g2ez04HpvnOiGrSDsJZIk3WeRmRFCjqrreHkWFS9db 78XRzkWqAhauBiLX5nT1gM1Mh8wcQNeGj60gG72bw1GjJVKKhwBz0fuBgoV12xUzKRP6 lGAVDFe2QVcUNnErdJo3AUEcTy5DDSyNknc/88+aj6ubaUck6Bw8z/sbaFU3CiR8lRTK WSithvBkXaxOfHHpDOzYEX3yKir6axsHg/3UHd9IpNEdDS08mnCRkScjGdqEzMysEGha DXBg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Uh/Ou0s/CMNDG6mn/Axnv2eioDOJrkUwiVyx/o94Fl0=; b=prUwBYHwjfqCn29IqjzWHIEWrgRyR5xmeAL+u43QId3Zn6cKLzbd/7EmMdmVT2qcxa Xk3a8LeRaD2GPLN+4wd3I/IizI5DDdGAWTKPgg3E6OfrKrk+bga47GUmUd4BmfCE7pyF S80Oz7eSq7GC6jtHUyN02wQibIuf/xo3WLEeQ2AYr8ns6vDcDhNvq0cw/pjiKfPFAUKy SxlGbIQlPLMUO0cGWYRgtDJOg3BCvD0TrCbCpammlLMHIfbhrdbPk0GbFTHvSHklOOxG x5evHS9jibiEKi8CaL+QcKeM4pu6YIukxfaAU+JE+YjBu4MRhnpDvUEbQi+8oD/TrNtV scOQ== X-Gm-Message-State: AOAM5320C5oJCTAiHVt1LDXMN3j9r147Cs+tYqgavP9JzJHSlhjmds5C TCvJD66NFtjcSO72wVMw4TFjMKPYDVI= X-Google-Smtp-Source: ABdhPJwu5uXDQXKJDi6dYxcNuBDojVNCWMGx3o4jZaIXJUxPrO20jvxE8t0NlzbxbxWi/Le0pPyG3Q== X-Received: by 2002:a17:90a:7345:: with SMTP id j5mr7435966pjs.48.1633480142559; Tue, 05 Oct 2021 17:29:02 -0700 (PDT) Received: from localhost ([2405:201:6014:d058:a28d:3909:6ed5:29e7]) by smtp.gmail.com with ESMTPSA id 139sm18583339pfz.35.2021.10.05.17.29.01 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Oct 2021 17:29:02 -0700 (PDT) From: Kumar Kartikeya Dwivedi To: bpf@vger.kernel.org Cc: Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Martin KaFai Lau , Song Liu , Yonghong Song , Jesper Dangaard Brouer , =?utf-8?q?Toke_H=C3=B8iland-J=C3=B8rgensen?= , netdev@vger.kernel.org Subject: [PATCH bpf-next v1 2/6] libbpf: Add typeless and weak ksym support to gen_loader Date: Wed, 6 Oct 2021 05:58:49 +0530 Message-Id: <20211006002853.308945-3-memxor@gmail.com> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20211006002853.308945-1-memxor@gmail.com> References: <20211006002853.308945-1-memxor@gmail.com> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=11735; h=from:subject; bh=DR1QI2yh+aSqpVAYNgwwUlnqqIaXbxa7jiFlgZcLvzA=; b=owEBbQKS/ZANAwAIAUzgyIZIvxHKAcsmYgBhXOxPKMl2qOVMhuXjWP1BHGcE8E6/g0SJ4Rvt8k6E 9b9nw6qJAjMEAAEIAB0WIQRLvip+Buz51YI8YRFM4MiGSL8RygUCYVzsTwAKCRBM4MiGSL8RygwkD/ 4sBkFmrXb9GtjBH1QrQ8PPYboWmPSfhhs+HD6sKaMVwcoLa8aAB25EzCopzwYdGIEPZnzwJw6p05PW gAsbiFykpDUoY3XsX7c3umY5Im7X+bdq4jjVo8X58ZtSYqOoDQLltxecSivjRNLqorm1fIsQa1NWY7 8xBbVoznyqQTHc59CkqntL3rHBdOENX47v1VA1RR5lrxDol90BG0QoMUQAT335u2wGMnTWT7WS58L5 WHockMQN4uTlZKJok0ApJJyZBT541SjED5eJvfC34HevZTjKF8ZQSqmI7aeJ9szHMbt1IRXao/VEZT a0sygVLd4tgzSmJp2ZB1xO1BI0QdTg179PS3H8bDKlHBJkpxMa1QjPoHG/NTvMgejmOvNqmaygasat up356cJbGEgZLoy1TccmR1GuABF5QmwplptGYTAI7VsJK7eoXepqaWFCwWFd4xgBBxbaoaDg5XK8Xh 27tL6sJhQIo33tmKWQWl7sGPchtS3eime+D1x8kYQmoWXEvV7dssgiFudY/05GBy3pbUwmh4BWMcm/ 8MWNR01CpBZGpuK1iVRslit93wPcZmxTRsxSDbR/uqbqsm3vMoE+JzzOBzQ5lKUMpaNYn/hzSBDuPa ezJo9Nr/VgA1KH1FRdi2mRv21ZA7FdGuqDBDnqc5rPIpGRHlD71G038cKF/Q== X-Developer-Key: i=memxor@gmail.com; a=openpgp; fpr=4BBE2A7E06ECF9D5823C61114CE0C88648BF11CA Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net This patch adds typeless and weak ksym support to BTF_KIND_VAR relocation code in gen_loader. For typeless ksym, we use the newly added bpf_kallsyms_lookup_name helper. For weak ksym, we simply skip error check, and fix up the srg_reg for the insn, as keeping it as BPF_PSEUDO_BTF_ID for weak ksym with its insn[0].imm and insn[1].imm set as 0 will cause a failure. This is consistent with how libbpf relocates these two cases of BTF_KIND_VAR. We also modify cleanup_relos to check for typeless ksyms in fd closing loop, since those have no fd associated with the ksym. For this we can reuse the unused 'off' member of ksym_desc. Signed-off-by: Kumar Kartikeya Dwivedi --- tools/lib/bpf/bpf_gen_internal.h | 12 ++- tools/lib/bpf/gen_loader.c | 123 ++++++++++++++++++++++++++++--- tools/lib/bpf/libbpf.c | 13 ++-- 3 files changed, 128 insertions(+), 20 deletions(-) diff --git a/tools/lib/bpf/bpf_gen_internal.h b/tools/lib/bpf/bpf_gen_internal.h index 70eccbffefb1..9f328d044636 100644 --- a/tools/lib/bpf/bpf_gen_internal.h +++ b/tools/lib/bpf/bpf_gen_internal.h @@ -8,13 +8,19 @@ struct ksym_relo_desc { int kind; int insn_idx; bool is_weak; + bool is_typeless; }; struct ksym_desc { const char *name; int ref; int kind; - int off; + union { + /* used for kfunc */ + int off; + /* used for typeless ksym */ + bool typeless; + }; int insn; }; @@ -49,7 +55,7 @@ void bpf_gen__prog_load(struct bpf_gen *gen, struct bpf_prog_load_params *load_a void bpf_gen__map_update_elem(struct bpf_gen *gen, int map_idx, void *value, __u32 value_size); void bpf_gen__map_freeze(struct bpf_gen *gen, int map_idx); void bpf_gen__record_attach_target(struct bpf_gen *gen, const char *name, enum bpf_attach_type type); -void bpf_gen__record_extern(struct bpf_gen *gen, const char *name, bool is_weak, int kind, - int insn_idx); +void bpf_gen__record_extern(struct bpf_gen *gen, const char *name, bool is_weak, + bool is_typeless, int kind, int insn_idx); #endif diff --git a/tools/lib/bpf/gen_loader.c b/tools/lib/bpf/gen_loader.c index 937bfc7db41e..da1fcb0e3bcb 100644 --- a/tools/lib/bpf/gen_loader.c +++ b/tools/lib/bpf/gen_loader.c @@ -13,6 +13,7 @@ #include "hashmap.h" #include "bpf_gen_internal.h" #include "skel_internal.h" +#include #define MAX_USED_MAPS 64 #define MAX_USED_PROGS 32 @@ -559,7 +560,7 @@ static void emit_find_attach_target(struct bpf_gen *gen) } void bpf_gen__record_extern(struct bpf_gen *gen, const char *name, bool is_weak, - int kind, int insn_idx) + bool is_typeless, int kind, int insn_idx) { struct ksym_relo_desc *relo; @@ -572,6 +573,7 @@ void bpf_gen__record_extern(struct bpf_gen *gen, const char *name, bool is_weak, relo += gen->relo_cnt; relo->name = name; relo->is_weak = is_weak; + relo->is_typeless = is_typeless; relo->kind = kind; relo->insn_idx = insn_idx; gen->relo_cnt++; @@ -621,6 +623,33 @@ static void emit_bpf_find_by_name_kind(struct bpf_gen *gen, struct ksym_relo_des debug_ret(gen, "find_by_name_kind(%s,%d)", relo->name, relo->kind); } +/* Overwrites BPF_REG_{0, 1, 2, 3, 4, 7} + * Returns result in BPF_REG_7 + * Returns u64 symbol addr in BPF_REG_9 + */ +static void emit_bpf_kallsyms_lookup_name(struct bpf_gen *gen, struct ksym_relo_desc *relo) +{ + int name_off, len = strlen(relo->name) + 1, res_off; + + name_off = add_data(gen, relo->name, len); + if (!name_off) + return; + res_off = add_data(gen, NULL, 8); /* res is u64 */ + if (!res_off) + return; + emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE, + 0, 0, 0, name_off)); + emit(gen, BPF_MOV64_IMM(BPF_REG_2, len)); + emit(gen, BPF_MOV64_IMM(BPF_REG_3, 0)); + emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_4, BPF_PSEUDO_MAP_IDX_VALUE, + 0, 0, 0, res_off)); + emit(gen, BPF_MOV64_REG(BPF_REG_7, BPF_REG_4)); + emit(gen, BPF_EMIT_CALL(BPF_FUNC_kallsyms_lookup_name)); + emit(gen, BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0)); + emit(gen, BPF_MOV64_REG(BPF_REG_7, BPF_REG_0)); + debug_ret(gen, "kallsyms_lookup_name(%s,%d)", relo->name, relo->kind); +} + /* Expects: * BPF_REG_8 - pointer to instruction * @@ -703,7 +732,8 @@ static void emit_relo_kfunc_btf(struct bpf_gen *gen, struct ksym_relo_desc *relo /* Expects: * BPF_REG_8 - pointer to instruction */ -static void emit_relo_ksym_btf(struct bpf_gen *gen, struct ksym_relo_desc *relo, int insn) +static void emit_relo_ksym_typeless(struct bpf_gen *gen, + struct ksym_relo_desc *relo, int insn) { struct ksym_desc *kdesc; @@ -718,25 +748,96 @@ static void emit_relo_ksym_btf(struct bpf_gen *gen, struct ksym_relo_desc *relo, kdesc->insn + sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm)); goto log; } + /* remember insn offset, so we can copy ksym addr later */ + kdesc->insn = insn; + /* skip typeless ksym_desc in fd closing loop in cleanup_relos */ + kdesc->typeless = true; + emit_bpf_kallsyms_lookup_name(gen, relo); + emit(gen, BPF_JMP_IMM(BPF_JEQ, BPF_REG_7, -ENOENT, 1)); + emit_check_err(gen); + /* store lower half of addr into insn[insn_idx].imm */ + emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_9, offsetof(struct bpf_insn, imm))); + /* store upper half of addr into insn[insn_idx + 1].imm */ + emit(gen, BPF_ALU64_IMM(BPF_RSH, BPF_REG_9, 32)); + emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_9, + sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm))); +log: + if (!gen->log_level) + return; + emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_8, + offsetof(struct bpf_insn, imm))); + emit(gen, BPF_LDX_MEM(BPF_H, BPF_REG_9, BPF_REG_8, sizeof(struct bpf_insn) + + offsetof(struct bpf_insn, imm))); + debug_regs(gen, BPF_REG_7, BPF_REG_9, " var t=0 w=%d (%s:count=%d): imm[0]: %%d, imm[1]: %%d", + relo->is_weak, relo->name, kdesc->ref); + emit(gen, BPF_LDX_MEM(BPF_B, BPF_REG_9, BPF_REG_8, offsetofend(struct bpf_insn, code))); + debug_regs(gen, BPF_REG_9, -1, " var t=0 w=%d (%s:count=%d): insn.reg", + relo->is_weak, relo->name, kdesc->ref); +} + +/* Expects: + * BPF_REG_8 - pointer to instruction + */ +static void emit_relo_ksym_btf(struct bpf_gen *gen, struct ksym_relo_desc *relo, int insn) +{ + struct ksym_desc *kdesc; + __u32 reg_mask; + + kdesc = get_ksym_desc(gen, relo); + if (!kdesc) + return; + /* try to copy from existing ldimm64 insn */ + if (kdesc->ref > 1) { + move_blob2blob(gen, insn + offsetof(struct bpf_insn, imm), 4, + kdesc->insn + offsetof(struct bpf_insn, imm)); + move_blob2blob(gen, insn + sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm), 4, + kdesc->insn + sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm)); + emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_9, BPF_REG_8, offsetof(struct bpf_insn, imm))); + /* jump over src_reg adjustment if imm is not 0 */ + emit(gen, BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0, 3)); + goto clear_src_reg; + } /* remember insn offset, so we can copy BTF ID and FD later */ kdesc->insn = insn; emit_bpf_find_by_name_kind(gen, relo); - emit_check_err(gen); + if (!relo->is_weak) + emit_check_err(gen); + /* set default values as 0 */ + emit(gen, BPF_ST_MEM(BPF_W, BPF_REG_8, offsetof(struct bpf_insn, imm), 0)); + emit(gen, BPF_ST_MEM(BPF_W, BPF_REG_8, sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm), 0)); + /* skip success case stores if ret < 0 */ + emit(gen, BPF_JMP_IMM(BPF_JSLT, BPF_REG_7, 0, 4)); /* store btf_id into insn[insn_idx].imm */ emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_7, offsetof(struct bpf_insn, imm))); /* store btf_obj_fd into insn[insn_idx + 1].imm */ emit(gen, BPF_ALU64_IMM(BPF_RSH, BPF_REG_7, 32)); emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_7, sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm))); -log: + emit(gen, BPF_JMP_IMM(BPF_JSGE, BPF_REG_7, 0, 3)); +clear_src_reg: + /* clear bpf_object__relocate_data's src_reg assignment, otherwise we get a verifier failure */ +#if defined(__LITTLE_ENDIAN_BITFIELD) + reg_mask = 0x0f; /* src_reg,dst_reg,... */ +#elif defined(__BIG_ENDIAN_BITFIELD) + reg_mask = 0xf0; /* dst_reg,src_reg,... */ +#else +#error "Unsupported bit endianness, cannot proceed" +#endif + emit(gen, BPF_LDX_MEM(BPF_B, BPF_REG_9, BPF_REG_8, offsetofend(struct bpf_insn, code))); + emit(gen, BPF_ALU32_IMM(BPF_AND, BPF_REG_9, reg_mask)); + emit(gen, BPF_STX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, offsetofend(struct bpf_insn, code))); + if (!gen->log_level) return; emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_8, offsetof(struct bpf_insn, imm))); emit(gen, BPF_LDX_MEM(BPF_H, BPF_REG_9, BPF_REG_8, sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm))); - debug_regs(gen, BPF_REG_7, BPF_REG_9, " var (%s:count=%d): imm: %%d, fd: %%d", - relo->name, kdesc->ref); + debug_regs(gen, BPF_REG_7, BPF_REG_9, " var t=1 w=%d (%s:count=%d): imm[0]: %%d, imm[1]: %%d", + relo->is_weak, relo->name, kdesc->ref); + emit(gen, BPF_LDX_MEM(BPF_B, BPF_REG_9, BPF_REG_8, offsetofend(struct bpf_insn, code))); + debug_regs(gen, BPF_REG_9, -1, " var t=1 w=%d (%s:count=%d): insn.reg", + relo->is_weak, relo->name, kdesc->ref); } static void emit_relo(struct bpf_gen *gen, struct ksym_relo_desc *relo, int insns) @@ -748,7 +849,10 @@ static void emit_relo(struct bpf_gen *gen, struct ksym_relo_desc *relo, int insn emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_8, BPF_PSEUDO_MAP_IDX_VALUE, 0, 0, 0, insn)); switch (relo->kind) { case BTF_KIND_VAR: - emit_relo_ksym_btf(gen, relo, insn); + if (relo->is_typeless) + emit_relo_ksym_typeless(gen, relo, insn); + else + emit_relo_ksym_btf(gen, relo, insn); break; case BTF_KIND_FUNC: emit_relo_kfunc_btf(gen, relo, insn); @@ -773,12 +877,13 @@ static void cleanup_relos(struct bpf_gen *gen, int insns) int i, insn; for (i = 0; i < gen->nr_ksyms; i++) { - if (gen->ksyms[i].kind == BTF_KIND_VAR) { + /* only close fds for typed ksyms and kfuncs */ + if (gen->ksyms[i].kind == BTF_KIND_VAR && !gen->ksyms[i].typeless) { /* close fd recorded in insn[insn_idx + 1].imm */ insn = gen->ksyms[i].insn; insn += sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm); emit_sys_close_blob(gen, insn); - } else { /* BTF_KIND_FUNC */ + } else if (gen->ksyms[i].kind == BTF_KIND_FUNC) { emit_sys_close_blob(gen, blob_fd_array_off(gen, gen->ksyms[i].off)); if (gen->ksyms[i].off < MAX_FD_ARRAY_SZ) gen->nr_fd_array--; diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index f32fa51b1e63..d286dec73b5f 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -6355,17 +6355,14 @@ static int bpf_program__record_externs(struct bpf_program *prog) case RELO_EXTERN_VAR: if (ext->type != EXT_KSYM) continue; - if (!ext->ksym.type_id) { - pr_warn("typeless ksym %s is not supported yet\n", - ext->name); - return -ENOTSUP; - } - bpf_gen__record_extern(obj->gen_loader, ext->name, ext->is_weak, + bpf_gen__record_extern(obj->gen_loader, ext->name, + ext->is_weak, !ext->ksym.type_id, BTF_KIND_VAR, relo->insn_idx); break; case RELO_EXTERN_FUNC: - bpf_gen__record_extern(obj->gen_loader, ext->name, ext->is_weak, - BTF_KIND_FUNC, relo->insn_idx); + bpf_gen__record_extern(obj->gen_loader, ext->name, + ext->is_weak, 0, BTF_KIND_FUNC, + relo->insn_idx); break; default: continue; From patchwork Wed Oct 6 00:28:50 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kumar Kartikeya Dwivedi X-Patchwork-Id: 12538261 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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 92923C433EF for ; Wed, 6 Oct 2021 00:29:13 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 67CF9611C5 for ; Wed, 6 Oct 2021 00:29:13 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237060AbhJFAbD (ORCPT ); Tue, 5 Oct 2021 20:31:03 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44024 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237007AbhJFAa5 (ORCPT ); Tue, 5 Oct 2021 20:30:57 -0400 Received: from mail-pj1-x1042.google.com (mail-pj1-x1042.google.com [IPv6:2607:f8b0:4864:20::1042]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 166C3C061749; Tue, 5 Oct 2021 17:29:06 -0700 (PDT) Received: by mail-pj1-x1042.google.com with SMTP id q7-20020a17090a2e0700b001a01027dd88so1377348pjd.1; Tue, 05 Oct 2021 17:29:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=4UqEpcscfQ03cFhb1sYSCPHOjFjHmnSxOjNPBp/HO14=; b=nLGNBEpbdEPYvDdjcEUMHc4XF6NO+jjUxmm9/UNVX8BNZHTKe2+RZLJq6o0fhJJZG8 Qy7JpEkP8W9jC9QgQIYhwOvTWH1dbfrym9IqCJi8lg6hseN8h5prHp1R6nuqqGkSOPyX oMtN+wa5qQnNu3Q1DfWSNG6ojeahI8AIqyDaRMmHMbkeiBLisf3GO6oifyRBj/b8hLXe gIhyrIJzIxfQ0D0uVkTk1tafmZWEFzc5vCy77mK2dFoYlQTV+8Nf1Th8rSPa44JZ2egF koX7M9dOkWlU50HiBoZDzVw9LYQdMwJiDdx5qBqHpy3dw/ztRfqhqAtF42uFQSxcoj4Q JWyQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=4UqEpcscfQ03cFhb1sYSCPHOjFjHmnSxOjNPBp/HO14=; b=vQ0+zxEO/begRlVsNrQF8UKECToHOHvcdsdlem1lnWuDIcEbkYokF5CCRGOJqMzrcG 1L44NPDK+7x/1kq8GIZN7UZCBOOTLu4beEKQbacXmiNh0jkM08YVM6bypUyXD8ES/EUM eq7m1rCZd+E6lamfq5vSXC/EiSG2z7bZ1tsDsLpHAUPm3MM1blU1zRoJohHKebwb9ST6 yyr9nz2XE8K1Sbfque2D3N8QEJSLZ14QMxAF5aHR4GfjGathv+68BUw4Dyzl3tqBjd7K YhaTgYQA8llImjEOSHXjqus0dV9+CWYFAtSf+/xY1YadAc2XokXIfbI83OQlcnkSuuuL 25iQ== X-Gm-Message-State: AOAM531B+hv8P76AmRCO+LnD0E5emd2MsKZbdMKeoLkrdCJTp8eShryY gqhbQotMpeOXMk4DAnKoUn3bqW62WIg= X-Google-Smtp-Source: ABdhPJyFBuvexMWs9holY9ZycW2fFqRSZNvZw9SwY190utqvjgFW4qT5Jy8bhxXNy4AHCEOjT3qWLg== X-Received: by 2002:a17:902:7b85:b0:13d:cdc4:9531 with SMTP id w5-20020a1709027b8500b0013dcdc49531mr8092338pll.27.1633480145484; Tue, 05 Oct 2021 17:29:05 -0700 (PDT) Received: from localhost ([2405:201:6014:d058:a28d:3909:6ed5:29e7]) by smtp.gmail.com with ESMTPSA id l24sm19042418pgt.77.2021.10.05.17.29.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Oct 2021 17:29:05 -0700 (PDT) From: Kumar Kartikeya Dwivedi To: bpf@vger.kernel.org Cc: Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Martin KaFai Lau , Song Liu , Yonghong Song , Jesper Dangaard Brouer , =?utf-8?q?Toke_H=C3=B8iland-J=C3=B8rgensen?= , netdev@vger.kernel.org Subject: [PATCH bpf-next v1 3/6] libbpf: Ensure that module BTF fd is never 0 Date: Wed, 6 Oct 2021 05:58:50 +0530 Message-Id: <20211006002853.308945-4-memxor@gmail.com> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20211006002853.308945-1-memxor@gmail.com> References: <20211006002853.308945-1-memxor@gmail.com> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=1329; h=from:subject; bh=6vaY63fTOrdOcgwuh5tqf+Er7r1dLYsnaLf5oJmNO6I=; b=owEBbAKT/ZANAwAIAUzgyIZIvxHKAcsmYgBhXOxQAOiKhIBZO783+I7/of0v1cYzKQbbUT3GlwHG HZyFuA+JAjIEAAEIAB0WIQRLvip+Buz51YI8YRFM4MiGSL8RygUCYVzsUAAKCRBM4MiGSL8RysHND/ i245URMaBhGwGSRuGz6YvkUsZAhmmyiJTBQuEpcXHpdTI3KN0AgUEYXQLEVJIEjQAVd4+2VGa4Q7i9 jJUoY1i2EydpYhBrKq1gz8xjg1BfdwJq6BEDAUkfSlIocmTMjfwOqJ1giL969Qo3XLQhQ0/tQFi2s5 X1uBQVO2TP6S/vXJCa/v2OKX/aIehNqr8I0yDDpYfWNu6D5zO9FGghpYIaCk0qt+iVtbCsKvJd7c+I bIWHXR1dtUpE+NiBCu83TQC4PL9LGEvaXwKVwIu1rXFXhQ1ZZomp9rjzWOHh4VLBemOWi06cUKI52v rq/D0WgyKVd8uiA9OQw83bJgu5BzUoGQMpPubRRtEdtDo9vKD+EwlbJTS4ErrHfxS1x0It7qqUiQHv CAmWcPVD0XC9tA/zOQ7kAfLZhUaSYpoOa46UG55IZHmlxJej6kh7G0MLRrBrhFQMWHZ+fwLQ7s5kjs G7b94QOWU5ecfIihmxu5UjXUvAseBO7ah/1kO7X2lAVNW7frm+exmAsNbWon//CAwoPv1TmZRrarH1 rhT2pMt/tsDUYN7zNtU7/otcr+rPG+tVfK7o2iQ/zB9GZ0ND7yLOER7r2hJu781CAvwoFZLJSnRpgr eZvo6WbjtThNCxkds1ES39j3WMqXUamoMbAsQqE9OU0L2QGP/YpDwM8klQ X-Developer-Key: i=memxor@gmail.com; a=openpgp; fpr=4BBE2A7E06ECF9D5823C61114CE0C88648BF11CA Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net Since the code assumes in various places that BTF fd for modules is never 0, if we end up getting fd as 0, obtain a new fd > 0. Even though fd 0 being free for allocation is usually an application error, it is still possible that we end up getting fd 0 if the application explicitly closes its stdin. Deal with this by getting a new fd using dup and closing fd 0. Signed-off-by: Kumar Kartikeya Dwivedi --- tools/lib/bpf/libbpf.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index d286dec73b5f..3e5e460fe63e 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -4975,6 +4975,20 @@ static int load_module_btfs(struct bpf_object *obj) pr_warn("failed to get BTF object #%d FD: %d\n", id, err); return err; } + /* Make sure module BTF fd is never 0, as kernel depends on it + * being > 0 to distinguish between vmlinux and module BTFs, + * e.g. for BPF_PSEUDO_BTF_ID ld_imm64 insns (ksyms). + */ + if (!fd) { + fd = dup(0); + if (fd < 0) { + err = -errno; + pr_warn("failed to dup BTF object #%d FD 0 to FD > 0: %d\n", id, err); + close(0); + return err; + } + close(0); + } len = sizeof(info); memset(&info, 0, sizeof(info)); From patchwork Wed Oct 6 00:28:51 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kumar Kartikeya Dwivedi X-Patchwork-Id: 12538263 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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E0409C4332F for ; Wed, 6 Oct 2021 00:29:14 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id C840E611C3 for ; Wed, 6 Oct 2021 00:29:14 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237080AbhJFAbF (ORCPT ); Tue, 5 Oct 2021 20:31:05 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44058 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237086AbhJFAbD (ORCPT ); Tue, 5 Oct 2021 20:31:03 -0400 Received: from mail-pf1-x444.google.com (mail-pf1-x444.google.com [IPv6:2607:f8b0:4864:20::444]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0EEE5C061766; Tue, 5 Oct 2021 17:29:09 -0700 (PDT) Received: by mail-pf1-x444.google.com with SMTP id p1so875612pfh.8; Tue, 05 Oct 2021 17:29:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=XTgi6QrC3BHmTI8J3/+5DjgDIrcuKtZUvmL8l9gwicQ=; b=Lb8Jx2+HX+68yZ0yWPfsXJDV71rc+i+6m6KCOyikcAAToyVmVOkYrRlFoZwAZv5OJ7 nlLPHbnIavg9gRn9/Up3oPdqAAJhcrNtSxoQPSy6cX5WoYCanm5VbdSkAqr/9NARqZis QjTHVYeik0qWSdSG0KrPHHok4Db39C1aSa1rxcY9Akc5YsS53rh1YRxXsw+gOQNWlwu4 I1ZWtte66ozqsjo6jt9IAMNg0R/wdyQ8R8RhOhByCfPzY2qeGx0JVzuF8Hqwak5pJtv1 tkVD+e1IjufDS6GYDWeRvBzdg22pL++K5BINumHep9llkqh1Vog3bIQVt5CuBMHq5n78 k7zw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=XTgi6QrC3BHmTI8J3/+5DjgDIrcuKtZUvmL8l9gwicQ=; b=P7dSx5hw0Do9EEQnsAzyhTuHFjrmXNfP8/+rV4JIUpq8w3gxSmvIg7XfibF9ykX5/j Zlsjzr64TGzIvqhWyD4MwPfzMlDEMGBkka5QsShN5vKl8A+WQPrmhf8YRhYPd+Z84mqF Ozdwn3F60vfCf+3VJQKnMAmaZLKJeVUU8VO3tzbCTnh/zxAS3tUsOS+0mGzw9iJsfj86 vAmhNOY00obqJbrg4/UwkEtyGSj6kYsnkWAzfbSRXQtxpnYgBs/4UXJSFNLZPjeU/xhR 5ZteD5igstQKgxMZnLzq1BrHieoobRRjoXdqGgcNF05T/CqaoF4WvwteRhEeCi84xc4V wSDw== X-Gm-Message-State: AOAM5332BCO2duHVdDHLUvtsGZJ6mVSgi2UbYYVyEp7zXPmxT39fmDy+ ZUrvkBlmDjeLhLemB+BtdDjeWS9cKLQ= X-Google-Smtp-Source: ABdhPJw5Ogv0igCRAiRnnf+1HnNLIfF2A6H4Pxxxvmd3EseeuWrAbdQ+S4kFnLomgj9GuxmSH04gCw== X-Received: by 2002:aa7:9e9a:0:b0:447:a1be:ee48 with SMTP id p26-20020aa79e9a000000b00447a1beee48mr33721275pfq.48.1633480148373; Tue, 05 Oct 2021 17:29:08 -0700 (PDT) Received: from localhost ([2405:201:6014:d058:a28d:3909:6ed5:29e7]) by smtp.gmail.com with ESMTPSA id w9sm3139155pjk.28.2021.10.05.17.29.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Oct 2021 17:29:08 -0700 (PDT) From: Kumar Kartikeya Dwivedi To: bpf@vger.kernel.org Cc: Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Martin KaFai Lau , Song Liu , Yonghong Song , Jesper Dangaard Brouer , =?utf-8?q?Toke_H=C3=B8iland-J=C3=B8rgensen?= , netdev@vger.kernel.org Subject: [PATCH bpf-next v1 4/6] bpf: selftests: Move test_ksyms_weak test to lskel, add libbpf test Date: Wed, 6 Oct 2021 05:58:51 +0530 Message-Id: <20211006002853.308945-5-memxor@gmail.com> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20211006002853.308945-1-memxor@gmail.com> References: <20211006002853.308945-1-memxor@gmail.com> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=4343; h=from:subject; bh=4tvYwn/5csi5Df3dmPxmGgXq6bkFX36iyn8BycVhcas=; b=owEBbQKS/ZANAwAIAUzgyIZIvxHKAcsmYgBhXOxQqrCmUDw5RRQ3lXczpuZ7vo9kuj6AQK3LrGui 8/4lPJ+JAjMEAAEIAB0WIQRLvip+Buz51YI8YRFM4MiGSL8RygUCYVzsUAAKCRBM4MiGSL8RypQKD/ oDWREw8xu93e/2kxHE/qJWeHTq7s9jzgHKvywjoCMttHzZs11nNjd/2LuXyCqzXj38VfHQjm9VAova 9Rkni2WcHgmLwgHqbniXJnB4ly9UzjDVd4qkyKdRUMqJeDOCSjPT+kvItPi2Bv7oA3b50EinTPFtnc AUvhPgCXQNb5TbO435+9crIWwWuyN2U4R1MAG/KaRLNIbd8ASlyFAbJzT0C4bAnrD7fb+f91ShtVvn pnZNeC8p/1WNG0Cm7RyNWpno6/0ccUDhFwrBpVxzUuOw8Ha9PRx15hr3pJRRiHAB/GJEjeI5vle8kW Pgu6tRmQLiMfTsr+pC7Qy74EsttxKjb6oY8pbADuJ9vUkgHFGsuSfOXE/lac3vR6KnXT51r3S9daU+ cZXCXQXvx+vn3SxNpOLLPQuNX3bcVTKzqzo74jNhaycEX8mUEkAsX365/hHJ8ZHCzCYuB207RfRazj NiEssOe+wVj1FIU6RjTziN9uQevrtZwPMhFoSFwRsAc82dqT6oukd9MCRmutRj79raocifh2l469ax ml3lCpHSibjfCbTzod97vK1aqweLycK+3pc4cITiKmf30HvNIelkrFNi1lOzIQGlepS+np3Pv3duxP 1JUa6Lbmy/4Lpg8bwnTHIQzZMlysnHMO9Dm8jseq1zR21figdmgd3cJH7Inw== X-Developer-Key: i=memxor@gmail.com; a=openpgp; fpr=4BBE2A7E06ECF9D5823C61114CE0C88648BF11CA Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net Also, avoid using CO-RE features, as lskel doesn't support CO-RE, yet. Create a file for testing libbpf skeleton as well, so that both gen_loader and libbpf get tested. Signed-off-by: Kumar Kartikeya Dwivedi --- tools/testing/selftests/bpf/Makefile | 2 +- .../selftests/bpf/prog_tests/ksyms_btf.c | 6 ++-- .../bpf/prog_tests/ksyms_weak_libbpf.c | 31 +++++++++++++++++++ .../selftests/bpf/progs/test_ksyms_weak.c | 3 +- 4 files changed, 36 insertions(+), 6 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/ksyms_weak_libbpf.c diff --git a/tools/testing/selftests/bpf/Makefile b/tools/testing/selftests/bpf/Makefile index c5c9a9f50d8d..4ae5bc852ca8 100644 --- a/tools/testing/selftests/bpf/Makefile +++ b/tools/testing/selftests/bpf/Makefile @@ -317,7 +317,7 @@ LINKED_SKELS := test_static_linked.skel.h linked_funcs.skel.h \ LSKELS := kfunc_call_test.c fentry_test.c fexit_test.c fexit_sleep.c \ test_ringbuf.c atomics.c trace_printk.c trace_vprintk.c # Generate both light skeleton and libbpf skeleton for these -LSKELS_EXTRA := test_ksyms_module.c +LSKELS_EXTRA := test_ksyms_module.c test_ksyms_weak.c SKEL_BLACKLIST += $$(LSKELS) test_static_linked.skel.h-deps := test_static_linked1.o test_static_linked2.o diff --git a/tools/testing/selftests/bpf/prog_tests/ksyms_btf.c b/tools/testing/selftests/bpf/prog_tests/ksyms_btf.c index cf3acfa5a91d..21ff02d47076 100644 --- a/tools/testing/selftests/bpf/prog_tests/ksyms_btf.c +++ b/tools/testing/selftests/bpf/prog_tests/ksyms_btf.c @@ -6,7 +6,7 @@ #include #include "test_ksyms_btf.skel.h" #include "test_ksyms_btf_null_check.skel.h" -#include "test_ksyms_weak.skel.h" +#include "test_ksyms_weak.lskel.h" static int duration; @@ -89,11 +89,11 @@ static void test_weak_syms(void) int err; skel = test_ksyms_weak__open_and_load(); - if (CHECK(!skel, "test_ksyms_weak__open_and_load", "failed\n")) + if (!ASSERT_OK_PTR(skel, "test_ksyms_weak__open_and_load")) return; err = test_ksyms_weak__attach(skel); - if (CHECK(err, "test_ksyms_weak__attach", "skeleton attach failed: %d\n", err)) + if (!ASSERT_OK(err, "test_ksyms_weak__attach")) goto cleanup; /* trigger tracepoint */ diff --git a/tools/testing/selftests/bpf/prog_tests/ksyms_weak_libbpf.c b/tools/testing/selftests/bpf/prog_tests/ksyms_weak_libbpf.c new file mode 100644 index 000000000000..b75725e28647 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/ksyms_weak_libbpf.c @@ -0,0 +1,31 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include "test_ksyms_weak.skel.h" + +void test_ksyms_weak_libbpf(void) +{ + struct test_ksyms_weak *skel; + struct test_ksyms_weak__data *data; + int err; + + skel = test_ksyms_weak__open_and_load(); + if (!ASSERT_OK_PTR(skel, "test_ksyms_weak__open_and_load")) + return; + + err = test_ksyms_weak__attach(skel); + if (!ASSERT_OK(err, "test_ksyms_weak__attach")) + goto cleanup; + + /* trigger tracepoint */ + usleep(1); + + data = skel->data; + ASSERT_EQ(data->out__existing_typed, 0, "existing typed ksym"); + ASSERT_NEQ(data->out__existing_typeless, -1, "existing typeless ksym"); + ASSERT_EQ(data->out__non_existent_typeless, 0, "nonexistent typeless ksym"); + ASSERT_EQ(data->out__non_existent_typed, 0, "nonexistent typed ksym"); + +cleanup: + test_ksyms_weak__destroy(skel); +} diff --git a/tools/testing/selftests/bpf/progs/test_ksyms_weak.c b/tools/testing/selftests/bpf/progs/test_ksyms_weak.c index 5f8379aadb29..521e7b99db08 100644 --- a/tools/testing/selftests/bpf/progs/test_ksyms_weak.c +++ b/tools/testing/selftests/bpf/progs/test_ksyms_weak.c @@ -21,7 +21,6 @@ __u64 out__non_existent_typed = -1; extern const struct rq runqueues __ksym __weak; /* typed */ extern const void bpf_prog_active __ksym __weak; /* typeless */ - /* non-existent weak symbols. */ /* typeless symbols, default to zero. */ @@ -38,7 +37,7 @@ int pass_handler(const void *ctx) /* tests existing symbols. */ rq = (struct rq *)bpf_per_cpu_ptr(&runqueues, 0); if (rq) - out__existing_typed = rq->cpu; + out__existing_typed = 0; out__existing_typeless = (__u64)&bpf_prog_active; /* tests non-existent symbols. */ From patchwork Wed Oct 6 00:28:52 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kumar Kartikeya Dwivedi X-Patchwork-Id: 12538265 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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id A96E4C433F5 for ; Wed, 6 Oct 2021 00:29:16 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 933AB611C3 for ; Wed, 6 Oct 2021 00:29:16 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237115AbhJFAbG (ORCPT ); Tue, 5 Oct 2021 20:31:06 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44062 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237089AbhJFAbD (ORCPT ); Tue, 5 Oct 2021 20:31:03 -0400 Received: from mail-pg1-x544.google.com (mail-pg1-x544.google.com [IPv6:2607:f8b0:4864:20::544]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CA492C061749; Tue, 5 Oct 2021 17:29:11 -0700 (PDT) Received: by mail-pg1-x544.google.com with SMTP id q201so860095pgq.12; Tue, 05 Oct 2021 17:29:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=lJuMPGCG6/YTXwopHoyLaCt3/oTqYL0QNWlBCFoiYPE=; b=HopOb8htRn3ReOz6IidivDTexuxMJRcPgFYbHeEWMsZy6H56yqEXEVMFJJZ63WJU6O mW4fancKmjDT7S3Jk/hyxcMCVBpsQjBdQ4G0cbq305zslNZmY0PWPKWPntdztJZbGp8Q 1ZiAAriYqlJ8CCMf9im2mcJ3fWO1AZaxmivSqFYRnijCK4kzVFY7Kew92f/o7QMDLR2o ZYM83VeCbW9ru6Ag0v0qydiGL9flrt9Ac6XUL/aosKaLk3Rk7Sd3vv+nsHPUoeIdDCQI H7lFD/yiz8hQtEVw1mZ8aBOdz7P+6Xahdq+oLeHC0eSKipYEPDvaiistg6GFu/rHVSo0 eVTQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=lJuMPGCG6/YTXwopHoyLaCt3/oTqYL0QNWlBCFoiYPE=; b=ms8UdOVHu9im7lqzO12bEzNRycXM6EdaKBCqysxp5O2aWlvYEsMuRas85FPW97m0YX Ed5VTtgN/VEHsdibneBlIY29IluBH4uXC4crkHbpHW/CSf61wIXK3HP3GmUJvn3xvu3e fSTlQnsiZV+S0C/IvYkWRc2EXLjSvdaimLinZ4oahvIdPzvvFTbHBGQwgY6CgnuCH6FW KDRmNv/wYYMoT8iW2lfJ62/LQkMTglok8F4D9vG6UmaWSWviygiVOm66g4J8n3glN63J Kuei1Fooit/LFG1vxF+yA9Tue5CFwBcvEmwQprRBKdV7cMED8FxyN//lNsKWyuVF5tJn ONfQ== X-Gm-Message-State: AOAM532KabGxk2UC0qJ9cPSmfyO3IQk/y3719LNDjmoeIXWsBSitZbkY 0coZw50NkMI0F45xn5/zk8lkeGLPDek= X-Google-Smtp-Source: ABdhPJxN3bdlX5x0/6SsTpIRyn3CaonHA06YuNwgtUnXJCfYVifL0PI5LGpxhkQZ0EzqEqnB8vdgDA== X-Received: by 2002:a62:770f:0:b0:44c:4bea:6f89 with SMTP id s15-20020a62770f000000b0044c4bea6f89mr18969106pfc.57.1633480151233; Tue, 05 Oct 2021 17:29:11 -0700 (PDT) Received: from localhost ([2405:201:6014:d058:a28d:3909:6ed5:29e7]) by smtp.gmail.com with ESMTPSA id 4sm2983960pjb.21.2021.10.05.17.29.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Oct 2021 17:29:11 -0700 (PDT) From: Kumar Kartikeya Dwivedi To: bpf@vger.kernel.org Cc: Jakub Sitnicki , Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Martin KaFai Lau , Song Liu , Yonghong Song , Jesper Dangaard Brouer , =?utf-8?q?Toke_H=C3=B8iland-J?= =?utf-8?q?=C3=B8rgensen?= , netdev@vger.kernel.org Subject: [PATCH bpf-next v1 5/6] bpf: selftests: Fix fd cleanup in sk_lookup test Date: Wed, 6 Oct 2021 05:58:52 +0530 Message-Id: <20211006002853.308945-6-memxor@gmail.com> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20211006002853.308945-1-memxor@gmail.com> References: <20211006002853.308945-1-memxor@gmail.com> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=2664; h=from:subject; bh=sgdsNBMusMzMKjmE0dNfyjREBKA+EEfPwKHfnCJm1hg=; b=owEBbAKT/ZANAwAIAUzgyIZIvxHKAcsmYgBhXOxQEHLhwSlTj4oi9HPDnomVV0Mp18+3yh9lWx8u TbxeCAaJAjIEAAEIAB0WIQRLvip+Buz51YI8YRFM4MiGSL8RygUCYVzsUAAKCRBM4MiGSL8RyvjRD/ jzrvD54e/4V6XoPzS626AmyOvFS9F7n4SK7nSvz3J4OYKy617twNKr40P5zZdyrc96zPXhPpOs01SI i/vKqUx2df2MxrfFpiSIWCraQrK/NP0JwJ3tN/aIGOZAAcdAAo+8eGaO5zDShObQtUJ+8D+gzKBewr rtfrtNyziuLtxFpHGfSOU1l1Y9hsKHi+7nWW34VxVsHWOWRUaeZMNIw9t4Tw9OdtCwQ6zh1Mkl8y7I CxF2/qJPGQaac1tVVS7C2UAbVCUA5Q3Oj9fC0oyfkSgPEur2QzFUJt15jHHR7sDOy+bvsL+RqKabnn 5fXSXsIqaFHYSSoqjYbBGetnv/avFI+WXVpnwFTj0ivdHZF1lrH9mad9azUQ0WorR90f8aanOL0dy2 cQL4UYtuvIAMZcO4bTrbEAvFH1eNVN4xCuXd/bdDfR7Qh1hzFQoqKO4iXvaqoeLgvRjkTw6SwIEd3O vKJLluvr1scLLm8ZFiRvK+vzgY0Jq7p+Ejacjbiq8WGIUfHDv2PBzzJAbKK4kakFP/BNxlh2Y+jThC gplS8adhflxqqU7AuTtbFVr0nyivYbhgff7HS65lBohJHBa07HegJu6TSwKnFUrw61WOlth9kwA/PD hnlJHcJHmVMwVZAgttIS9GE45eTbax6NIA9QWBdUmIA4TbCPsNaj/f7tfQ X-Developer-Key: i=memxor@gmail.com; a=openpgp; fpr=4BBE2A7E06ECF9D5823C61114CE0C88648BF11CA Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net Similar to the fix in commit: e31eec77e4ab (bpf: selftests: Fix fd cleanup in get_branch_snapshot) We use memset to set fds to -1 without breaking on future changes to the array size (when MAX_SERVER constant is bumped). The particular close(0) occurs on non-reuseport tests, so it can be seen with -n 115/{2,3} but not 115/4. This can cause problems with future tests if they depend on BTF fd never being acquired as fd 0, breaking internal libbpf assumptions. Cc: Jakub Sitnicki Fixes: 0ab5539f8584 (selftests/bpf: Tests for BPF_SK_LOOKUP attach point) Signed-off-by: Kumar Kartikeya Dwivedi Reviewed-by: Jakub Sitnicki Acked-by: Song Liu --- .../selftests/bpf/prog_tests/sk_lookup.c | 20 +++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/tools/testing/selftests/bpf/prog_tests/sk_lookup.c b/tools/testing/selftests/bpf/prog_tests/sk_lookup.c index aee41547e7f4..572220065bdf 100644 --- a/tools/testing/selftests/bpf/prog_tests/sk_lookup.c +++ b/tools/testing/selftests/bpf/prog_tests/sk_lookup.c @@ -598,11 +598,14 @@ static void query_lookup_prog(struct test_sk_lookup *skel) static void run_lookup_prog(const struct test *t) { - int server_fds[MAX_SERVERS] = { -1 }; int client_fd, reuse_conn_fd = -1; struct bpf_link *lookup_link; + int server_fds[MAX_SERVERS]; int i, err; + /* set all fds to -1 */ + memset(server_fds, 0xFF, sizeof(server_fds)); + lookup_link = attach_lookup_prog(t->lookup_prog); if (!lookup_link) return; @@ -663,8 +666,9 @@ static void run_lookup_prog(const struct test *t) if (reuse_conn_fd != -1) close(reuse_conn_fd); for (i = 0; i < ARRAY_SIZE(server_fds); i++) { - if (server_fds[i] != -1) - close(server_fds[i]); + if (server_fds[i] == -1) + break; + close(server_fds[i]); } bpf_link__destroy(lookup_link); } @@ -1053,11 +1057,14 @@ static void run_sk_assign(struct test_sk_lookup *skel, struct bpf_program *lookup_prog, const char *remote_ip, const char *local_ip) { - int server_fds[MAX_SERVERS] = { -1 }; + int server_fds[MAX_SERVERS]; struct bpf_sk_lookup ctx; __u64 server_cookie; int i, err; + /* set all fds to -1 */ + memset(server_fds, 0xFF, sizeof(server_fds)); + DECLARE_LIBBPF_OPTS(bpf_test_run_opts, opts, .ctx_in = &ctx, .ctx_size_in = sizeof(ctx), @@ -1097,8 +1104,9 @@ static void run_sk_assign(struct test_sk_lookup *skel, close_servers: for (i = 0; i < ARRAY_SIZE(server_fds); i++) { - if (server_fds[i] != -1) - close(server_fds[i]); + if (server_fds[i] == -1) + break; + close(server_fds[i]); } } From patchwork Wed Oct 6 00:28:53 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kumar Kartikeya Dwivedi X-Patchwork-Id: 12538267 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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 92CFFC433EF for ; Wed, 6 Oct 2021 00:29:21 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 6F24E611C3 for ; Wed, 6 Oct 2021 00:29:21 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237105AbhJFAbL (ORCPT ); Tue, 5 Oct 2021 20:31:11 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44074 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237086AbhJFAbF (ORCPT ); Tue, 5 Oct 2021 20:31:05 -0400 Received: from mail-pf1-x443.google.com (mail-pf1-x443.google.com [IPv6:2607:f8b0:4864:20::443]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A91D2C061749; Tue, 5 Oct 2021 17:29:14 -0700 (PDT) Received: by mail-pf1-x443.google.com with SMTP id h1so859033pfv.12; Tue, 05 Oct 2021 17:29:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=mO8eLvTvx7uyO48zoyP55mESCJ3tJ4Kie0/HPIIxwyg=; b=iGnWmTa44eJeXi9HPgNbokxxNV9dFqcdJ+HZ0wDpABr7YcoQYsGMaeK6NHHTFQbKXO LJseX/qX/t+q9nOkDM3raKstiSbBXhBIE1GKmHS8Q+DbByxuyNkPvDZDZ+xVn89E3Kii nvlYE2VSQZj7lQWdxMp9lU01wgn0mV1RZBF8NBFrJayvtjloWBX7BWyRtIm0sSMdVNCg Z43LcGHuInFo0j30FCmgkVJGf8ftxcuGI/rAYI2vEc1ZM4DxVfOndQ+FKA95LuPZS8hl oADO01uBPny3GXriDfcjpUOTTk+1wWh3Tlc3YkPpX/ZXGg+VgD3pxGfGUzw1VaCuDxF/ o3AQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=mO8eLvTvx7uyO48zoyP55mESCJ3tJ4Kie0/HPIIxwyg=; b=QCxQZc24m/CkB5mdfcl/lWntjhGS5+PIT5EvR9c+usNs9icylE7nUXa6wKDdOL9+WH gNCd0xNKVHAZVC/EvjAnjKMCOXASK7aFsSeX1cuV+n2H3SZHUrOE/2I02Q0tpKMbXyBh KHTWV5p44Lc3bm8rIeD6hKJDKMFCRSPYb3ENIXZrtaCAH2xI24Voct7CkvSWAXHDE5cl /3YzaYIi1I41fyJi4tSw7TrBD7I6qhtAcLcmCPRRKDr8cLA1IcqhqkBrKjbLcOmd7FKC 5JvNCA/fCccwDaGAutups44qsQBDDrwDw6VDEdpR1/YkXQ/N+MBaTe6RvqHy8PmNpw38 e5bQ== X-Gm-Message-State: AOAM533Suw/zxI6DyDHzJymp9sdeNpqyddY0NlDzHVSItOES4ZPEnBe+ +txL7p5G0T0y6vfPXy4BmBldZgfL738= X-Google-Smtp-Source: ABdhPJzjj1yOe+0NeHxesrweh0xp2G9MEAvOosO9U4jsdedoNFeGmDqFT2E9OHkTP8DF1csPrmmQtQ== X-Received: by 2002:a65:6648:: with SMTP id z8mr18400234pgv.418.1633480154120; Tue, 05 Oct 2021 17:29:14 -0700 (PDT) Received: from localhost ([2405:201:6014:d058:a28d:3909:6ed5:29e7]) by smtp.gmail.com with ESMTPSA id j6sm18142623pgq.0.2021.10.05.17.29.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Oct 2021 17:29:13 -0700 (PDT) From: Kumar Kartikeya Dwivedi To: bpf@vger.kernel.org Cc: Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Martin KaFai Lau , Song Liu , Yonghong Song , Jesper Dangaard Brouer , =?utf-8?q?Toke_H=C3=B8iland-J=C3=B8rgensen?= , netdev@vger.kernel.org Subject: [PATCH bpf-next v1 6/6] bpf: selftests: Fix memory leak in test_ima Date: Wed, 6 Oct 2021 05:58:53 +0530 Message-Id: <20211006002853.308945-7-memxor@gmail.com> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20211006002853.308945-1-memxor@gmail.com> References: <20211006002853.308945-1-memxor@gmail.com> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=1115; h=from:subject; bh=4bfzhM+sYcTW2y2zdsHJx5N2vzbm4oaFQaoGmKSXTic=; b=owEBbQKS/ZANAwAIAUzgyIZIvxHKAcsmYgBhXOxQgI5e86LHo+jVOJkUuF0P4byE+Xxfe3jR9uE9 WjZQteGJAjMEAAEIAB0WIQRLvip+Buz51YI8YRFM4MiGSL8RygUCYVzsUAAKCRBM4MiGSL8RynvrEA C0Powb1Gh+WDgwv+3rhP5DMBEFGdnK06lC6288bG4XXpDc95ESMY9HptZU36gkLigpKvnv6phTYgg3 0alu9cfQv2iS0b+3lqMGaQ6WxLvtn52BM0DXy4oMFnfOlToOdc0I54RVFl7hcOd1FsDbzSYBmFvoLr KBBO5dAqjevxlWAx/Xq1saaFCrpf0f34LXWeXvVK+Gmuo4+OYfN34ei1lBQ2i1sHxpxprlH88QzCGS ZMEUQNxBPDScvVKPv44IyGYEAtca9SvauMD2gdByGkFvDQ2//F43aV9gU7OOz19vQE8YOBV57sxb1W DTUFx5gefvGcxjO63V/y9UsKnduRrNbvMUIqGPaPEUxvoCIt75seB8KmQ4crFI2XNlhGMRX1/1NMOp 7OwLMc8z1CxgPuGpeHVNa9ftbaB6tmeNFPB3xVlXcfYEzpunY7K/MfW3zRSKQphsrUY/eoy5Kv+gKj AmxVhF/kgdyWQ1t0S6B21dVQ2iVMMgVqt2Fo3uHcVt2WREIiO0rrd4xfxQPapEXgoQ7aQs4X0ENdaD 4/2sqChoj3lCpkhckk9S9wjokyRgCu6zah3ZzfgSbK0xLwC6/kxLM5lVVDX90cQo1Vl7RZl1IrcWPe ilrZ3OVA9FfIxoGP4e1HU47CQcomDhW38rQ+GKkewmn9eEiBDQ2dNX5MBfrg== X-Developer-Key: i=memxor@gmail.com; a=openpgp; fpr=4BBE2A7E06ECF9D5823C61114CE0C88648BF11CA Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net The allocated ring buffer is never freed, do so in the cleanup path. Fixes: f446b570ac7e (bpf/selftests: Update the IMA test to use BPF ring buffer) Signed-off-by: Kumar Kartikeya Dwivedi Acked-by: Andrii Nakryiko Acked-by: Song Liu --- tools/testing/selftests/bpf/prog_tests/test_ima.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/bpf/prog_tests/test_ima.c b/tools/testing/selftests/bpf/prog_tests/test_ima.c index 0252f61d611a..97d8a6f84f4a 100644 --- a/tools/testing/selftests/bpf/prog_tests/test_ima.c +++ b/tools/testing/selftests/bpf/prog_tests/test_ima.c @@ -43,7 +43,7 @@ static int process_sample(void *ctx, void *data, size_t len) void test_test_ima(void) { char measured_dir_template[] = "/tmp/ima_measuredXXXXXX"; - struct ring_buffer *ringbuf; + struct ring_buffer *ringbuf = NULL; const char *measured_dir; char cmd[256]; @@ -85,5 +85,6 @@ void test_test_ima(void) err = system(cmd); CHECK(err, "failed to run command", "%s, errno = %d\n", cmd, errno); close_prog: + ring_buffer__free(ringbuf); ima__destroy(skel); }