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

Pull networking updates from David Miller:

 1) Support offloading wireless authentication to userspace via
    NL80211_CMD_EXTERNAL_AUTH, from Srinivas Dasari.

 2) A lot of work on network namespace setup/teardown from Kirill Tkhai.
    Setup and cleanup of namespaces now all run asynchronously and thus
    performance is significantly increased.

 3) Add rx/tx timestamping support to mv88e6xxx driver, from Brandon
    Streiff.

 4) Support zerocopy on RDS sockets, from Sowmini Varadhan.

 5) Use denser instruction encoding in x86 eBPF JIT, from Daniel
    Borkmann.

 6) Support hw offload of vlan filtering in mvpp2 dreiver, from Maxime
    Chevallier.

 7) Support grafting of child qdiscs in mlxsw driver, from Nogah
    Frankel.

 8) Add packet forwarding tests to selftests, from Ido Schimmel.

 9) Deal with sub-optimal GSO packets better in BBR congestion control,
    from Eric Dumazet.

10) Support 5-tuple hashing in ipv6 multipath routing, from David Ahern.

11) Add path MTU tests to selftests, from Stefano Brivio.

12) Various bits of IPSEC offloading support for mlx5, from Aviad
    Yehezkel, Yossi Kuperman, and Saeed Mahameed.

13) Support RSS spreading on ntuple filters in SFC driver, from Edward
    Cree.

14) Lots of sockmap work from John Fastabend. Applications can use eBPF
    to filter sendmsg and sendpage operations.

15) In-kernel receive TLS support, from Dave Watson.

16) Add XDP support to ixgbevf, this is significant because it should
    allow optimized XDP usage in various cloud environments. From Tony
    Nguyen.

17) Add new Intel E800 series "ice" ethernet driver, from Anirudh
    Venkataramanan et al.

18) IP fragmentation match offload support in nfp driver, from Pieter
    Jansen van Vuuren.

19) Support XDP redirect in i40e driver, from Björn Töpel.

20) Add BPF_RAW_TRACEPOINT program type for accessing the arguments of
    tracepoints in their raw form, from Alexei Starovoitov.

21) Lots of striding RQ improvements to mlx5 driver with many
    performance improvements, from Tariq Toukan.

22) Use rhashtable for inet frag reassembly, from Eric Dumazet.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1678 commits)
  net: mvneta: improve suspend/resume
  net: mvneta: split rxq/txq init and txq deinit into SW and HW parts
  ipv6: frags: fix /proc/sys/net/ipv6/ip6frag_low_thresh
  net: bgmac: Fix endian access in bgmac_dma_tx_ring_free()
  net: bgmac: Correctly annotate register space
  route: check sysctl_fib_multipath_use_neigh earlier than hash
  fix typo in command value in drivers/net/phy/mdio-bitbang.
  sky2: Increase D3 delay to sky2 stops working after suspend
  net/mlx5e: Set EQE based as default TX interrupt moderation mode
  ibmvnic: Disable irqs before exiting reset from closed state
  net: sched: do not emit messages while holding spinlock
  vlan: also check phy_driver ts_info for vlan's real device
  Bluetooth: Mark expected switch fall-throughs
  Bluetooth: Set HCI_QUIRK_SIMULTANEOUS_DISCOVERY for BTUSB_QCA_ROME
  Bluetooth: btrsi: remove unused including <linux/version.h>
  Bluetooth: hci_bcm: Remove DMI quirk for the MINIX Z83-4
  sh_eth: kill useless check in __sh_eth_get_regs()
  sh_eth: add sh_eth_cpu_data::no_xdfar flag
  ipv6: factorize sk_wmem_alloc updates done by __ip6_append_data()
  ipv4: factorize sk_wmem_alloc updates done by __ip_append_data()
  ...

4 files changed, 149 insertions, 46 deletions

diff --git a/tools/lib/bpf/bpf.c b/tools/lib/bpf/bpf.c
index 592a58a2b681..acbb3f8b3bec 100644
--- a/tools/lib/bpf/bpf.c
+++ b/tools/lib/bpf/bpf.c
@@ -146,26 +146,30 @@ int bpf_create_map_in_map(enum bpf_map_type map_type, const char *name,
                                           -1);
 }
 
-int bpf_load_program_name(enum bpf_prog_type type, const char *name,
-                          const struct bpf_insn *insns,
-                          size_t insns_cnt, const char *license,
-                          __u32 kern_version, char *log_buf,
-                          size_t log_buf_sz)
+int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,
+                           char *log_buf, size_t log_buf_sz)
 {
-        int fd;
         union bpf_attr attr;
-        __u32 name_len = name ? strlen(name) : 0;
+        __u32 name_len;
+        int fd;
+
+        if (!load_attr)
+                return -EINVAL;
+
+        name_len = load_attr->name ? strlen(load_attr->name) : 0;
 
         bzero(&attr, sizeof(attr));
-        attr.prog_type = type;
-        attr.insn_cnt = (__u32)insns_cnt;
-        attr.insns = ptr_to_u64(insns);
-        attr.license = ptr_to_u64(license);
+        attr.prog_type = load_attr->prog_type;
+        attr.expected_attach_type = load_attr->expected_attach_type;
+        attr.insn_cnt = (__u32)load_attr->insns_cnt;
+        attr.insns = ptr_to_u64(load_attr->insns);
+        attr.license = ptr_to_u64(load_attr->license);
         attr.log_buf = ptr_to_u64(NULL);
         attr.log_size = 0;
         attr.log_level = 0;
-        attr.kern_version = kern_version;
-        memcpy(attr.prog_name, name, min(name_len, BPF_OBJ_NAME_LEN - 1));
+        attr.kern_version = load_attr->kern_version;
+        memcpy(attr.prog_name, load_attr->name,
+               min(name_len, BPF_OBJ_NAME_LEN - 1));
 
         fd = sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
         if (fd >= 0 || !log_buf || !log_buf_sz)
@@ -184,8 +188,18 @@ int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
                      __u32 kern_version, char *log_buf,
                      size_t log_buf_sz)
 {
-        return bpf_load_program_name(type, NULL, insns, insns_cnt, license,
-                                     kern_version, log_buf, log_buf_sz);
+        struct bpf_load_program_attr load_attr;
+
+        memset(&load_attr, 0, sizeof(struct bpf_load_program_attr));
+        load_attr.prog_type = type;
+        load_attr.expected_attach_type = 0;
+        load_attr.name = NULL;
+        load_attr.insns = insns;
+        load_attr.insns_cnt = insns_cnt;
+        load_attr.license = license;
+        load_attr.kern_version = kern_version;
+
+        return bpf_load_program_xattr(&load_attr, log_buf, log_buf_sz);
 }
 
 int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,
@@ -428,6 +442,17 @@ int bpf_obj_get_info_by_fd(int prog_fd, void *info, __u32 *info_len)
         return err;
 }
 
+int bpf_raw_tracepoint_open(const char *name, int prog_fd)
+{
+        union bpf_attr attr;
+
+        bzero(&attr, sizeof(attr));
+        attr.raw_tracepoint.name = ptr_to_u64(name);
+        attr.raw_tracepoint.prog_fd = 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;
diff --git a/tools/lib/bpf/bpf.h b/tools/lib/bpf/bpf.h
index 8d18fb73d7fb..39f6a0d64a3b 100644
--- a/tools/lib/bpf/bpf.h
+++ b/tools/lib/bpf/bpf.h
@@ -41,13 +41,20 @@ int bpf_create_map_in_map(enum bpf_map_type map_type, const char *name,
                           int key_size, int inner_map_fd, int max_entries,
                           __u32 map_flags);
 
+struct bpf_load_program_attr {
+        enum bpf_prog_type prog_type;
+        enum bpf_attach_type expected_attach_type;
+        const char *name;
+        const struct bpf_insn *insns;
+        size_t insns_cnt;
+        const char *license;
+        __u32 kern_version;
+};
+
 /* Recommend log buffer size */
 #define BPF_LOG_BUF_SIZE (256 * 1024)
-int bpf_load_program_name(enum bpf_prog_type type, const char *name,
-                          const struct bpf_insn *insns,
-                          size_t insns_cnt, const char *license,
-                          __u32 kern_version, char *log_buf,
-                          size_t log_buf_sz);
+int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,
+                           char *log_buf, size_t log_buf_sz);
 int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
                      size_t insns_cnt, const char *license,
                      __u32 kern_version, char *log_buf,
@@ -79,4 +86,5 @@ int bpf_map_get_fd_by_id(__u32 id);
 int bpf_obj_get_info_by_fd(int prog_fd, void *info, __u32 *info_len);
 int bpf_prog_query(int target_fd, enum bpf_attach_type type, __u32 query_flags,
                    __u32 *attach_flags, __u32 *prog_ids, __u32 *prog_cnt);
+int bpf_raw_tracepoint_open(const char *name, int prog_fd);
 #endif
diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 5bbbf285af74..5922443063f0 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -203,6 +203,8 @@ struct bpf_program {
         struct bpf_object *obj;
         void *priv;
         bpf_program_clear_priv_t clear_priv;
+
+        enum bpf_attach_type expected_attach_type;
 };
 
 struct bpf_map {
@@ -1162,21 +1164,31 @@ static int bpf_object__collect_reloc(struct bpf_object *obj)
 }
 
 static int
-load_program(enum bpf_prog_type type, const char *name, struct bpf_insn *insns,
-             int insns_cnt, char *license, u32 kern_version, int *pfd)
+load_program(enum bpf_prog_type type, enum bpf_attach_type expected_attach_type,
+             const char *name, struct bpf_insn *insns, int insns_cnt,
+             char *license, u32 kern_version, int *pfd)
 {
-        int ret;
+        struct bpf_load_program_attr load_attr;
         char *log_buf;
+        int ret;
 
-        if (!insns || !insns_cnt)
+        memset(&load_attr, 0, sizeof(struct bpf_load_program_attr));
+        load_attr.prog_type = type;
+        load_attr.expected_attach_type = expected_attach_type;
+        load_attr.name = name;
+        load_attr.insns = insns;
+        load_attr.insns_cnt = insns_cnt;
+        load_attr.license = license;
+        load_attr.kern_version = kern_version;
+
+        if (!load_attr.insns || !load_attr.insns_cnt)
                 return -EINVAL;
 
         log_buf = malloc(BPF_LOG_BUF_SIZE);
         if (!log_buf)
                 pr_warning("Alloc log buffer for bpf loader error, continue without log\n");
 
-        ret = bpf_load_program_name(type, name, insns, insns_cnt, license,
-                                    kern_version, log_buf, BPF_LOG_BUF_SIZE);
+        ret = bpf_load_program_xattr(&load_attr, log_buf, BPF_LOG_BUF_SIZE);
 
         if (ret >= 0) {
                 *pfd = ret;
@@ -1192,18 +1204,18 @@ load_program(enum bpf_prog_type type, const char *name, struct bpf_insn *insns,
                 pr_warning("-- BEGIN DUMP LOG ---\n");
                 pr_warning("\n%s\n", log_buf);
                 pr_warning("-- END LOG --\n");
-        } else if (insns_cnt >= BPF_MAXINSNS) {
-                pr_warning("Program too large (%d insns), at most %d insns\n",
-                           insns_cnt, BPF_MAXINSNS);
+        } else if (load_attr.insns_cnt >= BPF_MAXINSNS) {
+                pr_warning("Program too large (%zu insns), at most %d insns\n",
+                           load_attr.insns_cnt, BPF_MAXINSNS);
                 ret = -LIBBPF_ERRNO__PROG2BIG;
         } else {
                 /* Wrong program type? */
-                if (type != BPF_PROG_TYPE_KPROBE) {
+                if (load_attr.prog_type != BPF_PROG_TYPE_KPROBE) {
                         int fd;
 
-                        fd = bpf_load_program_name(BPF_PROG_TYPE_KPROBE, name,
-                                                   insns, insns_cnt, license,
-                                                   kern_version, NULL, 0);
+                        load_attr.prog_type = BPF_PROG_TYPE_KPROBE;
+                        load_attr.expected_attach_type = 0;
+                        fd = bpf_load_program_xattr(&load_attr, NULL, 0);
                         if (fd >= 0) {
                                 close(fd);
                                 ret = -LIBBPF_ERRNO__PROGTYPE;
@@ -1247,8 +1259,9 @@ bpf_program__load(struct bpf_program *prog,
                         pr_warning("Program '%s' is inconsistent: nr(%d) != 1\n",
                                    prog->section_name, prog->instances.nr);
                 }
-                err = load_program(prog->type, prog->name, prog->insns,
-                                   prog->insns_cnt, license, kern_version, &fd);
+                err = load_program(prog->type, prog->expected_attach_type,
+                                   prog->name, prog->insns, prog->insns_cnt,
+                                   license, kern_version, &fd);
                 if (!err)
                         prog->instances.fds[0] = fd;
                 goto out;
@@ -1276,8 +1289,8 @@ bpf_program__load(struct bpf_program *prog,
                         continue;
                 }
 
-                err = load_program(prog->type, prog->name,
-                                   result.new_insn_ptr,
+                err = load_program(prog->type, prog->expected_attach_type,
+                                   prog->name, result.new_insn_ptr,
                                    result.new_insn_cnt,
                                    license, kern_version, &fd);
 
@@ -1835,11 +1848,25 @@ BPF_PROG_TYPE_FNS(tracepoint, BPF_PROG_TYPE_TRACEPOINT);
 BPF_PROG_TYPE_FNS(xdp, BPF_PROG_TYPE_XDP);
 BPF_PROG_TYPE_FNS(perf_event, BPF_PROG_TYPE_PERF_EVENT);
 
-#define BPF_PROG_SEC(string, type) { string, sizeof(string) - 1, type }
+static void bpf_program__set_expected_attach_type(struct bpf_program *prog,
+                                                 enum bpf_attach_type type)
+{
+        prog->expected_attach_type = type;
+}
+
+#define BPF_PROG_SEC_FULL(string, ptype, atype) \
+        { string, sizeof(string) - 1, ptype, atype }
+
+#define BPF_PROG_SEC(string, ptype) BPF_PROG_SEC_FULL(string, ptype, 0)
+
+#define BPF_SA_PROG_SEC(string, ptype) \
+        BPF_PROG_SEC_FULL(string, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, ptype)
+
 static const struct {
         const char *sec;
         size_t len;
         enum bpf_prog_type prog_type;
+        enum bpf_attach_type expected_attach_type;
 } section_names[] = {
         BPF_PROG_SEC("socket",          BPF_PROG_TYPE_SOCKET_FILTER),
         BPF_PROG_SEC("kprobe/",         BPF_PROG_TYPE_KPROBE),
@@ -1857,10 +1884,18 @@ static const struct {
         BPF_PROG_SEC("lwt_xmit",        BPF_PROG_TYPE_LWT_XMIT),
         BPF_PROG_SEC("sockops",         BPF_PROG_TYPE_SOCK_OPS),
         BPF_PROG_SEC("sk_skb",          BPF_PROG_TYPE_SK_SKB),
+        BPF_PROG_SEC("sk_msg",          BPF_PROG_TYPE_SK_MSG),
+        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),
+        BPF_SA_PROG_SEC("cgroup/connect6", BPF_CGROUP_INET6_CONNECT),
 };
+
 #undef BPF_PROG_SEC
+#undef BPF_PROG_SEC_FULL
+#undef BPF_SA_PROG_SEC
 
-static enum bpf_prog_type bpf_program__guess_type(struct bpf_program *prog)
+static int bpf_program__identify_section(struct bpf_program *prog)
 {
         int i;
 
@@ -1870,13 +1905,13 @@ static enum bpf_prog_type bpf_program__guess_type(struct bpf_program *prog)
         for (i = 0; i < ARRAY_SIZE(section_names); i++)
                 if (strncmp(prog->section_name, section_names[i].sec,
                             section_names[i].len) == 0)
-                        return section_names[i].prog_type;
+                        return i;
 
 err:
         pr_warning("failed to guess program type based on section name %s\n",
                    prog->section_name);
 
-        return BPF_PROG_TYPE_UNSPEC;
+        return -1;
 }
 
 int bpf_map__fd(struct bpf_map *map)
@@ -1976,11 +2011,30 @@ long libbpf_get_error(const void *ptr)
 int bpf_prog_load(const char *file, enum bpf_prog_type type,
                   struct bpf_object **pobj, int *prog_fd)
 {
+        struct bpf_prog_load_attr attr;
+
+        memset(&attr, 0, sizeof(struct bpf_prog_load_attr));
+        attr.file = file;
+        attr.prog_type = type;
+        attr.expected_attach_type = 0;
+
+        return bpf_prog_load_xattr(&attr, pobj, prog_fd);
+}
+
+int bpf_prog_load_xattr(const struct bpf_prog_load_attr *attr,
+                        struct bpf_object **pobj, int *prog_fd)
+{
         struct bpf_program *prog, *first_prog = NULL;
+        enum bpf_attach_type expected_attach_type;
+        enum bpf_prog_type prog_type;
         struct bpf_object *obj;
+        int section_idx;
         int err;
 
-        obj = bpf_object__open(file);
+        if (!attr)
+                return -EINVAL;
+
+        obj = bpf_object__open(attr->file);
         if (IS_ERR(obj))
                 return -ENOENT;
 
@@ -1989,15 +2043,23 @@ int bpf_prog_load(const char *file, enum bpf_prog_type type,
                  * If type is not specified, try to guess it based on
                  * section name.
                  */
-                if (type == BPF_PROG_TYPE_UNSPEC) {
-                        type = bpf_program__guess_type(prog);
-                        if (type == BPF_PROG_TYPE_UNSPEC) {
+                prog_type = attr->prog_type;
+                expected_attach_type = attr->expected_attach_type;
+                if (prog_type == BPF_PROG_TYPE_UNSPEC) {
+                        section_idx = bpf_program__identify_section(prog);
+                        if (section_idx < 0) {
                                 bpf_object__close(obj);
                                 return -EINVAL;
                         }
+                        prog_type = section_names[section_idx].prog_type;
+                        expected_attach_type =
+                                section_names[section_idx].expected_attach_type;
                 }
 
-                bpf_program__set_type(prog, type);
+                bpf_program__set_type(prog, prog_type);
+                bpf_program__set_expected_attach_type(prog,
+                                                      expected_attach_type);
+
                 if (prog->idx != obj->efile.text_shndx && !first_prog)
                         first_prog = prog;
         }
diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h
index f85906533cdd..a3a62a583f27 100644
--- a/tools/lib/bpf/libbpf.h
+++ b/tools/lib/bpf/libbpf.h
@@ -248,6 +248,14 @@ int bpf_map__pin(struct bpf_map *map, const char *path);
 
 long libbpf_get_error(const void *ptr);
 
+struct bpf_prog_load_attr {
+        const char *file;
+        enum bpf_prog_type prog_type;
+        enum bpf_attach_type expected_attach_type;
+};
+
+int bpf_prog_load_xattr(const struct bpf_prog_load_attr *attr,
+                        struct bpf_object **pobj, int *prog_fd);
 int bpf_prog_load(const char *file, enum bpf_prog_type type,
                   struct bpf_object **pobj, int *prog_fd);