Merge remote-tracking branch 'net-next/master'

diff --cc Documentation/devicetree/bindings/vendor-prefixes.txt
Simple merge

diff --cc Documentation/networking/device_drivers/dec/de4x5.txt
Simple merge

diff --cc MAINTAINERS
Simple merge

diff --cc drivers/infiniband/hw/cxgb4/cm.c
Simple merge

diff --cc drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c
Simple merge

diff --cc drivers/net/ethernet/mellanox/mlx5/core/en.h
Simple merge

diff --cc drivers/net/ethernet/mellanox/mlx5/core/en_main.c
Simple merge

diff --cc drivers/net/ethernet/mellanox/mlxsw/spectrum_nve.c
Simple merge

diff --cc drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c
Simple merge

diff --cc drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c
Simple merge

diff --cc drivers/net/ethernet/netronome/nfp/flower/offload.c
index 2f49eb75f3cce3245b7162a2ee3cf664bc0ab7f1,545d94168874419de78abff891817bfb5c63ebe5..21499a5b3b6bc20efad74f720cd8b4ebf2431302
--- 1/drivers/net/ethernet/netronome/nfp/flower/offload.c
--- 2/drivers/net/ethernet/netronome/nfp/flower/offload.c
+++ b/drivers/net/ethernet/netronome/nfp/flower/offload.c
@@@ -480,14 -469,10 +464,15 @@@ nfp_flower_add_offload(struct nfp_app *
        err = rhashtable_insert_fast(&priv->flow_table, &flow_pay->fl_node,
                                     nfp_flower_table_params);
        if (err)
 -              goto err_destroy_flow;
 +              goto err_release_metadata;
 +
-       err = nfp_flower_xmit_flow(netdev, flow_pay,
++      err = nfp_flower_xmit_flow(app, flow_pay,
 +                                 NFP_FLOWER_CMSG_TYPE_FLOW_ADD);
 +      if (err)
 +              goto err_remove_rhash;
  
-       port->tc_offload_cnt++;
+       if (port)
+               port->tc_offload_cnt++;
  
        /* Deallocate flow payload when flower rule has been destroyed. */
        kfree(key_layer);

diff --cc drivers/net/ethernet/socionext/sni_ave.c
Simple merge

diff --cc drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
Simple merge

diff --cc drivers/net/tun.c
index 005020042be946a23609dca3dfdcb589d60eff01,6760b86547df18b92bbf54575eadb85232bc963f..ea528248d7d022244ce937a282c6a578b8147c80
--- 1/drivers/net/tun.c
--- 2/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@@ -2381,11 -2401,17 +2401,18 @@@ static void tun_sock_write_space(struc
        kill_fasync(&tfile->fasync, SIGIO, POLL_OUT);
  }
  
+ static void tun_put_page(struct tun_page *tpage)
+ {
+       if (tpage->page)
+               __page_frag_cache_drain(tpage->page, tpage->count);
+ }
+ 
  static int tun_xdp_one(struct tun_struct *tun,
                       struct tun_file *tfile,
-                      struct xdp_buff *xdp, int *flush)
+                      struct xdp_buff *xdp, int *flush,
+                      struct tun_page *tpage)
  {
 +      unsigned int datasize = xdp->data_end - xdp->data;
        struct tun_xdp_hdr *hdr = xdp->data_hard_start;
        struct virtio_net_hdr *gso = &hdr->gso;
        struct tun_pcpu_stats *stats;

diff --cc drivers/s390/virtio/virtio_ccw.c
Simple merge

diff --cc include/linux/filter.h
Simple merge

diff --cc include/net/neighbour.h
Simple merge

diff --cc include/net/sctp/sctp.h
Simple merge

diff --cc include/net/sctp/structs.h
index feada358d872f3bc5622f5787078fde4cbfa6a97,7eaa294d938dad7a2453e8003be31ba2e05a5cb5..003020eb6e666c47d2c7c625d527037cef4e5d1a
--- 1/include/net/sctp/structs.h
--- 2/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@@ -2073,10 -2077,10 +2077,12 @@@ struct sctp_association 
  
        int sent_cnt_removable;
  
+       __u16 subscribe;
+ 
        __u64 abandoned_unsent[SCTP_PR_INDEX(MAX) + 1];
        __u64 abandoned_sent[SCTP_PR_INDEX(MAX) + 1];
 +
 +      struct rcu_head rcu;
  };
  
  

diff --cc include/uapi/linux/bpf.h
index 72c453a8bf50ed5cd4a0383997f5727048ce8d60,597afdbc1ab93a7f5e6774dd5dcba035d59f597d..ec8b40ff386e3ac8cecbaf9ce6ef611228485b13
--- 1/include/uapi/linux/bpf.h
--- 2/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@@ -2473,7 -2481,8 +2494,8 @@@ struct __sk_buff 
        /* ... here. */
  
        __u32 data_meta;
 -      struct bpf_flow_keys *flow_keys;
 +      __bpf_md_ptr(struct bpf_flow_keys *, flow_keys);
+       __u64 tstamp;
  };
  
  struct bpf_tunnel_key {

diff --cc kernel/bpf/btf.c
Simple merge

diff --cc kernel/bpf/verifier.c
Simple merge

diff --cc lib/Kconfig
Simple merge

diff --cc lib/Kconfig.debug
Simple merge

diff --cc net/core/dev.c
Simple merge

diff --cc net/core/filter.c
index 8d2c629501e2df10b0b4113986cac71369863789,bd0df75dc7b6e42097786fc6e73ea650104fa09a..8659b40172d18705a6445bfaace622938a0990ff
--- 1/net/core/filter.c
--- 2/net/core/filter.c
+++ b/net/core/filter.c
@@@ -4887,26 -5067,26 +5067,27 @@@ __bpf_sk_lookup(struct sk_buff *skb, st
        struct sock *sk = NULL;
        u8 family = AF_UNSPEC;
        struct net *net;
+       int sdif;
  
        family = len == sizeof(tuple->ipv4) ? AF_INET : AF_INET6;
 -      if (unlikely(family == AF_UNSPEC || netns_id > U32_MAX || flags))
 +      if (unlikely(family == AF_UNSPEC || flags ||
 +                   !((s32)netns_id < 0 || netns_id <= S32_MAX)))
                goto out;
  
-       if (skb->dev)
-               caller_net = dev_net(skb->dev);
+       if (family == AF_INET)
+               sdif = inet_sdif(skb);
        else
-               caller_net = sock_net(skb->sk);
+               sdif = inet6_sdif(skb);
+ 
 -      if (netns_id) {
 +      if ((s32)netns_id < 0) {
 +              net = caller_net;
-               sk = sk_lookup(net, tuple, skb, family, proto);
++              sk = sk_lookup(net, tuple, ifindex, sdif, family, proto);
 +      } else {
                net = get_net_ns_by_id(caller_net, netns_id);
                if (unlikely(!net))
                        goto out;
-               sk = sk_lookup(net, tuple, skb, family, proto);
+               sk = sk_lookup(net, tuple, ifindex, sdif, family, proto);
                put_net(net);
 -      } else {
 -              net = caller_net;
 -              sk = sk_lookup(net, tuple, ifindex, sdif, family, proto);
        }
  
        if (sk)
@@@ -5436,10 -5737,14 +5738,14 @@@ static bool bpf_skb_is_valid_access(in
                if (size != size_default)
                        return false;
                break;
 -      case bpf_ctx_range(struct __sk_buff, flow_keys):
 -              if (size != sizeof(struct bpf_flow_keys *))
 +      case bpf_ctx_range_ptr(struct __sk_buff, flow_keys):
 +              if (size != sizeof(__u64))
                        return false;
                break;
+       case bpf_ctx_range(struct __sk_buff, tstamp):
+               if (size != sizeof(__u64))
+                       return false;
+               break;
        default:
                /* Only narrow read access allowed for now. */
                if (type == BPF_WRITE) {
@@@ -5465,8 -5770,9 +5771,9 @@@ static bool sk_filter_is_valid_access(i
        case bpf_ctx_range(struct __sk_buff, data):
        case bpf_ctx_range(struct __sk_buff, data_meta):
        case bpf_ctx_range(struct __sk_buff, data_end):
 -      case bpf_ctx_range(struct __sk_buff, flow_keys):
 +      case bpf_ctx_range_ptr(struct __sk_buff, flow_keys):
        case bpf_ctx_range_till(struct __sk_buff, family, local_port):
+       case bpf_ctx_range(struct __sk_buff, tstamp):
                return false;
        }
  
@@@ -5531,7 -5841,8 +5842,8 @@@ static bool lwt_is_valid_access(int off
        case bpf_ctx_range(struct __sk_buff, tc_classid):
        case bpf_ctx_range_till(struct __sk_buff, family, local_port):
        case bpf_ctx_range(struct __sk_buff, data_meta):
 -      case bpf_ctx_range(struct __sk_buff, flow_keys):
 +      case bpf_ctx_range_ptr(struct __sk_buff, flow_keys):
+       case bpf_ctx_range(struct __sk_buff, tstamp):
                return false;
        }
  
@@@ -5959,7 -6271,8 +6272,8 @@@ static bool sk_skb_is_valid_access(int 
        switch (off) {
        case bpf_ctx_range(struct __sk_buff, tc_classid):
        case bpf_ctx_range(struct __sk_buff, data_meta):
 -      case bpf_ctx_range(struct __sk_buff, flow_keys):
 +      case bpf_ctx_range_ptr(struct __sk_buff, flow_keys):
+       case bpf_ctx_range(struct __sk_buff, tstamp):
                return false;
        }
  

diff --cc net/core/flow_dissector.c
Simple merge

diff --cc net/core/rtnetlink.c
Simple merge

diff --cc net/dsa/master.c
index 5e8c9bef78bd2ec26b405d1de6e9a74845492e8b,d7d5145aa2351a145fef00030a87785b2601e011..71bb15f491c81af1c911d4182d746e89095ae68e
--- 1/net/dsa/master.c
--- 2/net/dsa/master.c
+++ b/net/dsa/master.c
@@@ -158,31 -158,36 +158,59 @@@ static void dsa_master_ethtool_teardown
        cpu_dp->orig_ethtool_ops = NULL;
  }
  
 +static ssize_t tagging_show(struct device *d, struct device_attribute *attr,
 +                          char *buf)
 +{
 +      struct net_device *dev = to_net_dev(d);
 +      struct dsa_port *cpu_dp = dev->dsa_ptr;
 +
 +      return sprintf(buf, "%s\n",
 +                     dsa_tag_protocol_to_str(cpu_dp->tag_ops));
 +}
 +static DEVICE_ATTR_RO(tagging);
 +
 +static struct attribute *dsa_slave_attrs[] = {
 +      &dev_attr_tagging.attr,
 +      NULL
 +};
 +
 +static const struct attribute_group dsa_group = {
 +      .name   = "dsa",
 +      .attrs  = dsa_slave_attrs,
 +};
 +
+ static void dsa_master_set_mtu(struct net_device *dev, struct dsa_port *cpu_dp)
+ {
+       unsigned int mtu = ETH_DATA_LEN + cpu_dp->tag_ops->overhead;
+       int err;
+ 
+       rtnl_lock();
+       if (mtu <= dev->max_mtu) {
+               err = dev_set_mtu(dev, mtu);
+               if (err)
+                       netdev_dbg(dev, "Unable to set MTU to include for DSA overheads\n");
+       }
+       rtnl_unlock();
+ }
+ 
+ static void dsa_master_reset_mtu(struct net_device *dev)
+ {
+       int err;
+ 
+       rtnl_lock();
+       err = dev_set_mtu(dev, ETH_DATA_LEN);
+       if (err)
+               netdev_dbg(dev,
+                          "Unable to reset MTU to exclude DSA overheads\n");
+       rtnl_unlock();
+ }
+ 
  int dsa_master_setup(struct net_device *dev, struct dsa_port *cpu_dp)
  {
 +      int ret;
 +
+       dsa_master_set_mtu(dev,  cpu_dp);
+ 
        /* If we use a tagging format that doesn't have an ethertype
         * field, make sure that all packets from this point on get
         * sent to the tag format's receive function.
@@@ -204,8 -201,8 +232,9 @@@
  
  void dsa_master_teardown(struct net_device *dev)
  {
 +      sysfs_remove_group(&dev->dev.kobj, &dsa_group);
        dsa_master_ethtool_teardown(dev);
+       dsa_master_reset_mtu(dev);
  
        dev->dsa_ptr = NULL;
  

diff --cc net/dsa/slave.c
Simple merge

diff --cc net/ipv4/ip_input.c
Simple merge

diff --cc net/ipv4/tcp_output.c
index d1676d8a6ed70fbe050709a16a650df35a1f4d87,d3b691f3a9e896ce340ae081a0d24092024361c8..c31badfee806a70d5af6dc033cf9155adb1f9375
--- 1/net/ipv4/tcp_output.c
--- 2/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@@ -1904,16 -1904,18 +1904,17 @@@ static int tso_fragment(struct sock *sk
   * This algorithm is from John Heffner.
   */
  static bool tcp_tso_should_defer(struct sock *sk, struct sk_buff *skb,
 -                               bool *is_cwnd_limited, u32 max_segs)
 +                               bool *is_cwnd_limited,
 +                               bool *is_rwnd_limited,
 +                               u32 max_segs)
  {
        const struct inet_connection_sock *icsk = inet_csk(sk);
-       u32 age, send_win, cong_win, limit, in_flight;
+       u32 send_win, cong_win, limit, in_flight;
        struct tcp_sock *tp = tcp_sk(sk);
        struct sk_buff *head;
        int win_divisor;
+       s64 delta;
  
 -      if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
 -              goto send_now;
 -
        if (icsk->icsk_ca_state >= TCP_CA_Recovery)
                goto send_now;
  
@@@ -1967,32 -1976,15 +1975,32 @@@
        head = tcp_rtx_queue_head(sk);
        if (!head)
                goto send_now;
-       age = tcp_stamp_us_delta(tp->tcp_mstamp, tcp_skb_timestamp_us(head));
+       delta = tp->tcp_clock_cache - head->tstamp;
        /* If next ACK is likely to come too late (half srtt), do not defer */
-       if (age < (tp->srtt_us >> 4))
+       if ((s64)(delta - (u64)NSEC_PER_USEC * (tp->srtt_us >> 4)) < 0)
                goto send_now;
  
 -      /* Ok, it looks like it is advisable to defer. */
 +      /* Ok, it looks like it is advisable to defer.
 +       * Three cases are tracked :
 +       * 1) We are cwnd-limited
 +       * 2) We are rwnd-limited
 +       * 3) We are application limited.
 +       */
 +      if (cong_win < send_win) {
 +              if (cong_win <= skb->len) {
 +                      *is_cwnd_limited = true;
 +                      return true;
 +              }
 +      } else {
 +              if (send_win <= skb->len) {
 +                      *is_rwnd_limited = true;
 +                      return true;
 +              }
 +      }
  
 -      if (cong_win < send_win && cong_win <= skb->len)
 -              *is_cwnd_limited = true;
 +      /* If this packet won't get more data, do not wait. */
 +      if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
 +              goto send_now;
  
        return true;
  

diff --cc net/ipv6/ip6_input.c
Simple merge

diff --cc net/ipv6/ip6_output.c
Simple merge

diff --cc net/sched/cls_flower.c
index 71312d7bd8f490c9b8200ccaac59ea0cd0031da6,85e9f8e1da10aa7b01b0f51768edfefbe63d6a10..544811dded600bc0b6e73e2c963eb302ab4b06f0
--- 1/net/sched/cls_flower.c
--- 2/net/sched/cls_flower.c
+++ b/net/sched/cls_flower.c
@@@ -1238,16 -1355,18 +1355,16 @@@ static int fl_change(struct net *net, s
        if (err)
                goto errout_idr;
  
-       if (!fold && fl_lookup(fnew->mask, &fnew->mkey)) {
 -      if (!tc_skip_sw(fnew->flags)) {
 -              if (!fold && __fl_lookup(fnew->mask, &fnew->mkey)) {
 -                      err = -EEXIST;
 -                      goto errout_mask;
 -              }
 -
 -              err = rhashtable_insert_fast(&fnew->mask->ht, &fnew->ht_node,
 -                                           fnew->mask->filter_ht_params);
 -              if (err)
 -                      goto errout_mask;
++      if (!fold && __fl_lookup(fnew->mask, &fnew->mkey)) {
 +              err = -EEXIST;
 +              goto errout_mask;
        }
  
 +      err = rhashtable_insert_fast(&fnew->mask->ht, &fnew->ht_node,
 +                                   fnew->mask->filter_ht_params);
 +      if (err)
 +              goto errout_mask;
 +
        if (!tc_skip_hw(fnew->flags)) {
                err = fl_hw_replace_filter(tp, fnew, extack);
                if (err)

diff --cc net/sched/sch_netem.c
Simple merge

diff --cc net/sctp/associola.c
Simple merge

diff --cc net/sctp/chunk.c
Simple merge

diff --cc net/sctp/socket.c
Simple merge

diff --cc tools/bpf/bpftool/btf_dumper.c
Simple merge

diff --cc tools/include/uapi/linux/bpf.h
index 72c453a8bf50ed5cd4a0383997f5727048ce8d60,597afdbc1ab93a7f5e6774dd5dcba035d59f597d..ec8b40ff386e3ac8cecbaf9ce6ef611228485b13
--- 1/tools/include/uapi/linux/bpf.h
--- 2/tools/include/uapi/linux/bpf.h
+++ b/tools/include/uapi/linux/bpf.h
@@@ -2473,7 -2481,8 +2494,8 @@@ struct __sk_buff 
        /* ... here. */
  
        __u32 data_meta;
 -      struct bpf_flow_keys *flow_keys;
 +      __bpf_md_ptr(struct bpf_flow_keys *, flow_keys);
+       __u64 tstamp;
  };
  
  struct bpf_tunnel_key {

diff --cc tools/testing/selftests/bpf/bpf_flow.c
Simple merge

diff --cc tools/testing/selftests/bpf/bpf_helpers.h
Simple merge

diff --cc tools/testing/selftests/bpf/test_btf.c
Simple merge

diff --cc tools/testing/selftests/bpf/test_verifier.c
Simple merge