From patchwork Wed Apr 28 16:25:51 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Kumar Kartikeya Dwivedi X-Patchwork-Id: 429132 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.7 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3F885C43461 for ; Wed, 28 Apr 2021 16:26:09 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 031ED613F8 for ; Wed, 28 Apr 2021 16:26:08 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240790AbhD1Q0w (ORCPT ); Wed, 28 Apr 2021 12:26:52 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60004 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S240424AbhD1Q0t (ORCPT ); Wed, 28 Apr 2021 12:26:49 -0400 Received: from mail-pf1-x441.google.com (mail-pf1-x441.google.com [IPv6:2607:f8b0:4864:20::441]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 724DBC061573; Wed, 28 Apr 2021 09:26:02 -0700 (PDT) Received: by mail-pf1-x441.google.com with SMTP id c3so25324916pfo.3; Wed, 28 Apr 2021 09:26:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=h7RyxlTJ7s+MkJPSTDuKUKxTt1Xu/Haw0/RnSLo89FY=; b=DSXpmNIh1xTkQ2pZZpv/r4h0vYHjgeSPUfzb66qWdjKfoY6QUDGubUnRXnic0bJ7md gq+vKIP+MiSi0Q3iq5/0W4vzz2APswStJZL6tuPnfC6B1bVc86LeRWEZGTzay3CadmJo 9ArH/itSN3JkjZc58MlS3nF/RHXshIM8GVMYvYkHRzoKtHPWtNJpigT7J5poGBl0pJ59 MgmybpG4FbNO5vlQIxHM/gbO0HY7xf9GhzUdpxI2+geWaLIto8+Wm5BMSDah1Fv39JVU F4Xb5UlnQ3gZMBejmqP83DBanJkbY9X31WE0j+aiuPCmJpIUsCmouBZJkcRbF78R9I+3 KTaA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=h7RyxlTJ7s+MkJPSTDuKUKxTt1Xu/Haw0/RnSLo89FY=; b=saLxzTHoAWitobjKmq9UmjtMGPXuYpYL2NvBdzBiWdq7K8MgdoLYIYz2Zy8pkGLV3a ihzOQHMywDDmXHhN3a9OqoGBTilnCTt0hHtMvoPWvOxKDiRmb8nktb9R5h3E9SqK1viO LE48EUJeE2uMi/xUGMSM13Ve/26eLl6psyJyMky6p68V28d+7tGaXpP6roE4BxATuaL4 SwpgTXRAzEnW+/RTuQMaGPD+AWxjaanPQC4YJyxM0VTZlJc97QQZYotiXKUgioJdJNdZ qr2nJ/7jz6V1cfC9HYBqnNLepfl5Kn2NB1Lon0bcd0ohxPdKU8C1FT94T8gBfn8nK2Cc IbPw== X-Gm-Message-State: AOAM533T48sGB9GrN8dQDVXhIxpPknJDdQIzD09O8R/Vn4Rv3yjy3bx5 pUjjEzFJqX00gCgUsvKKsiAFx+QxStqunA== X-Google-Smtp-Source: ABdhPJz5oOzPkCtVa0ohi/CAxd1cdS+uBNIeofeHGp0geVZ+pGCOM6pprdUoQ1esA89jmqcW0x9gyA== X-Received: by 2002:a65:5801:: with SMTP id g1mr27010749pgr.322.1619627161623; Wed, 28 Apr 2021 09:26:01 -0700 (PDT) Received: from localhost ([112.79.247.72]) by smtp.gmail.com with ESMTPSA id a6sm191564pfh.135.2021.04.28.09.26.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 28 Apr 2021 09:26:01 -0700 (PDT) From: Kumar Kartikeya Dwivedi To: bpf@vger.kernel.org Cc: Kumar Kartikeya Dwivedi , =?utf-8?q?Toke_H=C3=B8ilan?= =?utf-8?q?d-J=C3=B8rgensen?= , Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Martin KaFai Lau , Song Liu , Yonghong Song , John Fastabend , KP Singh , "David S. Miller" , Jakub Kicinski , Jesper Dangaard Brouer , Shaun Crampton , netdev@vger.kernel.org Subject: [PATCH bpf-next v5 1/3] libbpf: add netlink helpers Date: Wed, 28 Apr 2021 21:55:51 +0530 Message-Id: <20210428162553.719588-2-memxor@gmail.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20210428162553.719588-1-memxor@gmail.com> References: <20210428162553.719588-1-memxor@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org This change introduces a few helpers to wrap open coded attribute preparation in netlink.c. It also adds a libbpf_nl_send_recv that is useful to wrap send + recv handling in a generic way. Subsequent patch will also use this function for sending and receiving a netlink response. The libbpf_nl_get_link helper has been removed instead, moving socket creation into the newly named libbpf_nl_send_recv. Every nested attribute's closure must happen using the helper nlattr_end_nested, which sets its length properly. NLA_F_NESTED is enforced using nlattr_begin_nested helper. Other simple attributes can be added directly. The maxsz parameter corresponds to the size of the request structure which is being filled in, so for instance with req being: struct { struct nlmsghdr nh; struct tcmsg t; char buf[4096]; } req; Then, maxsz should be sizeof(req). This change also converts the open coded attribute preparation with the helpers. Note that the only failure the internal call to nlattr_add could result in the nested helper would be -EMSGSIZE, hence that is what we return to our caller. The libbpf_nl_send_recv call takes care of opening the socket, sending the netlink message, receiving the response, potentially invoking callbacks, and return errors if any, and then finally close the socket. This allows users to avoid identical socket setup code in different places. The only user of libbpf_nl_get_link has been converted to make use of it. __bpf_set_link_xdp_fd_replace has also been refactored to use it. Reviewed-by: Toke Høiland-Jørgensen Signed-off-by: Kumar Kartikeya Dwivedi --- tools/lib/bpf/netlink.c | 117 ++++++++++++++++++---------------------- tools/lib/bpf/nlattr.h | 48 +++++++++++++++++ 2 files changed, 100 insertions(+), 65 deletions(-) diff --git a/tools/lib/bpf/netlink.c b/tools/lib/bpf/netlink.c index d2cb28e9ef52..6daee6640725 100644 --- a/tools/lib/bpf/netlink.c +++ b/tools/lib/bpf/netlink.c @@ -131,72 +131,53 @@ static int bpf_netlink_recv(int sock, __u32 nl_pid, int seq, return ret; } +static int libbpf_nl_send_recv(struct nlmsghdr *nh, __dump_nlmsg_t fn, + libbpf_dump_nlmsg_t _fn, void *cookie); + static int __bpf_set_link_xdp_fd_replace(int ifindex, int fd, int old_fd, __u32 flags) { - int sock, seq = 0, ret; - struct nlattr *nla, *nla_xdp; + struct nlattr *nla; + int ret; struct { struct nlmsghdr nh; struct ifinfomsg ifinfo; char attrbuf[64]; } req; - __u32 nl_pid = 0; - - sock = libbpf_netlink_open(&nl_pid); - if (sock < 0) - return sock; memset(&req, 0, sizeof(req)); req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)); req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK; req.nh.nlmsg_type = RTM_SETLINK; - req.nh.nlmsg_pid = 0; - req.nh.nlmsg_seq = ++seq; req.ifinfo.ifi_family = AF_UNSPEC; req.ifinfo.ifi_index = ifindex; /* started nested attribute for XDP */ - nla = (struct nlattr *)(((char *)&req) - + NLMSG_ALIGN(req.nh.nlmsg_len)); - nla->nla_type = NLA_F_NESTED | IFLA_XDP; - nla->nla_len = NLA_HDRLEN; + nla = nlattr_begin_nested(&req.nh, sizeof(req), IFLA_XDP); + if (!nla) + return -EMSGSIZE; /* add XDP fd */ - nla_xdp = (struct nlattr *)((char *)nla + nla->nla_len); - nla_xdp->nla_type = IFLA_XDP_FD; - nla_xdp->nla_len = NLA_HDRLEN + sizeof(int); - memcpy((char *)nla_xdp + NLA_HDRLEN, &fd, sizeof(fd)); - nla->nla_len += nla_xdp->nla_len; + ret = nlattr_add(&req.nh, sizeof(req), IFLA_XDP_FD, &fd, sizeof(fd)); + if (ret < 0) + return ret; /* if user passed in any flags, add those too */ if (flags) { - nla_xdp = (struct nlattr *)((char *)nla + nla->nla_len); - nla_xdp->nla_type = IFLA_XDP_FLAGS; - nla_xdp->nla_len = NLA_HDRLEN + sizeof(flags); - memcpy((char *)nla_xdp + NLA_HDRLEN, &flags, sizeof(flags)); - nla->nla_len += nla_xdp->nla_len; + ret = nlattr_add(&req.nh, sizeof(req), IFLA_XDP_FLAGS, &flags, sizeof(flags)); + if (ret < 0) + return ret; } if (flags & XDP_FLAGS_REPLACE) { - nla_xdp = (struct nlattr *)((char *)nla + nla->nla_len); - nla_xdp->nla_type = IFLA_XDP_EXPECTED_FD; - nla_xdp->nla_len = NLA_HDRLEN + sizeof(old_fd); - memcpy((char *)nla_xdp + NLA_HDRLEN, &old_fd, sizeof(old_fd)); - nla->nla_len += nla_xdp->nla_len; + ret = nlattr_add(&req.nh, sizeof(req), IFLA_XDP_EXPECTED_FD, &flags, sizeof(flags)); + if (ret < 0) + return ret; } - req.nh.nlmsg_len += NLA_ALIGN(nla->nla_len); + nlattr_end_nested(&req.nh, nla); - if (send(sock, &req, req.nh.nlmsg_len, 0) < 0) { - ret = -errno; - goto cleanup; - } - ret = bpf_netlink_recv(sock, nl_pid, seq, NULL, NULL, NULL); - -cleanup: - close(sock); - return ret; + return libbpf_nl_send_recv(&req.nh, NULL, NULL, NULL); } int bpf_set_link_xdp_fd_opts(int ifindex, int fd, __u32 flags, @@ -282,16 +263,22 @@ static int get_xdp_info(void *cookie, void *msg, struct nlattr **tb) return 0; } -static int libbpf_nl_get_link(int sock, unsigned int nl_pid, - libbpf_dump_nlmsg_t dump_link_nlmsg, void *cookie); int bpf_get_link_xdp_info(int ifindex, struct xdp_link_info *info, size_t info_size, __u32 flags) { struct xdp_id_md xdp_id = {}; - int sock, ret; - __u32 nl_pid = 0; __u32 mask; + int ret; + struct { + struct nlmsghdr nlh; + struct ifinfomsg ifm; + } req = { + .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)), + .nlh.nlmsg_type = RTM_GETLINK, + .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST, + .ifm.ifi_family = AF_PACKET, + }; if (flags & ~XDP_FLAGS_MASK || !info_size) return -EINVAL; @@ -302,14 +289,10 @@ int bpf_get_link_xdp_info(int ifindex, struct xdp_link_info *info, if (flags && flags & mask) return -EINVAL; - sock = libbpf_netlink_open(&nl_pid); - if (sock < 0) - return sock; - xdp_id.ifindex = ifindex; xdp_id.flags = flags; - ret = libbpf_nl_get_link(sock, nl_pid, get_xdp_info, &xdp_id); + ret = libbpf_nl_send_recv(&req.nlh, __dump_link_nlmsg, get_xdp_info, &xdp_id); if (!ret) { size_t sz = min(info_size, sizeof(xdp_id.info)); @@ -317,7 +300,6 @@ int bpf_get_link_xdp_info(int ifindex, struct xdp_link_info *info, memset((void *) info + sz, 0, info_size - sz); } - close(sock); return ret; } @@ -349,24 +331,29 @@ int bpf_get_link_xdp_id(int ifindex, __u32 *prog_id, __u32 flags) return ret; } -int libbpf_nl_get_link(int sock, unsigned int nl_pid, - libbpf_dump_nlmsg_t dump_link_nlmsg, void *cookie) +static int libbpf_nl_send_recv(struct nlmsghdr *nh, __dump_nlmsg_t fn, + libbpf_dump_nlmsg_t _fn, void *cookie) { - struct { - struct nlmsghdr nlh; - struct ifinfomsg ifm; - } req = { - .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)), - .nlh.nlmsg_type = RTM_GETLINK, - .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST, - .ifm.ifi_family = AF_PACKET, - }; - int seq = time(NULL); + __u32 nl_pid = 0; + int sock, ret; - req.nlh.nlmsg_seq = seq; - if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0) - return -errno; + if (!nh) + return -EINVAL; + + sock = libbpf_netlink_open(&nl_pid); + if (sock < 0) + return sock; - return bpf_netlink_recv(sock, nl_pid, seq, __dump_link_nlmsg, - dump_link_nlmsg, cookie); + nh->nlmsg_pid = 0; + nh->nlmsg_seq = time(NULL); + if (send(sock, nh, nh->nlmsg_len, 0) < 0) { + ret = -errno; + goto end; + } + + ret = bpf_netlink_recv(sock, nl_pid, nh->nlmsg_seq, fn, _fn, cookie); + +end: + close(sock); + return ret; } diff --git a/tools/lib/bpf/nlattr.h b/tools/lib/bpf/nlattr.h index 6cc3ac91690f..1c94cdb6e89d 100644 --- a/tools/lib/bpf/nlattr.h +++ b/tools/lib/bpf/nlattr.h @@ -10,7 +10,10 @@ #define __LIBBPF_NLATTR_H #include +#include +#include #include + /* avoid multiple definition of netlink features */ #define __LINUX_NETLINK_H @@ -103,4 +106,49 @@ int libbpf_nla_parse_nested(struct nlattr *tb[], int maxtype, int libbpf_nla_dump_errormsg(struct nlmsghdr *nlh); +static inline struct nlattr *nla_data(struct nlattr *nla) +{ + return (struct nlattr *)((char *)nla + NLA_HDRLEN); +} + +static inline struct nlattr *nh_tail(struct nlmsghdr *nh) +{ + return (struct nlattr *)((char *)nh + NLMSG_ALIGN(nh->nlmsg_len)); +} + +static inline int nlattr_add(struct nlmsghdr *nh, size_t maxsz, int type, + const void *data, int len) +{ + struct nlattr *nla; + + if (NLMSG_ALIGN(nh->nlmsg_len) + NLA_ALIGN(NLA_HDRLEN + len) > maxsz) + return -EMSGSIZE; + if ((!data && len) || (data && !len)) + return -EINVAL; + + nla = nh_tail(nh); + nla->nla_type = type; + nla->nla_len = NLA_HDRLEN + len; + if (data) + memcpy(nla_data(nla), data, len); + nh->nlmsg_len = NLMSG_ALIGN(nh->nlmsg_len) + NLA_ALIGN(nla->nla_len); + return 0; +} + +static inline struct nlattr *nlattr_begin_nested(struct nlmsghdr *nh, + size_t maxsz, int type) +{ + struct nlattr *tail; + + tail = nh_tail(nh); + if (nlattr_add(nh, maxsz, type | NLA_F_NESTED, NULL, 0)) + return NULL; + return tail; +} + +static inline void nlattr_end_nested(struct nlmsghdr *nh, struct nlattr *tail) +{ + tail->nla_len = (char *)nh_tail(nh) - (char *)tail; +} + #endif /* __LIBBPF_NLATTR_H */ From patchwork Wed Apr 28 16:25:53 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Kumar Kartikeya Dwivedi X-Patchwork-Id: 429131 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.7 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 71C9DC433B4 for ; Wed, 28 Apr 2021 16:26:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 334BA613EF for ; Wed, 28 Apr 2021 16:26:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240872AbhD1Q1D (ORCPT ); Wed, 28 Apr 2021 12:27:03 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60042 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S240811AbhD1Q04 (ORCPT ); Wed, 28 Apr 2021 12:26:56 -0400 Received: from mail-pl1-x641.google.com (mail-pl1-x641.google.com [IPv6:2607:f8b0:4864:20::641]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 51CDAC061573; Wed, 28 Apr 2021 09:26:10 -0700 (PDT) Received: by mail-pl1-x641.google.com with SMTP id p17so7234898plf.12; Wed, 28 Apr 2021 09:26:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=jGBOmJj4JIBaLUD9Oaj2UB4kWD0yjcksRfAhWdzA1t8=; b=rC3ugNo3rdDVNG2qCBT44LX93vameBWS36ItWpdWSMLKmS1AhpIa1QJtag51Jrsbe8 mstO0PBbzknmB9zQzw9sZC4PX0wPPSjq7fRmu2Mt7RanzugajGKGBdbnrVCbvtZYtvjT JMvAVIiPYw9/axrfwVYuBCwcuDFsP2Ho67olRulz6WNF3T4dp7KkkuIl/WTgh/w9h4fv X5SZiQ8ZLy3VK+xFO18Zkt2vfUXcw9hkteMwdEeryhooA7+15eNBcmVeGz+FHF/8Zl/p NDDWYKFIPhQVhvD4JQxUzqXNcLS2mRmKc3AqR1KSpYodXrvN55ZbQtkQDwIc7EJkxlgc yGEg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=jGBOmJj4JIBaLUD9Oaj2UB4kWD0yjcksRfAhWdzA1t8=; b=KXyEE/fCzcRAeLPb1UpxUCx5la53PI96WFzCgA1NBVNcESSeqzAEav4FVc4Jr5bUfN D40CqhkxYUsW8yO+1/nGInuv6sDCySNQtUHixM4DRkWmwwlFxodm3RE3nrmker2K64y7 NdyXw1wzX8VQAqNk6jxnv4LNvw5ungT2TYGSanGrIkGYBmw6ZbD7Os74EtyHu5MUcTm+ SdYZneixav8VCaCOyoKmRgn11hXO4SyDf7lIeFQ0FLXxwxuGhXjpcNB/RQnZZp7iDhcn ZTG7kdbVjn2GfovKxv5IYQtXBgO7PTo2gsLmLxIYyh4o6M5lBZ8DZ+LIqxIZk3i375sc khsQ== X-Gm-Message-State: AOAM530cSpU7mYfjFHjzI4j6Y1WvnlUpzPIrSOPCAEIU5n77Y3NbPiq2 BUyIs51BcLKB4hzer62EuEIFt/lYxFuaFQ== X-Google-Smtp-Source: ABdhPJz7pBl3glrXbfwwbxNL9LKj23gqjkB7dkeIW35oPWaKGiHQH3OtCK1IfipAx38FuX2/t3WEZQ== X-Received: by 2002:a17:902:8b81:b029:eb:5a4:9cae with SMTP id ay1-20020a1709028b81b02900eb05a49caemr31382137plb.13.1619627169484; Wed, 28 Apr 2021 09:26:09 -0700 (PDT) Received: from localhost ([112.79.247.72]) by smtp.gmail.com with ESMTPSA id lk6sm5616546pjb.36.2021.04.28.09.26.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 28 Apr 2021 09:26:09 -0700 (PDT) From: Kumar Kartikeya Dwivedi To: bpf@vger.kernel.org Cc: Kumar Kartikeya Dwivedi , =?utf-8?q?Toke_H=C3=B8ilan?= =?utf-8?q?d-J=C3=B8rgensen?= , Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Martin KaFai Lau , Song Liu , Yonghong Song , John Fastabend , KP Singh , "David S. Miller" , Jakub Kicinski , Jesper Dangaard Brouer , Shaun Crampton , netdev@vger.kernel.org Subject: [PATCH bpf-next v5 3/3] libbpf: add selftests for TC-BPF API Date: Wed, 28 Apr 2021 21:55:53 +0530 Message-Id: <20210428162553.719588-4-memxor@gmail.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20210428162553.719588-1-memxor@gmail.com> References: <20210428162553.719588-1-memxor@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org This adds some basic tests for the low level bpf_tc_* API. Reviewed-by: Toke Høiland-Jørgensen Signed-off-by: Kumar Kartikeya Dwivedi --- .../testing/selftests/bpf/prog_tests/tc_bpf.c | 467 ++++++++++++++++++ .../testing/selftests/bpf/progs/test_tc_bpf.c | 12 + 2 files changed, 479 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/tc_bpf.c create mode 100644 tools/testing/selftests/bpf/progs/test_tc_bpf.c diff --git a/tools/testing/selftests/bpf/prog_tests/tc_bpf.c b/tools/testing/selftests/bpf/prog_tests/tc_bpf.c new file mode 100644 index 000000000000..40441f4e23e2 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/tc_bpf.c @@ -0,0 +1,467 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include + +#include "test_tc_bpf.skel.h" + +#define LO_IFINDEX 1 + +static int test_tc_internal(const struct bpf_tc_hook *hook, int fd) +{ + DECLARE_LIBBPF_OPTS(bpf_tc_opts, opts, .handle = 1, .priority = 1, + .prog_fd = fd); + struct bpf_prog_info info = {}; + int ret; + + ret = bpf_obj_get_info_by_fd(fd, &info, &(__u32){sizeof(info)}); + if (!ASSERT_OK(ret, "bpf_obj_get_info_by_fd")) + return ret; + + ret = bpf_tc_attach(hook, &opts, 0); + if (!ASSERT_OK(ret, "bpf_tc_attach")) + return ret; + + if (!ASSERT_EQ(opts.handle, 1, "handle set") || + !ASSERT_EQ(opts.priority, 1, "priority set") || + !ASSERT_EQ(opts.prog_id, info.id, "prog_id set")) + goto end; + + DECLARE_LIBBPF_OPTS(bpf_tc_opts, info_opts, .prog_fd = fd); + ret = bpf_tc_query(hook, &info_opts); + if (!ASSERT_OK(ret, "bpf_tc_query")) + goto end; + + DECLARE_LIBBPF_OPTS(bpf_tc_opts, info_opts2, .prog_id = info.id); + ret = bpf_tc_query(hook, &info_opts2); + if (!ASSERT_OK(ret, "bpf_tc_query")) + goto end; + + if (!ASSERT_EQ(opts.handle, 1, "handle set") || + !ASSERT_EQ(opts.priority, 1, "priority set") || + !ASSERT_EQ(opts.prog_id, info.id, "prog_id set")) + goto end; + + opts.prog_id = 0; + ret = bpf_tc_attach(hook, &opts, BPF_TC_F_REPLACE); + if (!ASSERT_OK(ret, "bpf_tc_attach replace mode")) + return ret; + +end: + opts.prog_fd = opts.prog_id = 0; + ret = bpf_tc_detach(hook, &opts); + ASSERT_OK(ret, "bpf_tc_detach"); + return ret; +} + +static int test_tc_bpf_api(struct bpf_tc_hook *hook, int fd) +{ + DECLARE_LIBBPF_OPTS(bpf_tc_opts, opts, .handle = 1, .priority = 1); + DECLARE_LIBBPF_OPTS(bpf_tc_opts, attach_opts, .handle = 1, .priority = 1, + .prog_fd = fd); + DECLARE_LIBBPF_OPTS(bpf_tc_hook, inv_hook, .attach_point = BPF_TC_INGRESS); + int ret; + + ret = bpf_tc_hook_create(NULL, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_hook_create invalid hook = NULL")) + return -EINVAL; + + ret = bpf_tc_hook_create(hook, 42); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_hook_create invalid flags")) + return -EINVAL; + ret = bpf_tc_hook_destroy(NULL); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_hook_destroy invalid hook = NULL")) + return -EINVAL; + + /* hook ifindex = 0 */ + ret = bpf_tc_hook_create(&inv_hook, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_hook_create invalid hook ifindex == 0")) + return -EINVAL; + ret = bpf_tc_hook_destroy(&inv_hook); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_hook_destroy invalid hook ifindex == 0")) + return -EINVAL; + ret = bpf_tc_attach(&inv_hook, &attach_opts, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_attach invalid hook ifindex == 0")) + return -EINVAL; + ret = bpf_tc_detach(&inv_hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid hook ifindex == 0")) + return -EINVAL; + ret = bpf_tc_query(&inv_hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_query invalid hook ifindex == 0")) + return -EINVAL; + + /* hook ifindex < 0 */ + inv_hook.ifindex = -1; + ret = bpf_tc_hook_create(&inv_hook, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_hook_create invalid hook ifindex < 0")) + return -EINVAL; + ret = bpf_tc_hook_destroy(&inv_hook); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_hook_destroy invalid hook ifindex < 0")) + return -EINVAL; + ret = bpf_tc_attach(&inv_hook, &attach_opts, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_attach invalid hook ifindex < 0")) + return -EINVAL; + ret = bpf_tc_detach(&inv_hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid hook ifindex < 0")) + return -EINVAL; + ret = bpf_tc_query(&inv_hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_query invalid hook ifindex < 0")) + return -EINVAL; + inv_hook.ifindex = LO_IFINDEX; + + /* hook.attach_point invalid */ + inv_hook.attach_point = 0xabcd; + ret = bpf_tc_hook_create(&inv_hook, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_hook_create invalid hook.attach_point")) + return -EINVAL; + ret = bpf_tc_hook_destroy(&inv_hook); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_hook_destroy invalid hook.attach_point")) + return -EINVAL; + ret = bpf_tc_attach(&inv_hook, &attach_opts, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_attach invalid hook.attach_point")) + return -EINVAL; + ret = bpf_tc_detach(&inv_hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid hook.attach_point")) + return -EINVAL; + ret = bpf_tc_query(&inv_hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_query invalid hook.attach_point")) + return -EINVAL; + inv_hook.attach_point = BPF_TC_INGRESS; + + /* hook.attach_point valid, but parent invalid */ + inv_hook.parent = TC_H_MAKE(1UL << 16, 10); + ret = bpf_tc_hook_create(&inv_hook, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_hook_create invalid hook parent")) + return -EINVAL; + ret = bpf_tc_hook_destroy(&inv_hook); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_hook_destroy invalid hook parent")) + return -EINVAL; + ret = bpf_tc_attach(&inv_hook, &attach_opts, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_attach invalid hook parent")) + return -EINVAL; + ret = bpf_tc_detach(&inv_hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid hook parent")) + return -EINVAL; + ret = bpf_tc_query(&inv_hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_query invalid hook parent")) + return -EINVAL; + + inv_hook.attach_point = BPF_TC_CUSTOM; + inv_hook.parent = 0; + /* These return EOPNOTSUPP instead of EINVAL as parent is checked after + * attach_point of the hook. + */ + ret = bpf_tc_hook_create(&inv_hook, 0); + if (!ASSERT_EQ(ret, -EOPNOTSUPP, "bpf_tc_hook_create invalid hook parent")) + return -EINVAL; + ret = bpf_tc_hook_destroy(&inv_hook); + if (!ASSERT_EQ(ret, -EOPNOTSUPP, "bpf_tc_hook_destroy invalid hook parent")) + return -EINVAL; + ret = bpf_tc_attach(&inv_hook, &attach_opts, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_attach invalid hook parent")) + return -EINVAL; + ret = bpf_tc_detach(&inv_hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid hook parent")) + return -EINVAL; + ret = bpf_tc_query(&inv_hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_query invalid hook parent")) + return -EINVAL; + inv_hook.attach_point = BPF_TC_INGRESS; + + /* detach */ + ret = bpf_tc_detach(NULL, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid hook = NULL")) + return -EINVAL; + opts.prog_fd = 42; + ret = bpf_tc_detach(hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid prog_fd set")) + return -EINVAL; + opts.prog_fd = 0; + opts.prog_id = 42; + ret = bpf_tc_detach(hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid prog_id set")) + return -EINVAL; + opts.prog_id = 0; + opts.handle = 0; + ret = bpf_tc_detach(hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid handle unset")) + return -EINVAL; + opts.handle = 1; + opts.priority = 0; + ret = bpf_tc_detach(hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid priority unset")) + return -EINVAL; + opts.priority = UINT16_MAX + 1; + ret = bpf_tc_detach(hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid priority > UINT16_MAX")) + return -EINVAL; + opts.priority = 1; + ret = bpf_tc_detach(hook, NULL); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_detach invalid opts = NULL")) + return -EINVAL; + + /* query */ + ret = bpf_tc_query(NULL, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_query invalid hook = NULL")) + return -EINVAL; + opts.prog_fd = fd; + ret = bpf_tc_query(hook, &opts); + if (!ASSERT_EQ(ret, -ENOENT, "bpf_tc_query valid only prog_fd set")) + return -EINVAL; + opts.prog_fd = 0; + opts.prog_id = 42; + ret = bpf_tc_query(hook, &opts); + if (!ASSERT_EQ(ret, -ENOENT, "bpf_tc_query valid only prog_id set")) + return -EINVAL; + opts.prog_fd = opts.prog_id = 42; + ret = bpf_tc_query(hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_query invalid both prog_fd and prog_id set")) + return -EINVAL; + opts.prog_fd = opts.prog_id = 0; + opts.handle = 0; + ret = bpf_tc_query(hook, &opts); + if (!ASSERT_EQ(ret, -ENOENT, "bpf_tc_query valid handle unset")) + return -EINVAL; + opts.handle = 1; + opts.priority = 0; + ret = bpf_tc_query(hook, &opts); + if (!ASSERT_EQ(ret, -ENOENT, "bpf_tc_query valid priority unset")) + return -EINVAL; + opts.priority = UINT16_MAX + 1; + ret = bpf_tc_query(hook, &opts); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_query invalid priority > UINT16_MAX")) + return -EINVAL; + opts.priority = 1; + ret = bpf_tc_query(hook, NULL); + if (!ASSERT_EQ(ret, -ENOENT, "bpf_tc_query valid opts = NULL")) + return -EINVAL; + + /* attach */ + ret = bpf_tc_attach(NULL, &attach_opts, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_attach invalid hook = NULL")) + return -EINVAL; + ret = bpf_tc_attach(hook, &attach_opts, 42); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_attach invalid flags")) + return -EINVAL; + attach_opts.prog_fd = 0; + ret = bpf_tc_attach(hook, &attach_opts, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_attach invalid prog_fd unset")) + return -EINVAL; + attach_opts.prog_fd = fd; + attach_opts.prog_id = 42; + ret = bpf_tc_attach(hook, &attach_opts, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_attach invalid prog_id set")) + return -EINVAL; + attach_opts.prog_id = 0; + attach_opts.handle = 0; + ret = bpf_tc_attach(hook, &attach_opts, 0); + if (!ASSERT_OK(ret, "bpf_tc_attach valid handle unset")) + return -EINVAL; + attach_opts.prog_fd = attach_opts.prog_id = 0; + ASSERT_OK(bpf_tc_detach(hook, &attach_opts), "bpf_tc_detach"); + attach_opts.prog_fd = fd; + attach_opts.handle = 1; + attach_opts.priority = 0; + ret = bpf_tc_attach(hook, &attach_opts, 0); + if (!ASSERT_OK(ret, "bpf_tc_attach valid priority unset")) + return -EINVAL; + attach_opts.prog_fd = attach_opts.prog_id = 0; + ASSERT_OK(bpf_tc_detach(hook, &attach_opts), "bpf_tc_detach"); + attach_opts.prog_fd = fd; + attach_opts.priority = UINT16_MAX + 1; + ret = bpf_tc_attach(hook, &attach_opts, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_attach invalid priority > UINT16_MAX")) + return -EINVAL; + attach_opts.priority = 0; + attach_opts.handle = attach_opts.priority = 0; + ret = bpf_tc_attach(hook, &attach_opts, 0); + if (!ASSERT_OK(ret, "bpf_tc_attach valid both handle and priority unset")) + return -EINVAL; + attach_opts.prog_fd = attach_opts.prog_id = 0; + ASSERT_OK(bpf_tc_detach(hook, &attach_opts), "bpf_tc_detach"); + ret = bpf_tc_attach(hook, NULL, 0); + if (!ASSERT_EQ(ret, -EINVAL, "bpf_tc_attach invalid opts = NULL")) + return -EINVAL; + + return 0; +} + +static int test_tc_query(const struct bpf_tc_hook *hook, int fd) +{ + struct test_tc_bpf *skel = NULL; + int new_fd, ret, i = 0; + + skel = test_tc_bpf__open_and_load(); + if (!ASSERT_OK_PTR(skel, "test_tc_bpf__open_and_load")) + return -EINVAL; + + new_fd = bpf_program__fd(skel->progs.cls); + + /* make sure no other filters are attached */ + ret = bpf_tc_query(hook, NULL); + if (!ASSERT_EQ(ret, -ENOENT, "bpf_tc_query == -ENOENT")) + goto end_destroy; + + for (i = 0; i < 5; i++) { + DECLARE_LIBBPF_OPTS(bpf_tc_opts, opts, .prog_fd = fd); + ret = bpf_tc_attach(hook, &opts, 0); + if (!ASSERT_OK(ret, "bpf_tc_attach")) + goto end; + } + DECLARE_LIBBPF_OPTS(bpf_tc_opts, opts, .handle = 1, .priority = 1, + .prog_fd = new_fd); + ret = bpf_tc_attach(hook, &opts, 0); + if (!ASSERT_OK(ret, "bpf_tc_attach")) + goto end; + i++; + + ASSERT_EQ(opts.handle, 1, "handle match"); + ASSERT_EQ(opts.priority, 1, "priority match"); + ASSERT_NEQ(opts.prog_id, 0, "prog_id set"); + + opts.prog_fd = 0; + /* search with handle, priority, prog_id */ + ret = bpf_tc_query(hook, &opts); + if (!ASSERT_OK(ret, "bpf_tc_query")) + goto end; + + ASSERT_EQ(opts.handle, 1, "handle match"); + ASSERT_EQ(opts.priority, 1, "priority match"); + ASSERT_NEQ(opts.prog_id, 0, "prog_id set"); + + opts.priority = opts.prog_fd = 0; + /* search with handle, prog_id */ + ret = bpf_tc_query(hook, &opts); + if (!ASSERT_OK(ret, "bpf_tc_query")) + goto end; + + ASSERT_EQ(opts.handle, 1, "handle match"); + ASSERT_EQ(opts.priority, 1, "priority match"); + ASSERT_NEQ(opts.prog_id, 0, "prog_id set"); + + opts.handle = opts.prog_fd = 0; + /* search with priority, prog_id */ + ret = bpf_tc_query(hook, &opts); + if (!ASSERT_OK(ret, "bpf_tc_query")) + goto end; + + ASSERT_EQ(opts.handle, 1, "handle match"); + ASSERT_EQ(opts.priority, 1, "priority match"); + ASSERT_NEQ(opts.prog_id, 0, "prog_id set"); + + opts.handle = opts.priority = opts.prog_fd = 0; + /* search with prog_id */ + ret = bpf_tc_query(hook, &opts); + if (!ASSERT_OK(ret, "bpf_tc_query")) + goto end; + + ASSERT_EQ(opts.handle, 1, "handle match"); + ASSERT_EQ(opts.priority, 1, "priority match"); + ASSERT_NEQ(opts.prog_id, 0, "prog_id set"); + + while (i != 1) { + DECLARE_LIBBPF_OPTS(bpf_tc_opts, del_opts, .prog_fd = fd); + ret = bpf_tc_query(hook, &del_opts); + if (!ASSERT_OK(ret, "bpf_tc_query")) + goto end; + ASSERT_NEQ(del_opts.prog_id, opts.prog_id, "prog_id should not be same"); + ASSERT_NEQ(del_opts.priority, 1, "priority should not be 1"); + del_opts.prog_fd = del_opts.prog_id = 0; + ret = bpf_tc_detach(hook, &del_opts); + if (!ASSERT_OK(ret, "bpf_tc_detach")) + goto end; + i--; + } + + opts.handle = opts.priority = opts.prog_id = 0; + opts.prog_fd = fd; + ret = bpf_tc_query(hook, &opts); + ASSERT_EQ(ret, -ENOENT, "bpf_tc_query == -ENOENT"); + +end: + while (i--) { + DECLARE_LIBBPF_OPTS(bpf_tc_opts, del_opts, 0); + ret = bpf_tc_query(hook, &del_opts); + if (!ASSERT_OK(ret, "bpf_tc_query")) + break; + del_opts.prog_id = 0; + ret = bpf_tc_detach(hook, &del_opts); + if (!ASSERT_OK(ret, "bpf_tc_detach")) + break; + } + ASSERT_EQ(bpf_tc_query(hook, NULL), -ENOENT, "bpf_tc_query == -ENOENT"); +end_destroy: + test_tc_bpf__destroy(skel); + return ret; +} + +void test_tc_bpf(void) +{ + struct test_tc_bpf *skel = NULL; + bool hook_created = true; + int cls_fd, ret; + + skel = test_tc_bpf__open_and_load(); + if (!ASSERT_OK_PTR(skel, "test_tc_bpf__open_and_load")) + return; + + cls_fd = bpf_program__fd(skel->progs.cls); + + DECLARE_LIBBPF_OPTS(bpf_tc_hook, hook, .ifindex = LO_IFINDEX, + .attach_point = BPF_TC_INGRESS); + ret = bpf_tc_hook_create(&hook, 0); + if (ret < 0 && ret == -EEXIST) { + hook_created = false; + ret = 0; + } + if (!ASSERT_OK(ret, "bpf_tc_hook_create(BPF_TC_INGRESS)")) + goto end; + + hook.attach_point = BPF_TC_CUSTOM; + hook.parent = TC_H_MAKE(TC_H_CLSACT, TC_H_MIN_INGRESS); + ret = bpf_tc_hook_create(&hook, 0); + if (!ASSERT_EQ(ret, -EOPNOTSUPP, "bpf_tc_hook_create invalid hook.attach_point")) + goto end; + + ret = test_tc_internal(&hook, cls_fd); + if (!ASSERT_OK(ret, "test_tc_internal ingress")) + goto end; + + ret = bpf_tc_hook_destroy(&hook); + if (!ASSERT_EQ(ret, -EOPNOTSUPP, "bpf_tc_hook_destroy invalid hook.attach_point")) + goto end; + + hook.attach_point = BPF_TC_INGRESS; + hook.parent = 0; + bpf_tc_hook_destroy(&hook); + + ret = test_tc_internal(&hook, cls_fd); + if (!ASSERT_OK(ret, "test_tc_internal ingress")) + goto end; + + bpf_tc_hook_destroy(&hook); + + hook.attach_point = BPF_TC_EGRESS; + ret = test_tc_internal(&hook, cls_fd); + if (!ASSERT_OK(ret, "test_tc_internal egress")) + goto end; + + bpf_tc_hook_destroy(&hook); + + ret = test_tc_bpf_api(&hook, cls_fd); + if (!ASSERT_OK(ret, "test_tc_bpf_api")) + goto end; + + bpf_tc_hook_destroy(&hook); + + ret = test_tc_query(&hook, cls_fd); + if (!ASSERT_OK(ret, "test_tc_query")) + goto end; + +end: + if (hook_created) { + hook.attach_point = BPF_TC_INGRESS|BPF_TC_EGRESS; + bpf_tc_hook_destroy(&hook); + } + test_tc_bpf__destroy(skel); +} diff --git a/tools/testing/selftests/bpf/progs/test_tc_bpf.c b/tools/testing/selftests/bpf/progs/test_tc_bpf.c new file mode 100644 index 000000000000..18a3a7ed924a --- /dev/null +++ b/tools/testing/selftests/bpf/progs/test_tc_bpf.c @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include + +/* Dummy prog to test TC-BPF API */ + +SEC("classifier") +int cls(struct __sk_buff *skb) +{ + return 0; +}