Merge git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next

Daniel Borkmann says:

====================
pull-request: bpf-next 2018-09-25

The following pull-request contains BPF updates for your *net-next* tree.

The main changes are:

1) Allow for RX stack hardening by implementing the kernel's flow
   dissector in BPF. Idea was originally presented at netconf 2017 [0].
   Quote from merge commit:

     [...] Because of the rigorous checks of the BPF verifier, this
     provides significant security guarantees. In particular, the BPF
     flow dissector cannot get inside of an infinite loop, as with
     CVE-2013-4348, because BPF programs are guaranteed to terminate.
     It cannot read outside of packet bounds, because all memory accesses
     are checked. Also, with BPF the administrator can decide which
     protocols to support, reducing potential attack surface. Rarely
     encountered protocols can be excluded from dissection and the
     program can be updated without kernel recompile or reboot if a
     bug is discovered. [...]

   Also, a sample flow dissector has been implemented in BPF as part
   of this work, from Petar and Willem.

   [0] http://vger.kernel.org/netconf2017_files/rx_hardening_and_udp_gso.pdf

2) Add support for bpftool to list currently active attachment
   points of BPF networking programs providing a quick overview
   similar to bpftool's perf subcommand, from Yonghong.

3) Fix a verifier pruning instability bug where a union member
   from the register state was not cleared properly leading to
   branches not being pruned despite them being valid candidates,
   from Alexei.

4) Various smaller fast-path optimizations in XDP's map redirect
   code, from Jesper.

5) Enable to recognize BPF_MAP_TYPE_REUSEPORT_SOCKARRAY maps
   in bpftool, from Roman.

6) Remove a duplicate check in libbpf that probes for function
   storage, from Taeung.

7) Fix an issue in test_progs by avoid checking for errno since
   on success its value should not be checked, from Mauricio.

8) Fix unused variable warning in bpf_getsockopt() helper when
   CONFIG_INET is not configured, from Anders.

9) Fix a compilation failure in the BPF sample code's use of
   bpf_flow_keys, from Prashant.

10) Minor cleanups in BPF code, from Yue and Zhong.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

8 files changed, 411 insertions, 143 deletions

diff --git a/tools/lib/bpf/Build b/tools/lib/bpf/Build
index 6eb9bacd1948..7bc31c905018 100644
--- a/tools/lib/bpf/Build
+++ b/tools/lib/bpf/Build
@@ -1 +1 @@
-libbpf-y := libbpf.o bpf.o nlattr.o btf.o libbpf_errno.o str_error.o
+libbpf-y := libbpf.o bpf.o nlattr.o btf.o libbpf_errno.o str_error.o netlink.o
diff --git a/tools/lib/bpf/bpf.c b/tools/lib/bpf/bpf.c
index 60aa4ca8b2c5..3878a26a2071 100644
--- a/tools/lib/bpf/bpf.c
+++ b/tools/lib/bpf/bpf.c
@@ -28,16 +28,8 @@
 #include <linux/bpf.h>
 #include "bpf.h"
 #include "libbpf.h"
-#include "nlattr.h"
-#include <linux/rtnetlink.h>
-#include <linux/if_link.h>
-#include <sys/socket.h>
 #include <errno.h>
 
-#ifndef SOL_NETLINK
-#define SOL_NETLINK 270
-#endif
-
 /*
  * When building perf, unistd.h is overridden. __NR_bpf is
  * required to be defined explicitly.
@@ -499,127 +491,6 @@ int bpf_raw_tracepoint_open(const char *name, int prog_fd)
         return sys_bpf(BPF_RAW_TRACEPOINT_OPEN, &attr, sizeof(attr));
 }
 
-int bpf_set_link_xdp_fd(int ifindex, int fd, __u32 flags)
-{
-        struct sockaddr_nl sa;
-        int sock, seq = 0, len, ret = -1;
-        char buf[4096];
-        struct nlattr *nla, *nla_xdp;
-        struct {
-                struct nlmsghdr  nh;
-                struct ifinfomsg ifinfo;
-                char             attrbuf[64];
-        } req;
-        struct nlmsghdr *nh;
-        struct nlmsgerr *err;
-        socklen_t addrlen;
-        int one = 1;
-
-        memset(&sa, 0, sizeof(sa));
-        sa.nl_family = AF_NETLINK;
-
-        sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
-        if (sock < 0) {
-                return -errno;
-        }
-
-        if (setsockopt(sock, SOL_NETLINK, NETLINK_EXT_ACK,
-                       &one, sizeof(one)) < 0) {
-                fprintf(stderr, "Netlink error reporting not supported\n");
-        }
-
-        if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
-                ret = -errno;
-                goto cleanup;
-        }
-
-        addrlen = sizeof(sa);
-        if (getsockname(sock, (struct sockaddr *)&sa, &addrlen) < 0) {
-                ret = -errno;
-                goto cleanup;
-        }
-
-        if (addrlen != sizeof(sa)) {
-                ret = -LIBBPF_ERRNO__INTERNAL;
-                goto cleanup;
-        }
-
-        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;
-
-        /* 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;
-
-        /* 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;
-        }
-
-        req.nh.nlmsg_len += NLA_ALIGN(nla->nla_len);
-
-        if (send(sock, &req, req.nh.nlmsg_len, 0) < 0) {
-                ret = -errno;
-                goto cleanup;
-        }
-
-        len = recv(sock, buf, sizeof(buf), 0);
-        if (len < 0) {
-                ret = -errno;
-                goto cleanup;
-        }
-
-        for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, len);
-             nh = NLMSG_NEXT(nh, len)) {
-                if (nh->nlmsg_pid != sa.nl_pid) {
-                        ret = -LIBBPF_ERRNO__WRNGPID;
-                        goto cleanup;
-                }
-                if (nh->nlmsg_seq != seq) {
-                        ret = -LIBBPF_ERRNO__INVSEQ;
-                        goto cleanup;
-                }
-                switch (nh->nlmsg_type) {
-                case NLMSG_ERROR:
-                        err = (struct nlmsgerr *)NLMSG_DATA(nh);
-                        if (!err->error)
-                                continue;
-                        ret = err->error;
-                        nla_dump_errormsg(nh);
-                        goto cleanup;
-                case NLMSG_DONE:
-                        break;
-                default:
-                        break;
-                }
-        }
-
-        ret = 0;
-
-cleanup:
-        close(sock);
-        return ret;
-}
-
 int bpf_load_btf(void *btf, __u32 btf_size, char *log_buf, __u32 log_buf_size,
                  bool do_log)
 {
diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index bdb94939fd60..4f8d43ae20d2 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -1502,6 +1502,7 @@ static bool bpf_prog_type__needs_kver(enum bpf_prog_type type)
         case BPF_PROG_TYPE_CGROUP_SOCK_ADDR:
         case BPF_PROG_TYPE_LIRC_MODE2:
         case BPF_PROG_TYPE_SK_REUSEPORT:
+        case BPF_PROG_TYPE_FLOW_DISSECTOR:
                 return false;
         case BPF_PROG_TYPE_UNSPEC:
         case BPF_PROG_TYPE_KPROBE:
@@ -2121,6 +2122,7 @@ static const struct {
         BPF_PROG_SEC("sk_skb",          BPF_PROG_TYPE_SK_SKB),
         BPF_PROG_SEC("sk_msg",          BPF_PROG_TYPE_SK_MSG),
         BPF_PROG_SEC("lirc_mode2",      BPF_PROG_TYPE_LIRC_MODE2),
+        BPF_PROG_SEC("flow_dissector",  BPF_PROG_TYPE_FLOW_DISSECTOR),
         BPF_SA_PROG_SEC("cgroup/bind4", BPF_CGROUP_INET4_BIND),
         BPF_SA_PROG_SEC("cgroup/bind6", BPF_CGROUP_INET6_BIND),
         BPF_SA_PROG_SEC("cgroup/connect4", BPF_CGROUP_INET4_CONNECT),
@@ -2336,7 +2338,7 @@ int bpf_prog_load_xattr(const struct bpf_prog_load_attr *attr,
                 bpf_program__set_expected_attach_type(prog,
                                                       expected_attach_type);
 
-                if (!bpf_program__is_function_storage(prog, obj) && !first_prog)
+                if (!first_prog)
                         first_prog = prog;
         }
 
diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h
index 96c55fac54c3..e3b00e23e181 100644
--- a/tools/lib/bpf/libbpf.h
+++ b/tools/lib/bpf/libbpf.h
@@ -46,6 +46,7 @@ enum libbpf_errno {
         LIBBPF_ERRNO__PROGTYPE, /* Kernel doesn't support this program type */
         LIBBPF_ERRNO__WRNGPID,  /* Wrong pid in netlink message */
         LIBBPF_ERRNO__INVSEQ,   /* Invalid netlink sequence */
+        LIBBPF_ERRNO__NLPARSE,  /* netlink parsing error */
         __LIBBPF_ERRNO__END,
 };
 
@@ -297,4 +298,19 @@ int bpf_perf_event_read_simple(void *mem, unsigned long size,
                                unsigned long page_size,
                                void **buf, size_t *buf_len,
                                bpf_perf_event_print_t fn, void *priv);
+
+struct nlmsghdr;
+struct nlattr;
+typedef int (*dump_nlmsg_t)(void *cookie, void *msg, struct nlattr **tb);
+typedef int (*__dump_nlmsg_t)(struct nlmsghdr *nlmsg, dump_nlmsg_t,
+                              void *cookie);
+int bpf_netlink_open(unsigned int *nl_pid);
+int nl_get_link(int sock, unsigned int nl_pid, dump_nlmsg_t dump_link_nlmsg,
+                void *cookie);
+int nl_get_class(int sock, unsigned int nl_pid, int ifindex,
+                 dump_nlmsg_t dump_class_nlmsg, void *cookie);
+int nl_get_qdisc(int sock, unsigned int nl_pid, int ifindex,
+                 dump_nlmsg_t dump_qdisc_nlmsg, void *cookie);
+int nl_get_filter(int sock, unsigned int nl_pid, int ifindex, int handle,
+                  dump_nlmsg_t dump_filter_nlmsg, void *cookie);
 #endif
diff --git a/tools/lib/bpf/libbpf_errno.c b/tools/lib/bpf/libbpf_errno.c
index d9ba851bd7f9..2464ade3b326 100644
--- a/tools/lib/bpf/libbpf_errno.c
+++ b/tools/lib/bpf/libbpf_errno.c
@@ -42,6 +42,7 @@ static const char *libbpf_strerror_table[NR_ERRNO] = {
         [ERRCODE_OFFSET(PROGTYPE)]      = "Kernel doesn't support this program type",
         [ERRCODE_OFFSET(WRNGPID)]       = "Wrong pid in netlink message",
         [ERRCODE_OFFSET(INVSEQ)]        = "Invalid netlink sequence",
+        [ERRCODE_OFFSET(NLPARSE)]       = "Incorrect netlink message parsing",
 };
 
 int libbpf_strerror(int err, char *buf, size_t size)
diff --git a/tools/lib/bpf/netlink.c b/tools/lib/bpf/netlink.c
new file mode 100644
index 000000000000..fde1d7bf8199
--- /dev/null
+++ b/tools/lib/bpf/netlink.c
@@ -0,0 +1,331 @@
+// SPDX-License-Identifier: LGPL-2.1
+/* Copyright (c) 2018 Facebook */
+
+#include <stdlib.h>
+#include <memory.h>
+#include <unistd.h>
+#include <linux/bpf.h>
+#include <linux/rtnetlink.h>
+#include <sys/socket.h>
+#include <errno.h>
+#include <time.h>
+
+#include "bpf.h"
+#include "libbpf.h"
+#include "nlattr.h"
+
+#ifndef SOL_NETLINK
+#define SOL_NETLINK 270
+#endif
+
+int bpf_netlink_open(__u32 *nl_pid)
+{
+        struct sockaddr_nl sa;
+        socklen_t addrlen;
+        int one = 1, ret;
+        int sock;
+
+        memset(&sa, 0, sizeof(sa));
+        sa.nl_family = AF_NETLINK;
+
+        sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+        if (sock < 0)
+                return -errno;
+
+        if (setsockopt(sock, SOL_NETLINK, NETLINK_EXT_ACK,
+                       &one, sizeof(one)) < 0) {
+                fprintf(stderr, "Netlink error reporting not supported\n");
+        }
+
+        if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
+                ret = -errno;
+                goto cleanup;
+        }
+
+        addrlen = sizeof(sa);
+        if (getsockname(sock, (struct sockaddr *)&sa, &addrlen) < 0) {
+                ret = -errno;
+                goto cleanup;
+        }
+
+        if (addrlen != sizeof(sa)) {
+                ret = -LIBBPF_ERRNO__INTERNAL;
+                goto cleanup;
+        }
+
+        *nl_pid = sa.nl_pid;
+        return sock;
+
+cleanup:
+        close(sock);
+        return ret;
+}
+
+static int bpf_netlink_recv(int sock, __u32 nl_pid, int seq,
+                            __dump_nlmsg_t _fn, dump_nlmsg_t fn,
+                            void *cookie)
+{
+        bool multipart = true;
+        struct nlmsgerr *err;
+        struct nlmsghdr *nh;
+        char buf[4096];
+        int len, ret;
+
+        while (multipart) {
+                multipart = false;
+                len = recv(sock, buf, sizeof(buf), 0);
+                if (len < 0) {
+                        ret = -errno;
+                        goto done;
+                }
+
+                if (len == 0)
+                        break;
+
+                for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, len);
+                     nh = NLMSG_NEXT(nh, len)) {
+                        if (nh->nlmsg_pid != nl_pid) {
+                                ret = -LIBBPF_ERRNO__WRNGPID;
+                                goto done;
+                        }
+                        if (nh->nlmsg_seq != seq) {
+                                ret = -LIBBPF_ERRNO__INVSEQ;
+                                goto done;
+                        }
+                        if (nh->nlmsg_flags & NLM_F_MULTI)
+                                multipart = true;
+                        switch (nh->nlmsg_type) {
+                        case NLMSG_ERROR:
+                                err = (struct nlmsgerr *)NLMSG_DATA(nh);
+                                if (!err->error)
+                                        continue;
+                                ret = err->error;
+                                nla_dump_errormsg(nh);
+                                goto done;
+                        case NLMSG_DONE:
+                                return 0;
+                        default:
+                                break;
+                        }
+                        if (_fn) {
+                                ret = _fn(nh, fn, cookie);
+                                if (ret)
+                                        return ret;
+                        }
+                }
+        }
+        ret = 0;
+done:
+        return ret;
+}
+
+int bpf_set_link_xdp_fd(int ifindex, int fd, __u32 flags)
+{
+        int sock, seq = 0, ret;
+        struct nlattr *nla, *nla_xdp;
+        struct {
+                struct nlmsghdr  nh;
+                struct ifinfomsg ifinfo;
+                char             attrbuf[64];
+        } req;
+        __u32 nl_pid;
+
+        sock = bpf_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;
+
+        /* 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;
+
+        /* 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;
+        }
+
+        req.nh.nlmsg_len += NLA_ALIGN(nla->nla_len);
+
+        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;
+}
+
+static int __dump_link_nlmsg(struct nlmsghdr *nlh, dump_nlmsg_t dump_link_nlmsg,
+                             void *cookie)
+{
+        struct nlattr *tb[IFLA_MAX + 1], *attr;
+        struct ifinfomsg *ifi = NLMSG_DATA(nlh);
+        int len;
+
+        len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*ifi));
+        attr = (struct nlattr *) ((void *) ifi + NLMSG_ALIGN(sizeof(*ifi)));
+        if (nla_parse(tb, IFLA_MAX, attr, len, NULL) != 0)
+                return -LIBBPF_ERRNO__NLPARSE;
+
+        return dump_link_nlmsg(cookie, ifi, tb);
+}
+
+int nl_get_link(int sock, unsigned int nl_pid, dump_nlmsg_t dump_link_nlmsg,
+                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);
+
+        req.nlh.nlmsg_seq = seq;
+        if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0)
+                return -errno;
+
+        return bpf_netlink_recv(sock, nl_pid, seq, __dump_link_nlmsg,
+                                dump_link_nlmsg, cookie);
+}
+
+static int __dump_class_nlmsg(struct nlmsghdr *nlh,
+                              dump_nlmsg_t dump_class_nlmsg, void *cookie)
+{
+        struct nlattr *tb[TCA_MAX + 1], *attr;
+        struct tcmsg *t = NLMSG_DATA(nlh);
+        int len;
+
+        len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t));
+        attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t)));
+        if (nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
+                return -LIBBPF_ERRNO__NLPARSE;
+
+        return dump_class_nlmsg(cookie, t, tb);
+}
+
+int nl_get_class(int sock, unsigned int nl_pid, int ifindex,
+                 dump_nlmsg_t dump_class_nlmsg, void *cookie)
+{
+        struct {
+                struct nlmsghdr nlh;
+                struct tcmsg t;
+        } req = {
+                .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)),
+                .nlh.nlmsg_type = RTM_GETTCLASS,
+                .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
+                .t.tcm_family = AF_UNSPEC,
+                .t.tcm_ifindex = ifindex,
+        };
+        int seq = time(NULL);
+
+        req.nlh.nlmsg_seq = seq;
+        if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0)
+                return -errno;
+
+        return bpf_netlink_recv(sock, nl_pid, seq, __dump_class_nlmsg,
+                                dump_class_nlmsg, cookie);
+}
+
+static int __dump_qdisc_nlmsg(struct nlmsghdr *nlh,
+                              dump_nlmsg_t dump_qdisc_nlmsg, void *cookie)
+{
+        struct nlattr *tb[TCA_MAX + 1], *attr;
+        struct tcmsg *t = NLMSG_DATA(nlh);
+        int len;
+
+        len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t));
+        attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t)));
+        if (nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
+                return -LIBBPF_ERRNO__NLPARSE;
+
+        return dump_qdisc_nlmsg(cookie, t, tb);
+}
+
+int nl_get_qdisc(int sock, unsigned int nl_pid, int ifindex,
+                 dump_nlmsg_t dump_qdisc_nlmsg, void *cookie)
+{
+        struct {
+                struct nlmsghdr nlh;
+                struct tcmsg t;
+        } req = {
+                .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)),
+                .nlh.nlmsg_type = RTM_GETQDISC,
+                .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
+                .t.tcm_family = AF_UNSPEC,
+                .t.tcm_ifindex = ifindex,
+        };
+        int seq = time(NULL);
+
+        req.nlh.nlmsg_seq = seq;
+        if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0)
+                return -errno;
+
+        return bpf_netlink_recv(sock, nl_pid, seq, __dump_qdisc_nlmsg,
+                                dump_qdisc_nlmsg, cookie);
+}
+
+static int __dump_filter_nlmsg(struct nlmsghdr *nlh,
+                               dump_nlmsg_t dump_filter_nlmsg, void *cookie)
+{
+        struct nlattr *tb[TCA_MAX + 1], *attr;
+        struct tcmsg *t = NLMSG_DATA(nlh);
+        int len;
+
+        len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t));
+        attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t)));
+        if (nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
+                return -LIBBPF_ERRNO__NLPARSE;
+
+        return dump_filter_nlmsg(cookie, t, tb);
+}
+
+int nl_get_filter(int sock, unsigned int nl_pid, int ifindex, int handle,
+                  dump_nlmsg_t dump_filter_nlmsg, void *cookie)
+{
+        struct {
+                struct nlmsghdr nlh;
+                struct tcmsg t;
+        } req = {
+                .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)),
+                .nlh.nlmsg_type = RTM_GETTFILTER,
+                .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
+                .t.tcm_family = AF_UNSPEC,
+                .t.tcm_ifindex = ifindex,
+                .t.tcm_parent = handle,
+        };
+        int seq = time(NULL);
+
+        req.nlh.nlmsg_seq = seq;
+        if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0)
+                return -errno;
+
+        return bpf_netlink_recv(sock, nl_pid, seq, __dump_filter_nlmsg,
+                                dump_filter_nlmsg, cookie);
+}
diff --git a/tools/lib/bpf/nlattr.c b/tools/lib/bpf/nlattr.c
index 4719434278b2..49f514119bdb 100644
--- a/tools/lib/bpf/nlattr.c
+++ b/tools/lib/bpf/nlattr.c
@@ -26,11 +26,6 @@ static uint16_t nla_attr_minlen[NLA_TYPE_MAX+1] = {
         [NLA_FLAG]      = 0,
 };
 
-static int nla_len(const struct nlattr *nla)
-{
-        return nla->nla_len - NLA_HDRLEN;
-}
-
 static struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
 {
         int totlen = NLA_ALIGN(nla->nla_len);
@@ -46,11 +41,6 @@ static int nla_ok(const struct nlattr *nla, int remaining)
                nla->nla_len <= remaining;
 }
 
-static void *nla_data(const struct nlattr *nla)
-{
-        return (char *) nla + NLA_HDRLEN;
-}
-
 static int nla_type(const struct nlattr *nla)
 {
         return nla->nla_type & NLA_TYPE_MASK;
@@ -114,8 +104,8 @@ static inline int nlmsg_len(const struct nlmsghdr *nlh)
  * @see nla_validate
  * @return 0 on success or a negative error code.
  */
-static int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len,
-                     struct nla_policy *policy)
+int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len,
+              struct nla_policy *policy)
 {
         struct nlattr *nla;
         int rem, err;
@@ -146,6 +136,25 @@ errout:
         return err;
 }
 
+/**
+ * Create attribute index based on nested attribute
+ * @arg tb              Index array to be filled (maxtype+1 elements).
+ * @arg maxtype         Maximum attribute type expected and accepted.
+ * @arg nla             Nested Attribute.
+ * @arg policy          Attribute validation policy.
+ *
+ * Feeds the stream of attributes nested into the specified attribute
+ * to nla_parse().
+ *
+ * @see nla_parse
+ * @return 0 on success or a negative error code.
+ */
+int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla,
+                     struct nla_policy *policy)
+{
+        return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
+}
+
 /* dump netlink extended ack error message */
 int nla_dump_errormsg(struct nlmsghdr *nlh)
 {
diff --git a/tools/lib/bpf/nlattr.h b/tools/lib/bpf/nlattr.h
index 931a71f68f93..a6e2396bce7c 100644
--- a/tools/lib/bpf/nlattr.h
+++ b/tools/lib/bpf/nlattr.h
@@ -67,6 +67,44 @@ struct nla_policy {
              nla_ok(pos, rem); \
              pos = nla_next(pos, &(rem)))
 
+/**
+ * nla_data - head of payload
+ * @nla: netlink attribute
+ */
+static inline void *nla_data(const struct nlattr *nla)
+{
+        return (char *) nla + NLA_HDRLEN;
+}
+
+static inline uint8_t nla_getattr_u8(const struct nlattr *nla)
+{
+        return *(uint8_t *)nla_data(nla);
+}
+
+static inline uint32_t nla_getattr_u32(const struct nlattr *nla)
+{
+        return *(uint32_t *)nla_data(nla);
+}
+
+static inline const char *nla_getattr_str(const struct nlattr *nla)
+{
+        return (const char *)nla_data(nla);
+}
+
+/**
+ * nla_len - length of payload
+ * @nla: netlink attribute
+ */
+static inline int nla_len(const struct nlattr *nla)
+{
+        return nla->nla_len - NLA_HDRLEN;
+}
+
+int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len,
+              struct nla_policy *policy);
+int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla,
+                     struct nla_policy *policy);
+
 int nla_dump_errormsg(struct nlmsghdr *nlh);
 
 #endif /* __NLATTR_H */