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

Pull networking updates from Davic Miller:

 1) Support busy polling generically, for all NAPI drivers.  From Eric
    Dumazet.

 2) Add byte/packet counter support to nft_ct, from Floriani Westphal.

 3) Add RSS/XPS support to mvneta driver, from Gregory Clement.

 4) Implement IPV6_HDRINCL socket option for raw sockets, from Hannes
    Frederic Sowa.

 5) Add support for T6 adapter to cxgb4 driver, from Hariprasad Shenai.

 6) Add support for VLAN device bridging to mlxsw switch driver, from
    Ido Schimmel.

 7) Add driver for Netronome NFP4000/NFP6000, from Jakub Kicinski.

 8) Provide hwmon interface to mlxsw switch driver, from Jiri Pirko.

 9) Reorganize wireless drivers into per-vendor directories just like we
    do for ethernet drivers.  From Kalle Valo.

10) Provide a way for administrators "destroy" connected sockets via the
    SOCK_DESTROY socket netlink diag operation.  From Lorenzo Colitti.

11) Add support to add/remove multicast routes via netlink, from Nikolay
    Aleksandrov.

12) Make TCP keepalive settings per-namespace, from Nikolay Borisov.

13) Add forwarding and packet duplication facilities to nf_tables, from
    Pablo Neira Ayuso.

14) Dead route support in MPLS, from Roopa Prabhu.

15) TSO support for thunderx chips, from Sunil Goutham.

16) Add driver for IBM's System i/p VNIC protocol, from Thomas Falcon.

17) Rationalize, consolidate, and more completely document the checksum
    offloading facilities in the networking stack.  From Tom Herbert.

18) Support aborting an ongoing scan in mac80211/cfg80211, from
    Vidyullatha Kanchanapally.

19) Use per-bucket spinlock for bpf hash facility, from Tom Leiming.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1375 commits)
  net: bnxt: always return values from _bnxt_get_max_rings
  net: bpf: reject invalid shifts
  phonet: properly unshare skbs in phonet_rcv()
  dwc_eth_qos: Fix dma address for multi-fragment skbs
  phy: remove an unneeded condition
  mdio: remove an unneed condition
  mdio_bus: NULL dereference on allocation error
  net: Fix typo in netdev_intersect_features
  net: freescale: mac-fec: Fix build error from phy_device API change
  net: freescale: ucc_geth: Fix build error from phy_device API change
  bonding: Prevent IPv6 link local address on enslaved devices
  IB/mlx5: Add flow steering support
  net/mlx5_core: Export flow steering API
  net/mlx5_core: Make ipv4/ipv6 location more clear
  net/mlx5_core: Enable flow steering support for the IB driver
  net/mlx5_core: Initialize namespaces only when supported by device
  net/mlx5_core: Set priority attributes
  net/mlx5_core: Connect flow tables
  net/mlx5_core: Introduce modify flow table command
  net/mlx5_core: Managing root flow table
  ...

133 files changed, 2341 insertions, 562 deletions

diff --git a/include/linux/brcmphy.h b/include/linux/brcmphy.h
index 59f4a7304419..f0ba9c2ec639 100644
--- a/include/linux/brcmphy.h
+++ b/include/linux/brcmphy.h
@@ -26,6 +26,7 @@
 #define PHY_ID_BCM7366                  0x600d8490
 #define PHY_ID_BCM7425                  0x600d86b0
 #define PHY_ID_BCM7429                  0x600d8730
+#define PHY_ID_BCM7435                  0x600d8750
 #define PHY_ID_BCM7439                  0x600d8480
 #define PHY_ID_BCM7439_2                0xae025080
 #define PHY_ID_BCM7445                  0x600d8510
diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h
index 06b77f9dd3f2..e5f4164cbd99 100644
--- a/include/linux/cgroup-defs.h
+++ b/include/linux/cgroup-defs.h
@@ -231,6 +231,14 @@ struct cgroup {
         int id;
 
         /*
+         * The depth this cgroup is at.  The root is at depth zero and each
+         * step down the hierarchy increments the level.  This along with
+         * ancestor_ids[] can determine whether a given cgroup is a
+         * descendant of another without traversing the hierarchy.
+         */
+        int level;
+
+        /*
          * Each non-empty css_set associated with this cgroup contributes
          * one to populated_cnt.  All children with non-zero popuplated_cnt
          * of their own contribute one.  The count is zero iff there's no
@@ -285,6 +293,9 @@ struct cgroup {
 
         /* used to schedule release agent */
         struct work_struct release_agent_work;
+
+        /* ids of the ancestors at each level including self */
+        int ancestor_ids[];
 };
 
 /*
@@ -304,6 +315,9 @@ struct cgroup_root {
         /* The root cgroup.  Root is destroyed on its release. */
         struct cgroup cgrp;
 
+        /* for cgrp->ancestor_ids[0] */
+        int cgrp_ancestor_id_storage;
+
         /* Number of cgroups in the hierarchy, used only for /proc/cgroups */
         atomic_t nr_cgrps;
 
@@ -521,4 +535,116 @@ static inline void cgroup_threadgroup_change_end(struct task_struct *tsk) {}
 
 #endif  /* CONFIG_CGROUPS */
 
+#ifdef CONFIG_SOCK_CGROUP_DATA
+
+/*
+ * sock_cgroup_data is embedded at sock->sk_cgrp_data and contains
+ * per-socket cgroup information except for memcg association.
+ *
+ * On legacy hierarchies, net_prio and net_cls controllers directly set
+ * attributes on each sock which can then be tested by the network layer.
+ * On the default hierarchy, each sock is associated with the cgroup it was
+ * created in and the networking layer can match the cgroup directly.
+ *
+ * To avoid carrying all three cgroup related fields separately in sock,
+ * sock_cgroup_data overloads (prioidx, classid) and the cgroup pointer.
+ * On boot, sock_cgroup_data records the cgroup that the sock was created
+ * in so that cgroup2 matches can be made; however, once either net_prio or
+ * net_cls starts being used, the area is overriden to carry prioidx and/or
+ * classid.  The two modes are distinguished by whether the lowest bit is
+ * set.  Clear bit indicates cgroup pointer while set bit prioidx and
+ * classid.
+ *
+ * While userland may start using net_prio or net_cls at any time, once
+ * either is used, cgroup2 matching no longer works.  There is no reason to
+ * mix the two and this is in line with how legacy and v2 compatibility is
+ * handled.  On mode switch, cgroup references which are already being
+ * pointed to by socks may be leaked.  While this can be remedied by adding
+ * synchronization around sock_cgroup_data, given that the number of leaked
+ * cgroups is bound and highly unlikely to be high, this seems to be the
+ * better trade-off.
+ */
+struct sock_cgroup_data {
+        union {
+#ifdef __LITTLE_ENDIAN
+                struct {
+                        u8      is_data;
+                        u8      padding;
+                        u16     prioidx;
+                        u32     classid;
+                } __packed;
+#else
+                struct {
+                        u32     classid;
+                        u16     prioidx;
+                        u8      padding;
+                        u8      is_data;
+                } __packed;
+#endif
+                u64             val;
+        };
+};
+
+/*
+ * There's a theoretical window where the following accessors race with
+ * updaters and return part of the previous pointer as the prioidx or
+ * classid.  Such races are short-lived and the result isn't critical.
+ */
+static inline u16 sock_cgroup_prioidx(struct sock_cgroup_data *skcd)
+{
+        /* fallback to 1 which is always the ID of the root cgroup */
+        return (skcd->is_data & 1) ? skcd->prioidx : 1;
+}
+
+static inline u32 sock_cgroup_classid(struct sock_cgroup_data *skcd)
+{
+        /* fallback to 0 which is the unconfigured default classid */
+        return (skcd->is_data & 1) ? skcd->classid : 0;
+}
+
+/*
+ * If invoked concurrently, the updaters may clobber each other.  The
+ * caller is responsible for synchronization.
+ */
+static inline void sock_cgroup_set_prioidx(struct sock_cgroup_data *skcd,
+                                           u16 prioidx)
+{
+        struct sock_cgroup_data skcd_buf = {{ .val = READ_ONCE(skcd->val) }};
+
+        if (sock_cgroup_prioidx(&skcd_buf) == prioidx)
+                return;
+
+        if (!(skcd_buf.is_data & 1)) {
+                skcd_buf.val = 0;
+                skcd_buf.is_data = 1;
+        }
+
+        skcd_buf.prioidx = prioidx;
+        WRITE_ONCE(skcd->val, skcd_buf.val);    /* see sock_cgroup_ptr() */
+}
+
+static inline void sock_cgroup_set_classid(struct sock_cgroup_data *skcd,
+                                           u32 classid)
+{
+        struct sock_cgroup_data skcd_buf = {{ .val = READ_ONCE(skcd->val) }};
+
+        if (sock_cgroup_classid(&skcd_buf) == classid)
+                return;
+
+        if (!(skcd_buf.is_data & 1)) {
+                skcd_buf.val = 0;
+                skcd_buf.is_data = 1;
+        }
+
+        skcd_buf.classid = classid;
+        WRITE_ONCE(skcd->val, skcd_buf.val);    /* see sock_cgroup_ptr() */
+}
+
+#else   /* CONFIG_SOCK_CGROUP_DATA */
+
+struct sock_cgroup_data {
+};
+
+#endif  /* CONFIG_SOCK_CGROUP_DATA */
+
 #endif  /* _LINUX_CGROUP_DEFS_H */
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index cb91b44f5f78..322a28482745 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -81,7 +81,8 @@ struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgroup,
 struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
                                                        struct cgroup_subsys *ss);
 
-bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);
+struct cgroup *cgroup_get_from_path(const char *path);
+
 int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
 int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
 
@@ -364,6 +365,11 @@ static inline void css_put_many(struct cgroup_subsys_state *css, unsigned int n)
                 percpu_ref_put_many(&css->refcnt, n);
 }
 
+static inline void cgroup_put(struct cgroup *cgrp)
+{
+        css_put(&cgrp->self);
+}
+
 /**
  * task_css_set_check - obtain a task's css_set with extra access conditions
  * @task: the task to obtain css_set for
@@ -471,6 +477,23 @@ static inline struct cgroup *task_cgroup(struct task_struct *task,
         return task_css(task, subsys_id)->cgroup;
 }
 
+/**
+ * cgroup_is_descendant - test ancestry
+ * @cgrp: the cgroup to be tested
+ * @ancestor: possible ancestor of @cgrp
+ *
+ * Test whether @cgrp is a descendant of @ancestor.  It also returns %true
+ * if @cgrp == @ancestor.  This function is safe to call as long as @cgrp
+ * and @ancestor are accessible.
+ */
+static inline bool cgroup_is_descendant(struct cgroup *cgrp,
+                                        struct cgroup *ancestor)
+{
+        if (cgrp->root != ancestor->root || cgrp->level < ancestor->level)
+                return false;
+        return cgrp->ancestor_ids[ancestor->level] == ancestor->id;
+}
+
 /* no synchronization, the result can only be used as a hint */
 static inline bool cgroup_is_populated(struct cgroup *cgrp)
 {
@@ -554,4 +577,45 @@ static inline int cgroup_init(void) { return 0; }
 
 #endif /* !CONFIG_CGROUPS */
 
+/*
+ * sock->sk_cgrp_data handling.  For more info, see sock_cgroup_data
+ * definition in cgroup-defs.h.
+ */
+#ifdef CONFIG_SOCK_CGROUP_DATA
+
+#if defined(CONFIG_CGROUP_NET_PRIO) || defined(CONFIG_CGROUP_NET_CLASSID)
+extern spinlock_t cgroup_sk_update_lock;
+#endif
+
+void cgroup_sk_alloc_disable(void);
+void cgroup_sk_alloc(struct sock_cgroup_data *skcd);
+void cgroup_sk_free(struct sock_cgroup_data *skcd);
+
+static inline struct cgroup *sock_cgroup_ptr(struct sock_cgroup_data *skcd)
+{
+#if defined(CONFIG_CGROUP_NET_PRIO) || defined(CONFIG_CGROUP_NET_CLASSID)
+        unsigned long v;
+
+        /*
+         * @skcd->val is 64bit but the following is safe on 32bit too as we
+         * just need the lower ulong to be written and read atomically.
+         */
+        v = READ_ONCE(skcd->val);
+
+        if (v & 1)
+                return &cgrp_dfl_root.cgrp;
+
+        return (struct cgroup *)(unsigned long)v ?: &cgrp_dfl_root.cgrp;
+#else
+        return (struct cgroup *)(unsigned long)skcd->val;
+#endif
+}
+
+#else   /* CONFIG_CGROUP_DATA */
+
+static inline void cgroup_sk_alloc(struct sock_cgroup_data *skcd) {}
+static inline void cgroup_sk_free(struct sock_cgroup_data *skcd) {}
+
+#endif  /* CONFIG_CGROUP_DATA */
+
 #endif /* _LINUX_CGROUP_H */
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index eb049c622208..37ff4a6faa9a 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -29,6 +29,9 @@
 #include <asm/bitsperlong.h>
 
 #ifdef __KERNEL__
+struct device;
+int eth_platform_get_mac_address(struct device *dev, u8 *mac_addr);
+unsigned char *arch_get_platform_get_mac_address(void);
 u32 eth_get_headlen(void *data, unsigned int max_len);
 __be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev);
 extern const struct header_ops eth_header_ops;
diff --git a/include/linux/filter.h b/include/linux/filter.h
index 5972ffe5719a..43aa1f8855c7 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -350,25 +350,43 @@ struct sk_filter {
 
 #define BPF_PROG_RUN(filter, ctx)  (*filter->bpf_func)(ctx, filter->insnsi)
 
+#define BPF_SKB_CB_LEN QDISC_CB_PRIV_LEN
+
+static inline u8 *bpf_skb_cb(struct sk_buff *skb)
+{
+        /* eBPF programs may read/write skb->cb[] area to transfer meta
+         * data between tail calls. Since this also needs to work with
+         * tc, that scratch memory is mapped to qdisc_skb_cb's data area.
+         *
+         * In some socket filter cases, the cb unfortunately needs to be
+         * saved/restored so that protocol specific skb->cb[] data won't
+         * be lost. In any case, due to unpriviledged eBPF programs
+         * attached to sockets, we need to clear the bpf_skb_cb() area
+         * to not leak previous contents to user space.
+         */
+        BUILD_BUG_ON(FIELD_SIZEOF(struct __sk_buff, cb) != BPF_SKB_CB_LEN);
+        BUILD_BUG_ON(FIELD_SIZEOF(struct __sk_buff, cb) !=
+                     FIELD_SIZEOF(struct qdisc_skb_cb, data));
+
+        return qdisc_skb_cb(skb)->data;
+}
+
 static inline u32 bpf_prog_run_save_cb(const struct bpf_prog *prog,
                                        struct sk_buff *skb)
 {
-        u8 *cb_data = qdisc_skb_cb(skb)->data;
-        u8 saved_cb[QDISC_CB_PRIV_LEN];
+        u8 *cb_data = bpf_skb_cb(skb);
+        u8 cb_saved[BPF_SKB_CB_LEN];
         u32 res;
 
-        BUILD_BUG_ON(FIELD_SIZEOF(struct __sk_buff, cb) !=
-                     QDISC_CB_PRIV_LEN);
-
         if (unlikely(prog->cb_access)) {
-                memcpy(saved_cb, cb_data, sizeof(saved_cb));
-                memset(cb_data, 0, sizeof(saved_cb));
+                memcpy(cb_saved, cb_data, sizeof(cb_saved));
+                memset(cb_data, 0, sizeof(cb_saved));
         }
 
         res = BPF_PROG_RUN(prog, skb);
 
         if (unlikely(prog->cb_access))
-                memcpy(cb_data, saved_cb, sizeof(saved_cb));
+                memcpy(cb_data, cb_saved, sizeof(cb_saved));
 
         return res;
 }
@@ -376,10 +394,11 @@ static inline u32 bpf_prog_run_save_cb(const struct bpf_prog *prog,
 static inline u32 bpf_prog_run_clear_cb(const struct bpf_prog *prog,
                                         struct sk_buff *skb)
 {
-        u8 *cb_data = qdisc_skb_cb(skb)->data;
+        u8 *cb_data = bpf_skb_cb(skb);
 
         if (unlikely(prog->cb_access))
-                memset(cb_data, 0, QDISC_CB_PRIV_LEN);
+                memset(cb_data, 0, BPF_SKB_CB_LEN);
+
         return BPF_PROG_RUN(prog, skb);
 }
 
@@ -447,6 +466,8 @@ void bpf_prog_destroy(struct bpf_prog *fp);
 
 int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
 int sk_attach_bpf(u32 ufd, struct sock *sk);
+int sk_reuseport_attach_filter(struct sock_fprog *fprog, struct sock *sk);
+int sk_reuseport_attach_bpf(u32 ufd, struct sock *sk);
 int sk_detach_filter(struct sock *sk);
 int sk_get_filter(struct sock *sk, struct sock_filter __user *filter,
                   unsigned int len);
diff --git a/include/linux/hashtable.h b/include/linux/hashtable.h
index 519b6e2d769e..661e5c2a8e2a 100644
--- a/include/linux/hashtable.h
+++ b/include/linux/hashtable.h
@@ -16,6 +16,10 @@
         struct hlist_head name[1 << (bits)] =                                   \
                         { [0 ... ((1 << (bits)) - 1)] = HLIST_HEAD_INIT }
 
+#define DEFINE_READ_MOSTLY_HASHTABLE(name, bits)                                \
+        struct hlist_head name[1 << (bits)] __read_mostly =                     \
+                        { [0 ... ((1 << (bits)) - 1)] = HLIST_HEAD_INIT }
+
 #define DECLARE_HASHTABLE(name, bits)                                           \
         struct hlist_head name[1 << (bits)]
 
diff --git a/include/linux/hdlc.h b/include/linux/hdlc.h
index 1acb1445e05f..e31bcd4c7859 100644
--- a/include/linux/hdlc.h
+++ b/include/linux/hdlc.h
@@ -101,7 +101,7 @@ netdev_tx_t hdlc_start_xmit(struct sk_buff *skb, struct net_device *dev);
 int attach_hdlc_protocol(struct net_device *dev, struct hdlc_proto *proto,
                          size_t size);
 /* May be used by hardware driver to gain control over HDLC device */
-void detach_hdlc_protocol(struct net_device *dev);
+int detach_hdlc_protocol(struct net_device *dev);
 
 static __inline__ __be16 hdlc_type_trans(struct sk_buff *skb,
                                          struct net_device *dev)
diff --git a/include/linux/if_pppox.h b/include/linux/if_pppox.h
index b49cf923becc..ba7a9b0c7c57 100644
--- a/include/linux/if_pppox.h
+++ b/include/linux/if_pppox.h
@@ -91,7 +91,6 @@ enum {
     PPPOX_CONNECTED     = 1,  /* connection established ==TCP_ESTABLISHED */
     PPPOX_BOUND         = 2,  /* bound to ppp device */
     PPPOX_RELAY         = 4,  /* forwarding is enabled */
-    PPPOX_ZOMBIE        = 8,  /* dead, but still bound to ppp device */
     PPPOX_DEAD          = 16  /* dead, useless, please clean me up!*/
 };
 
diff --git a/include/linux/if_team.h b/include/linux/if_team.h
index a6aa970758a2..b84e49c3a738 100644
--- a/include/linux/if_team.h
+++ b/include/linux/if_team.h
@@ -164,6 +164,7 @@ struct team_mode {
         size_t priv_size;
         size_t port_priv_size;
         const struct team_mode_ops *ops;
+        enum netdev_lag_tx_type lag_tx_type;
 };
 
 #define TEAM_PORT_HASHBITS 4
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index 67ce5bd3b56a..a5f6ce6b578c 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -73,7 +73,7 @@ static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb)
 /* found in socket.c */
 extern void vlan_ioctl_set(int (*hook)(struct net *, void __user *));
 
-static inline bool is_vlan_dev(struct net_device *dev)
+static inline bool is_vlan_dev(const struct net_device *dev)
 {
         return dev->priv_flags & IFF_802_1Q_VLAN;
 }
@@ -621,7 +621,7 @@ static inline netdev_features_t vlan_features_check(const struct sk_buff *skb,
                                                      NETIF_F_SG |
                                                      NETIF_F_HIGHDMA |
                                                      NETIF_F_FRAGLIST |
-                                                     NETIF_F_GEN_CSUM |
+                                                     NETIF_F_HW_CSUM |
                                                      NETIF_F_HW_VLAN_CTAG_TX |
                                                      NETIF_F_HW_VLAN_STAG_TX);
 
diff --git a/include/linux/inet_diag.h b/include/linux/inet_diag.h
index 0e707f0c1a3e..7c27fa1030e8 100644
--- a/include/linux/inet_diag.h
+++ b/include/linux/inet_diag.h
@@ -3,6 +3,7 @@
 
 #include <uapi/linux/inet_diag.h>
 
+struct net;
 struct sock;
 struct inet_hashinfo;
 struct nlattr;
@@ -23,6 +24,10 @@ struct inet_diag_handler {
         void            (*idiag_get_info)(struct sock *sk,
                                           struct inet_diag_msg *r,
                                           void *info);
+
+        int             (*destroy)(struct sk_buff *in_skb,
+                                   const struct inet_diag_req_v2 *req);
+
         __u16           idiag_type;
         __u16           idiag_info_size;
 };
@@ -41,6 +46,10 @@ int inet_diag_dump_one_icsk(struct inet_hashinfo *hashinfo,
                             struct sk_buff *in_skb, const struct nlmsghdr *nlh,
                             const struct inet_diag_req_v2 *req);
 
+struct sock *inet_diag_find_one_icsk(struct net *net,
+                                     struct inet_hashinfo *hashinfo,
+                                     const struct inet_diag_req_v2 *req);
+
 int inet_diag_bc_sk(const struct nlattr *_bc, struct sock *sk);
 
 extern int  inet_diag_register(const struct inet_diag_handler *handler);
diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h
index 5d4e9c4b821d..af51df35d749 100644
--- a/include/linux/kernfs.h
+++ b/include/linux/kernfs.h
@@ -274,6 +274,8 @@ void pr_cont_kernfs_path(struct kernfs_node *kn);
 struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn);
 struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
                                            const char *name, const void *ns);
+struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent,
+                                           const char *path, const void *ns);
 void kernfs_get(struct kernfs_node *kn);
 void kernfs_put(struct kernfs_node *kn);
 
@@ -350,6 +352,10 @@ static inline struct kernfs_node *
 kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name,
                        const void *ns)
 { return NULL; }
+static inline struct kernfs_node *
+kernfs_walk_and_get_ns(struct kernfs_node *parent, const char *path,
+                       const void *ns)
+{ return NULL; }
 
 static inline void kernfs_get(struct kernfs_node *kn) { }
 static inline void kernfs_put(struct kernfs_node *kn) { }
@@ -431,6 +437,12 @@ kernfs_find_and_get(struct kernfs_node *kn, const char *name)
 }
 
 static inline struct kernfs_node *
+kernfs_walk_and_get(struct kernfs_node *kn, const char *path)
+{
+        return kernfs_walk_and_get_ns(kn, path, NULL);
+}
+
+static inline struct kernfs_node *
 kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode,
                   void *priv)
 {
diff --git a/include/linux/mdio.h b/include/linux/mdio.h
index b42963bc81dd..5bfd99d1a40a 100644
--- a/include/linux/mdio.h
+++ b/include/linux/mdio.h
@@ -11,6 +11,55 @@
 
 #include <uapi/linux/mdio.h>
 
+struct mii_bus;
+
+struct mdio_device {
+        struct device dev;
+
+        const struct dev_pm_ops *pm_ops;
+        struct mii_bus *bus;
+
+        int (*bus_match)(struct device *dev, struct device_driver *drv);
+        void (*device_free)(struct mdio_device *mdiodev);
+        void (*device_remove)(struct mdio_device *mdiodev);
+
+        /* Bus address of the MDIO device (0-31) */
+        int addr;
+        int flags;
+};
+#define to_mdio_device(d) container_of(d, struct mdio_device, dev)
+
+/* struct mdio_driver_common: Common to all MDIO drivers */
+struct mdio_driver_common {
+        struct device_driver driver;
+        int flags;
+};
+#define MDIO_DEVICE_FLAG_PHY            1
+#define to_mdio_common_driver(d) \
+        container_of(d, struct mdio_driver_common, driver)
+
+/* struct mdio_driver: Generic MDIO driver */
+struct mdio_driver {
+        struct mdio_driver_common mdiodrv;
+
+        /*
+         * Called during discovery.  Used to set
+         * up device-specific structures, if any
+         */
+        int (*probe)(struct mdio_device *mdiodev);
+
+        /* Clears up any memory if needed */
+        void (*remove)(struct mdio_device *mdiodev);
+};
+#define to_mdio_driver(d)                                               \
+        container_of(to_mdio_common_driver(d), struct mdio_driver, mdiodrv)
+
+void mdio_device_free(struct mdio_device *mdiodev);
+struct mdio_device *mdio_device_create(struct mii_bus *bus, int addr);
+int mdio_device_register(struct mdio_device *mdiodev);
+void mdio_device_remove(struct mdio_device *mdiodev);
+int mdio_driver_register(struct mdio_driver *drv);
+void mdio_driver_unregister(struct mdio_driver *drv);
 
 static inline bool mdio_phy_id_is_c45(int phy_id)
 {
@@ -173,4 +222,33 @@ static inline u16 ethtool_adv_to_mmd_eee_adv_t(u32 adv)
         return reg;
 }
 
+int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum);
+int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum);
+int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val);
+int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val);
+
+int mdiobus_register_device(struct mdio_device *mdiodev);
+int mdiobus_unregister_device(struct mdio_device *mdiodev);
+bool mdiobus_is_registered_device(struct mii_bus *bus, int addr);
+struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr);
+
+/**
+ * module_mdio_driver() - Helper macro for registering mdio drivers
+ *
+ * Helper macro for MDIO drivers which do not do anything special in module
+ * init/exit. Each module may only use this macro once, and calling it
+ * replaces module_init() and module_exit().
+ */
+#define mdio_module_driver(_mdio_driver)                                \
+static int __init mdio_module_init(void)                                \
+{                                                                       \
+        return mdio_driver_register(&_mdio_driver);                     \
+}                                                                       \
+module_init(mdio_module_init);                                          \
+static void __exit mdio_module_exit(void)                               \
+{                                                                       \
+        mdio_driver_unregister(&_mdio_driver);                          \
+}                                                                       \
+module_exit(mdio_module_exit)
+
 #endif /* __LINUX_MDIO_H__ */
diff --git a/include/linux/mlx4/driver.h b/include/linux/mlx4/driver.h
index 5a06d969338e..2e8af001c5da 100644
--- a/include/linux/mlx4/driver.h
+++ b/include/linux/mlx4/driver.h
@@ -75,6 +75,11 @@ static inline int mlx4_is_bonded(struct mlx4_dev *dev)
         return !!(dev->flags & MLX4_FLAG_BONDED);
 }
 
+static inline int mlx4_is_mf_bonded(struct mlx4_dev *dev)
+{
+        return (mlx4_is_bonded(dev) && mlx4_is_mfunc(dev));
+}
+
 struct mlx4_port_map {
         u8      port1;
         u8      port2;
diff --git a/include/linux/mlx5/device.h b/include/linux/mlx5/device.h
index 0b473cbfa7ef..7be845e30689 100644
--- a/include/linux/mlx5/device.h
+++ b/include/linux/mlx5/device.h
@@ -251,6 +251,7 @@ enum mlx5_event {
         MLX5_EVENT_TYPE_PAGE_REQUEST       = 0xb,
 
         MLX5_EVENT_TYPE_PAGE_FAULT         = 0xc,
+        MLX5_EVENT_TYPE_NIC_VPORT_CHANGE   = 0xd,
 };
 
 enum {
@@ -442,9 +443,12 @@ struct mlx5_init_seg {
         __be32                  rsvd1[120];
         __be32                  initializing;
         struct health_buffer    health;
-        __be32                  rsvd2[884];
+        __be32                  rsvd2[880];
+        __be32                  internal_timer_h;
+        __be32                  internal_timer_l;
+        __be32                  rsrv3[2];
         __be32                  health_counter;
-        __be32                  rsvd3[1019];
+        __be32                  rsvd4[1019];
         __be64                  ieee1588_clk;
         __be32                  ieee1588_clk_type;
         __be32                  clr_intx;
@@ -520,6 +524,12 @@ struct mlx5_eqe_page_fault {
         __be32 flags_qpn;
 } __packed;
 
+struct mlx5_eqe_vport_change {
+        u8              rsvd0[2];
+        __be16          vport_num;
+        __be32          rsvd1[6];
+} __packed;
+
 union ev_data {
         __be32                          raw[7];
         struct mlx5_eqe_cmd             cmd;
@@ -532,6 +542,7 @@ union ev_data {
         struct mlx5_eqe_stall_vl        stall_vl;
         struct mlx5_eqe_page_req        req_pages;
         struct mlx5_eqe_page_fault      page_fault;
+        struct mlx5_eqe_vport_change    vport_change;
 } __packed;
 
 struct mlx5_eqe {
@@ -593,7 +604,8 @@ struct mlx5_cqe64 {
         __be32          imm_inval_pkey;
         u8              rsvd40[4];
         __be32          byte_cnt;
-        __be64          timestamp;
+        __be32          timestamp_h;
+        __be32          timestamp_l;
         __be32          sop_drop_qpn;
         __be16          wqe_counter;
         u8              signature;
@@ -615,6 +627,16 @@ static inline int cqe_has_vlan(struct mlx5_cqe64 *cqe)
         return !!(cqe->l4_hdr_type_etc & 0x1);
 }
 
+static inline u64 get_cqe_ts(struct mlx5_cqe64 *cqe)
+{
+        u32 hi, lo;
+
+        hi = be32_to_cpu(cqe->timestamp_h);
+        lo = be32_to_cpu(cqe->timestamp_l);
+
+        return (u64)lo | ((u64)hi << 32);
+}
+
 enum {
         CQE_L4_HDR_TYPE_NONE                    = 0x0,
         CQE_L4_HDR_TYPE_TCP_NO_ACK              = 0x1,
@@ -1067,6 +1089,12 @@ enum {
 };
 
 enum {
+        MLX5_ESW_VPORT_ADMIN_STATE_DOWN  = 0x0,
+        MLX5_ESW_VPORT_ADMIN_STATE_UP    = 0x1,
+        MLX5_ESW_VPORT_ADMIN_STATE_AUTO  = 0x2,
+};
+
+enum {
         MLX5_L3_PROT_TYPE_IPV4          = 0,
         MLX5_L3_PROT_TYPE_IPV6          = 1,
 };
@@ -1102,6 +1130,12 @@ enum {
         MLX5_FLOW_CONTEXT_DEST_TYPE_TIR         = 2,
 };
 
+enum mlx5_list_type {
+        MLX5_NVPRT_LIST_TYPE_UC   = 0x0,
+        MLX5_NVPRT_LIST_TYPE_MC   = 0x1,
+        MLX5_NVPRT_LIST_TYPE_VLAN = 0x2,
+};
+
 enum {
         MLX5_RQC_RQ_TYPE_MEMORY_RQ_INLINE = 0x0,
         MLX5_RQC_RQ_TYPE_MEMORY_RQ_RPM    = 0x1,
@@ -1124,6 +1158,8 @@ enum mlx5_cap_type {
         MLX5_CAP_IPOIB_OFFLOADS,
         MLX5_CAP_EOIB_OFFLOADS,
         MLX5_CAP_FLOW_TABLE,
+        MLX5_CAP_ESWITCH_FLOW_TABLE,
+        MLX5_CAP_ESWITCH,
         /* NUM OF CAP Types */
         MLX5_CAP_NUM
 };
@@ -1161,6 +1197,28 @@ enum mlx5_cap_type {
 #define MLX5_CAP_FLOWTABLE_MAX(mdev, cap) \
         MLX5_GET(flow_table_nic_cap, mdev->hca_caps_max[MLX5_CAP_FLOW_TABLE], cap)
 
+#define MLX5_CAP_ESW_FLOWTABLE(mdev, cap) \
+        MLX5_GET(flow_table_eswitch_cap, \
+                 mdev->hca_caps_cur[MLX5_CAP_ESWITCH_FLOW_TABLE], cap)
+
+#define MLX5_CAP_ESW_FLOWTABLE_MAX(mdev, cap) \
+        MLX5_GET(flow_table_eswitch_cap, \
+                 mdev->hca_caps_max[MLX5_CAP_ESWITCH_FLOW_TABLE], cap)
+
+#define MLX5_CAP_ESW_FLOWTABLE_FDB(mdev, cap) \
+        MLX5_CAP_ESW_FLOWTABLE(mdev, flow_table_properties_nic_esw_fdb.cap)
+
+#define MLX5_CAP_ESW_FLOWTABLE_FDB_MAX(mdev, cap) \
+        MLX5_CAP_ESW_FLOWTABLE_MAX(mdev, flow_table_properties_nic_esw_fdb.cap)
+
+#define MLX5_CAP_ESW(mdev, cap) \
+        MLX5_GET(e_switch_cap, \
+                 mdev->hca_caps_cur[MLX5_CAP_ESWITCH], cap)
+
+#define MLX5_CAP_ESW_MAX(mdev, cap) \
+        MLX5_GET(e_switch_cap, \
+                 mdev->hca_caps_max[MLX5_CAP_ESWITCH], cap)
+
 #define MLX5_CAP_ODP(mdev, cap)\
         MLX5_GET(odp_cap, mdev->hca_caps_cur[MLX5_CAP_ODP], cap)
 
@@ -1200,4 +1258,6 @@ static inline u16 mlx5_to_sw_pkey_sz(int pkey_sz)
         return MLX5_MIN_PKEY_TABLE_SIZE << pkey_sz;
 }
 
+#define MLX5_BY_PASS_NUM_PRIOS 9
+
 #endif /* MLX5_DEVICE_H */
diff --git a/include/linux/mlx5/driver.h b/include/linux/mlx5/driver.h
index 5c857f2a20d7..2fd7019f69db 100644
--- a/include/linux/mlx5/driver.h
+++ b/include/linux/mlx5/driver.h
@@ -426,11 +426,23 @@ struct mlx5_mr_table {
         struct radix_tree_root  tree;
 };
 
+struct mlx5_vf_context {
+        int     enabled;
+};
+
+struct mlx5_core_sriov {
+        struct mlx5_vf_context  *vfs_ctx;
+        int                     num_vfs;
+        int                     enabled_vfs;
+};
+
 struct mlx5_irq_info {
         cpumask_var_t mask;
         char name[MLX5_MAX_IRQ_NAME];
 };
 
+struct mlx5_eswitch;
+
 struct mlx5_priv {
         char                    name[MLX5_MAX_NAME_LEN];
         struct mlx5_eq_table    eq_table;
@@ -447,6 +459,7 @@ struct mlx5_priv {
         int                     fw_pages;
         atomic_t                reg_pages;
         struct list_head        free_list;
+        int                     vfs_pages;
 
         struct mlx5_core_health health;
 
@@ -485,6 +498,12 @@ struct mlx5_priv {
         struct list_head        dev_list;
         struct list_head        ctx_list;
         spinlock_t              ctx_lock;
+
+        struct mlx5_eswitch     *eswitch;
+        struct mlx5_core_sriov  sriov;
+        unsigned long           pci_dev_data;
+        struct mlx5_flow_root_namespace *root_ns;
+        struct mlx5_flow_root_namespace *fdb_root_ns;
 };
 
 enum mlx5_device_state {
@@ -739,6 +758,8 @@ void mlx5_pagealloc_init(struct mlx5_core_dev *dev);
 void mlx5_pagealloc_cleanup(struct mlx5_core_dev *dev);
 int mlx5_pagealloc_start(struct mlx5_core_dev *dev);
 void mlx5_pagealloc_stop(struct mlx5_core_dev *dev);
+int mlx5_sriov_init(struct mlx5_core_dev *dev);
+int mlx5_sriov_cleanup(struct mlx5_core_dev *dev);
 void mlx5_core_req_pages_handler(struct mlx5_core_dev *dev, u16 func_id,
                                  s32 npages);
 int mlx5_satisfy_startup_pages(struct mlx5_core_dev *dev, int boot);
@@ -884,6 +905,15 @@ struct mlx5_profile {
         } mr_cache[MAX_MR_CACHE_ENTRIES];
 };
 
+enum {
+        MLX5_PCI_DEV_IS_VF              = 1 << 0,
+};
+
+static inline int mlx5_core_is_pf(struct mlx5_core_dev *dev)
+{
+        return !(dev->priv.pci_dev_data & MLX5_PCI_DEV_IS_VF);
+}
+
 static inline int mlx5_get_gid_table_len(u16 param)
 {
         if (param > 4) {
diff --git a/include/linux/mlx5/flow_table.h b/include/linux/mlx5/flow_table.h
deleted file mode 100644
index 5f922c6d4fc2..000000000000
--- a/include/linux/mlx5/flow_table.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2013-2015, Mellanox Technologies, Ltd.  All rights reserved.
- *
- * This software is available to you under a choice of one of two
- * licenses.  You may choose to be licensed under the terms of the GNU
- * General Public License (GPL) Version 2, available from the file
- * COPYING in the main directory of this source tree, or the
- * OpenIB.org BSD license below:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      - Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer.
- *
- *      - Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#ifndef MLX5_FLOW_TABLE_H
-#define MLX5_FLOW_TABLE_H
-
-#include <linux/mlx5/driver.h>
-
-struct mlx5_flow_table_group {
-        u8      log_sz;
-        u8      match_criteria_enable;
-        u32     match_criteria[MLX5_ST_SZ_DW(fte_match_param)];
-};
-
-void *mlx5_create_flow_table(struct mlx5_core_dev *dev, u8 level, u8 table_type,
-                             u16 num_groups,
-                             struct mlx5_flow_table_group *group);
-void mlx5_destroy_flow_table(void *flow_table);
-int mlx5_add_flow_table_entry(void *flow_table, u8 match_criteria_enable,
-                              void *match_criteria, void *flow_context,
-                              u32 *flow_index);
-void mlx5_del_flow_table_entry(void *flow_table, u32 flow_index);
-u32 mlx5_get_flow_table_id(void *flow_table);
-
-#endif /* MLX5_FLOW_TABLE_H */
diff --git a/include/linux/mlx5/fs.h b/include/linux/mlx5/fs.h
new file mode 100644
index 000000000000..8230caa3fb6e
--- /dev/null
+++ b/include/linux/mlx5/fs.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2015, Mellanox Technologies. All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _MLX5_FS_
+#define _MLX5_FS_
+
+#include <linux/mlx5/driver.h>
+#include <linux/mlx5/mlx5_ifc.h>
+
+#define MLX5_FS_DEFAULT_FLOW_TAG 0x0
+
+#define LEFTOVERS_RULE_NUM       2
+static inline void build_leftovers_ft_param(int *priority,
+                                            int *n_ent,
+                                            int *n_grp)
+{
+        *priority = 0; /* Priority of leftovers_prio-0 */
+        *n_ent = LEFTOVERS_RULE_NUM;
+        *n_grp = LEFTOVERS_RULE_NUM;
+}
+
+enum mlx5_flow_namespace_type {
+        MLX5_FLOW_NAMESPACE_BYPASS,
+        MLX5_FLOW_NAMESPACE_KERNEL,
+        MLX5_FLOW_NAMESPACE_LEFTOVERS,
+        MLX5_FLOW_NAMESPACE_FDB,
+};
+
+struct mlx5_flow_table;
+struct mlx5_flow_group;
+struct mlx5_flow_rule;
+struct mlx5_flow_namespace;
+
+struct mlx5_flow_destination {
+        enum mlx5_flow_destination_type type;
+        union {
+                u32                     tir_num;
+                struct mlx5_flow_table  *ft;
+                u32                     vport_num;
+        };
+};
+
+struct mlx5_flow_namespace *
+mlx5_get_flow_namespace(struct mlx5_core_dev *dev,
+                        enum mlx5_flow_namespace_type type);
+
+struct mlx5_flow_table *
+mlx5_create_auto_grouped_flow_table(struct mlx5_flow_namespace *ns,
+                                    int prio,
+                                    int num_flow_table_entries,
+                                    int max_num_groups);
+
+struct mlx5_flow_table *
+mlx5_create_flow_table(struct mlx5_flow_namespace *ns,
+                       int prio,
+                       int num_flow_table_entries);
+int mlx5_destroy_flow_table(struct mlx5_flow_table *ft);
+
+/* inbox should be set with the following values:
+ * start_flow_index
+ * end_flow_index
+ * match_criteria_enable
+ * match_criteria
+ */
+struct mlx5_flow_group *
+mlx5_create_flow_group(struct mlx5_flow_table *ft, u32 *in);
+void mlx5_destroy_flow_group(struct mlx5_flow_group *fg);
+
+/* Single destination per rule.
+ * Group ID is implied by the match criteria.
+ */
+struct mlx5_flow_rule *
+mlx5_add_flow_rule(struct mlx5_flow_table *ft,
+                   u8 match_criteria_enable,
+                   u32 *match_criteria,
+                   u32 *match_value,
+                   u32 action,
+                   u32 flow_tag,
+                   struct mlx5_flow_destination *dest);
+void mlx5_del_flow_rule(struct mlx5_flow_rule *fr);
+
+#endif
diff --git a/include/linux/mlx5/mlx5_ifc.h b/include/linux/mlx5/mlx5_ifc.h
index 1565324eb620..68d73f82e009 100644
--- a/include/linux/mlx5/mlx5_ifc.h
+++ b/include/linux/mlx5/mlx5_ifc.h
@@ -185,6 +185,7 @@ enum {
         MLX5_CMD_OP_MODIFY_RQT                    = 0x917,
         MLX5_CMD_OP_DESTROY_RQT                   = 0x918,
         MLX5_CMD_OP_QUERY_RQT                     = 0x919,
+        MLX5_CMD_OP_SET_FLOW_TABLE_ROOT           = 0x92f,
         MLX5_CMD_OP_CREATE_FLOW_TABLE             = 0x930,
         MLX5_CMD_OP_DESTROY_FLOW_TABLE            = 0x931,
         MLX5_CMD_OP_QUERY_FLOW_TABLE              = 0x932,
@@ -193,7 +194,8 @@ enum {
         MLX5_CMD_OP_QUERY_FLOW_GROUP              = 0x935,
         MLX5_CMD_OP_SET_FLOW_TABLE_ENTRY          = 0x936,
         MLX5_CMD_OP_QUERY_FLOW_TABLE_ENTRY        = 0x937,
-        MLX5_CMD_OP_DELETE_FLOW_TABLE_ENTRY       = 0x938
+        MLX5_CMD_OP_DELETE_FLOW_TABLE_ENTRY       = 0x938,
+        MLX5_CMD_OP_MODIFY_FLOW_TABLE             = 0x93c
 };
 
 struct mlx5_ifc_flow_table_fields_supported_bits {
@@ -256,25 +258,30 @@ struct mlx5_ifc_flow_table_fields_supported_bits {
 
 struct mlx5_ifc_flow_table_prop_layout_bits {
         u8         ft_support[0x1];
-        u8         reserved_0[0x1f];
+        u8         reserved_0[0x2];
+        u8         flow_modify_en[0x1];
+        u8         modify_root[0x1];
+        u8         identified_miss_table_mode[0x1];
+        u8         flow_table_modify[0x1];
+        u8         reserved_1[0x19];
 
-        u8         reserved_1[0x2];
+        u8         reserved_2[0x2];
         u8         log_max_ft_size[0x6];
-        u8         reserved_2[0x10];
+        u8         reserved_3[0x10];
         u8         max_ft_level[0x8];
 
-        u8         reserved_3[0x20];
+        u8         reserved_4[0x20];
 
-        u8         reserved_4[0x18];
+        u8         reserved_5[0x18];
         u8         log_max_ft_num[0x8];
 
-        u8         reserved_5[0x18];
+        u8         reserved_6[0x18];
         u8         log_max_destination[0x8];
 
-        u8         reserved_6[0x18];
+        u8         reserved_7[0x18];
         u8         log_max_flow[0x8];
 
-        u8         reserved_7[0x40];
+        u8         reserved_8[0x40];
 
         struct mlx5_ifc_flow_table_fields_supported_bits ft_field_support;
 
@@ -291,6 +298,22 @@ struct mlx5_ifc_odp_per_transport_service_cap_bits {
         u8         reserved_1[0x1a];
 };
 
+struct mlx5_ifc_ipv4_layout_bits {
+        u8         reserved_0[0x60];
+
+        u8         ipv4[0x20];
+};
+
+struct mlx5_ifc_ipv6_layout_bits {
+        u8         ipv6[16][0x8];
+};
+
+union mlx5_ifc_ipv6_layout_ipv4_layout_auto_bits {
+        struct mlx5_ifc_ipv6_layout_bits ipv6_layout;
+        struct mlx5_ifc_ipv4_layout_bits ipv4_layout;
+        u8         reserved_0[0x80];
+};
+
 struct mlx5_ifc_fte_match_set_lyr_2_4_bits {
         u8         smac_47_16[0x20];
 
@@ -321,9 +344,9 @@ struct mlx5_ifc_fte_match_set_lyr_2_4_bits {
         u8         udp_sport[0x10];
         u8         udp_dport[0x10];
 
-        u8         src_ip[4][0x20];
+        union mlx5_ifc_ipv6_layout_ipv4_layout_auto_bits src_ipv4_src_ipv6;
 
-        u8         dst_ip[4][0x20];
+        union mlx5_ifc_ipv6_layout_ipv4_layout_auto_bits dst_ipv4_dst_ipv6;
 };
 
 struct mlx5_ifc_fte_match_set_misc_bits {
@@ -447,6 +470,29 @@ struct mlx5_ifc_flow_table_nic_cap_bits {
         u8         reserved_3[0x7200];
 };
 
+struct mlx5_ifc_flow_table_eswitch_cap_bits {
+        u8     reserved_0[0x200];
+
+        struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_esw_fdb;
+
+        struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_esw_acl_ingress;
+
+        struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_esw_acl_egress;
+
+        u8      reserved_1[0x7800];
+};
+
+struct mlx5_ifc_e_switch_cap_bits {
+        u8         vport_svlan_strip[0x1];
+        u8         vport_cvlan_strip[0x1];
+        u8         vport_svlan_insert[0x1];
+        u8         vport_cvlan_insert_if_not_exist[0x1];
+        u8         vport_cvlan_insert_overwrite[0x1];
+        u8         reserved_0[0x1b];
+
+        u8         reserved_1[0x7e0];
+};
+
 struct mlx5_ifc_per_protocol_networking_offload_caps_bits {
         u8         csum_cap[0x1];
         u8         vlan_cap[0x1];
@@ -665,7 +711,9 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         reserved_17[0x1];
         u8         ets[0x1];
         u8         nic_flow_table[0x1];
-        u8         reserved_18[0x4];
+        u8         eswitch_flow_table[0x1];
+        u8         early_vf_enable;
+        u8         reserved_18[0x2];
         u8         local_ca_ack_delay[0x5];
         u8         reserved_19[0x6];
         u8         port_type[0x2];
@@ -787,27 +835,36 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         reserved_60[0x1b];
         u8         log_max_wq_sz[0x5];
 
-        u8         reserved_61[0xa0];
-
+        u8         nic_vport_change_event[0x1];
+        u8         reserved_61[0xa];
+        u8         log_max_vlan_list[0x5];
         u8         reserved_62[0x3];
+        u8         log_max_current_mc_list[0x5];
+        u8         reserved_63[0x3];
+        u8         log_max_current_uc_list[0x5];
+
+        u8         reserved_64[0x80];
+
+        u8         reserved_65[0x3];
         u8         log_max_l2_table[0x5];
-        u8         reserved_63[0x8];
+        u8         reserved_66[0x8];
         u8         log_uar_page_sz[0x10];
 
-        u8         reserved_64[0x100];
-
-        u8         reserved_65[0x1f];
+        u8         reserved_67[0x40];
+        u8         device_frequency_khz[0x20];
+        u8         reserved_68[0x5f];
         u8         cqe_zip[0x1];
 
         u8         cqe_zip_timeout[0x10];
         u8         cqe_zip_max_num[0x10];
 
-        u8         reserved_66[0x220];
+        u8         reserved_69[0x220];
 };
 
-enum {
-        MLX5_DEST_FORMAT_STRUCT_DESTINATION_TYPE_FLOW_TABLE_  = 0x1,
-        MLX5_DEST_FORMAT_STRUCT_DESTINATION_TYPE_TIR          = 0x2,
+enum mlx5_flow_destination_type {
+        MLX5_FLOW_DESTINATION_TYPE_VPORT        = 0x0,
+        MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE   = 0x1,
+        MLX5_FLOW_DESTINATION_TYPE_TIR          = 0x2,
 };
 
 struct mlx5_ifc_dest_format_struct_bits {
@@ -900,6 +957,13 @@ struct mlx5_ifc_mac_address_layout_bits {
         u8         mac_addr_31_0[0x20];
 };
 
+struct mlx5_ifc_vlan_layout_bits {
+        u8         reserved_0[0x14];
+        u8         vlan[0x0c];
+
+        u8         reserved_1[0x20];
+};
+
 struct mlx5_ifc_cong_control_r_roce_ecn_np_bits {
         u8         reserved_0[0xa0];
 
@@ -1829,6 +1893,8 @@ union mlx5_ifc_hca_cap_union_bits {
         struct mlx5_ifc_roce_cap_bits roce_cap;
         struct mlx5_ifc_per_protocol_networking_offload_caps_bits per_protocol_networking_offload_caps;
         struct mlx5_ifc_flow_table_nic_cap_bits flow_table_nic_cap;
+        struct mlx5_ifc_flow_table_eswitch_cap_bits flow_table_eswitch_cap;
+        struct mlx5_ifc_e_switch_cap_bits e_switch_cap;
         u8         reserved_0[0x8000];
 };
 
@@ -2133,24 +2199,35 @@ struct mlx5_ifc_rmpc_bits {
         struct mlx5_ifc_wq_bits wq;
 };
 
-enum {
-        MLX5_NIC_VPORT_CONTEXT_ALLOWED_LIST_TYPE_CURRENT_UC_MAC_ADDRESS  = 0x0,
-};
-
 struct mlx5_ifc_nic_vport_context_bits {
         u8         reserved_0[0x1f];
         u8         roce_en[0x1];
 
-        u8         reserved_1[0x760];
+        u8         arm_change_event[0x1];
+        u8         reserved_1[0x1a];
+        u8         event_on_mtu[0x1];
+        u8         event_on_promisc_change[0x1];
+        u8         event_on_vlan_change[0x1];
+        u8         event_on_mc_address_change[0x1];
+        u8         event_on_uc_address_change[0x1];
 
-        u8         reserved_2[0x5];
+        u8         reserved_2[0xf0];
+
+        u8         mtu[0x10];
+
+        u8         reserved_3[0x640];
+
+        u8         promisc_uc[0x1];
+        u8         promisc_mc[0x1];
+        u8         promisc_all[0x1];
+        u8         reserved_4[0x2];
         u8         allowed_list_type[0x3];
-        u8         reserved_3[0xc];
+        u8         reserved_5[0xc];
         u8         allowed_list_size[0xc];
 
         struct mlx5_ifc_mac_address_layout_bits permanent_address;
 
-        u8         reserved_4[0x20];
+        u8         reserved_6[0x20];
 
         u8         current_uc_mac_address[0][0x40];
 };
@@ -2263,6 +2340,26 @@ struct mlx5_ifc_hca_vport_context_bits {
         u8         reserved_6[0xca0];
 };
 
+struct mlx5_ifc_esw_vport_context_bits {
+        u8         reserved_0[0x3];
+        u8         vport_svlan_strip[0x1];
+        u8         vport_cvlan_strip[0x1];
+        u8         vport_svlan_insert[0x1];
+        u8         vport_cvlan_insert[0x2];
+        u8         reserved_1[0x18];
+
+        u8         reserved_2[0x20];
+
+        u8         svlan_cfi[0x1];
+        u8         svlan_pcp[0x3];
+        u8         svlan_id[0xc];
+        u8         cvlan_cfi[0x1];
+        u8         cvlan_pcp[0x3];
+        u8         cvlan_id[0xc];
+
+        u8         reserved_3[0x7a0];
+};
+
 enum {
         MLX5_EQC_STATUS_OK                = 0x0,
         MLX5_EQC_STATUS_EQ_WRITE_FAILURE  = 0xa,
@@ -2769,6 +2866,13 @@ struct mlx5_ifc_set_hca_cap_in_bits {
         union mlx5_ifc_hca_cap_union_bits capability;
 };
 
+enum {
+        MLX5_SET_FTE_MODIFY_ENABLE_MASK_ACTION    = 0x0,
+        MLX5_SET_FTE_MODIFY_ENABLE_MASK_FLOW_TAG  = 0x1,
+        MLX5_SET_FTE_MODIFY_ENABLE_MASK_DESTINATION_LIST    = 0x2,
+        MLX5_SET_FTE_MODIFY_ENABLE_MASK_FLOW_COUNTERS    = 0x3
+};
+
 struct mlx5_ifc_set_fte_out_bits {
         u8         status[0x8];
         u8         reserved_0[0x18];
@@ -2793,11 +2897,14 @@ struct mlx5_ifc_set_fte_in_bits {
         u8         reserved_4[0x8];
         u8         table_id[0x18];
 
-        u8         reserved_5[0x40];
+        u8         reserved_5[0x18];
+        u8         modify_enable_mask[0x8];
+
+        u8         reserved_6[0x20];
 
         u8         flow_index[0x20];
 
-        u8         reserved_6[0xe0];
+        u8         reserved_7[0xe0];
 
         struct mlx5_ifc_flow_context_bits flow_context;
 };
@@ -2940,6 +3047,7 @@ struct mlx5_ifc_query_vport_state_out_bits {
 
 enum {
         MLX5_QUERY_VPORT_STATE_IN_OP_MOD_VNIC_VPORT  = 0x0,
+        MLX5_QUERY_VPORT_STATE_IN_OP_MOD_ESW_VPORT   = 0x1,
 };
 
 struct mlx5_ifc_query_vport_state_in_bits {
@@ -3700,6 +3808,64 @@ struct mlx5_ifc_query_flow_group_in_bits {
         u8         reserved_5[0x120];
 };
 
+struct mlx5_ifc_query_esw_vport_context_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_esw_vport_context_bits esw_vport_context;
+};
+
+struct mlx5_ifc_query_esw_vport_context_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_modify_esw_vport_context_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_esw_vport_context_fields_select_bits {
+        u8         reserved[0x1c];
+        u8         vport_cvlan_insert[0x1];
+        u8         vport_svlan_insert[0x1];
+        u8         vport_cvlan_strip[0x1];
+        u8         vport_svlan_strip[0x1];
+};
+
+struct mlx5_ifc_modify_esw_vport_context_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        struct mlx5_ifc_esw_vport_context_fields_select_bits field_select;
+
+        struct mlx5_ifc_esw_vport_context_bits esw_vport_context;
+};
+
 struct mlx5_ifc_query_eq_out_bits {
         u8         status[0x8];
         u8         reserved_0[0x18];
@@ -4228,7 +4394,10 @@ struct mlx5_ifc_modify_nic_vport_context_out_bits {
 };
 
 struct mlx5_ifc_modify_nic_vport_field_select_bits {
-        u8         reserved_0[0x1c];
+        u8         reserved_0[0x19];
+        u8         mtu[0x1];
+        u8         change_event[0x1];
+        u8         promisc[0x1];
         u8         permanent_address[0x1];
         u8         addresses_list[0x1];
         u8         roce_en[0x1];
@@ -5519,12 +5688,16 @@ struct mlx5_ifc_create_flow_table_in_bits {
 
         u8         reserved_4[0x20];
 
-        u8         reserved_5[0x8];
+        u8         reserved_5[0x4];
+        u8         table_miss_mode[0x4];
         u8         level[0x8];
         u8         reserved_6[0x8];
         u8         log_size[0x8];
 
-        u8         reserved_7[0x120];
+        u8         reserved_7[0x8];
+        u8         table_miss_id[0x18];
+
+        u8         reserved_8[0x100];
 };
 
 struct mlx5_ifc_create_flow_group_out_bits {
@@ -6798,4 +6971,72 @@ union mlx5_ifc_uplink_pci_interface_document_bits {
         u8         reserved_0[0x20060];
 };
 
+struct mlx5_ifc_set_flow_table_root_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_set_flow_table_root_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x140];
+};
+
+enum {
+        MLX5_MODIFY_FLOW_TABLE_MISS_TABLE_ID = 0x1,
+};
+
+struct mlx5_ifc_modify_flow_table_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_flow_table_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         reserved_3[0x10];
+        u8         modify_field_select[0x10];
+
+        u8         table_type[0x8];
+        u8         reserved_4[0x18];
+
+        u8         reserved_5[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_6[0x4];
+        u8         table_miss_mode[0x4];
+        u8         reserved_7[0x18];
+
+        u8         reserved_8[0x8];
+        u8         table_miss_id[0x18];
+
+        u8         reserved_9[0x100];
+};
+
 #endif /* MLX5_IFC_H */
diff --git a/include/linux/mlx5/vport.h b/include/linux/mlx5/vport.h
index 967e0fd06e89..638f2ca7a527 100644
--- a/include/linux/mlx5/vport.h
+++ b/include/linux/mlx5/vport.h
@@ -34,9 +34,17 @@
 #define __MLX5_VPORT_H__
 
 #include <linux/mlx5/driver.h>
+#include <linux/mlx5/device.h>
 
-u8 mlx5_query_vport_state(struct mlx5_core_dev *mdev, u8 opmod);
-void mlx5_query_nic_vport_mac_address(struct mlx5_core_dev *mdev, u8 *addr);
+u8 mlx5_query_vport_state(struct mlx5_core_dev *mdev, u8 opmod, u16 vport);
+u8 mlx5_query_vport_admin_state(struct mlx5_core_dev *mdev, u8 opmod,
+                                u16 vport);
+int mlx5_modify_vport_admin_state(struct mlx5_core_dev *mdev, u8 opmod,
+                                  u16 vport, u8 state);
+int mlx5_query_nic_vport_mac_address(struct mlx5_core_dev *mdev,
+                                     u16 vport, u8 *addr);
+int mlx5_modify_nic_vport_mac_address(struct mlx5_core_dev *dev,
+                                      u16 vport, u8 *addr);
 int mlx5_query_hca_vport_gid(struct mlx5_core_dev *dev, u8 other_vport,
                              u8 port_num, u16  vf_num, u16 gid_index,
                              union ib_gid *gid);
@@ -51,5 +59,30 @@ int mlx5_query_hca_vport_system_image_guid(struct mlx5_core_dev *dev,
                                            u64 *sys_image_guid);
 int mlx5_query_hca_vport_node_guid(struct mlx5_core_dev *dev,
                                    u64 *node_guid);
+int mlx5_query_nic_vport_mac_list(struct mlx5_core_dev *dev,
+                                  u32 vport,
+                                  enum mlx5_list_type list_type,
+                                  u8 addr_list[][ETH_ALEN],
+                                  int *list_size);
+int mlx5_modify_nic_vport_mac_list(struct mlx5_core_dev *dev,
+                                   enum mlx5_list_type list_type,
+                                   u8 addr_list[][ETH_ALEN],
+                                   int list_size);
+int mlx5_query_nic_vport_promisc(struct mlx5_core_dev *mdev,
+                                 u32 vport,
+                                 int *promisc_uc,
+                                 int *promisc_mc,
+                                 int *promisc_all);
+int mlx5_modify_nic_vport_promisc(struct mlx5_core_dev *mdev,
+                                  int promisc_uc,
+                                  int promisc_mc,
+                                  int promisc_all);
+int mlx5_query_nic_vport_vlans(struct mlx5_core_dev *dev,
+                               u32 vport,
+                               u16 vlans[],
+                               int *size);
+int mlx5_modify_nic_vport_vlans(struct mlx5_core_dev *dev,
+                                u16 vlans[],
+                                int list_size);
 
 #endif /* __MLX5_VPORT_H__ */
diff --git a/include/linux/mroute.h b/include/linux/mroute.h
index 79aaa9fc1a15..bf9b322cb0b0 100644
--- a/include/linux/mroute.h
+++ b/include/linux/mroute.h
@@ -9,38 +9,28 @@
 #ifdef CONFIG_IP_MROUTE
 static inline int ip_mroute_opt(int opt)
 {
-        return (opt >= MRT_BASE) && (opt <= MRT_MAX);
+        return opt >= MRT_BASE && opt <= MRT_MAX;
 }
-#else
-static inline int ip_mroute_opt(int opt)
-{
-        return 0;
-}
-#endif
 
-#ifdef CONFIG_IP_MROUTE
-extern int ip_mroute_setsockopt(struct sock *, int, char __user *, unsigned int);
-extern int ip_mroute_getsockopt(struct sock *, int, char __user *, int __user *);
-extern int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg);
-extern int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg);
-extern int ip_mr_init(void);
+int ip_mroute_setsockopt(struct sock *, int, char __user *, unsigned int);
+int ip_mroute_getsockopt(struct sock *, int, char __user *, int __user *);
+int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg);
+int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg);
+int ip_mr_init(void);
 #else
-static inline
-int ip_mroute_setsockopt(struct sock *sock,
-                         int optname, char __user *optval, unsigned int optlen)
+static inline int ip_mroute_setsockopt(struct sock *sock, int optname,
+                                       char __user *optval, unsigned int optlen)
 {
         return -ENOPROTOOPT;
 }
 
-static inline
-int ip_mroute_getsockopt(struct sock *sock,
-                         int optname, char __user *optval, int __user *optlen)
+static inline int ip_mroute_getsockopt(struct sock *sock, int optname,
+                                       char __user *optval, int __user *optlen)
 {
         return -ENOPROTOOPT;
 }
 
-static inline
-int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
+static inline int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
 {
         return -ENOIOCTLCMD;
 }
@@ -49,6 +39,11 @@ static inline int ip_mr_init(void)
 {
         return 0;
 }
+
+static inline int ip_mroute_opt(int opt)
+{
+        return 0;
+}
 #endif
 
 struct vif_device {
@@ -64,6 +59,32 @@ struct vif_device {
 
 #define VIFF_STATIC 0x8000
 
+#define VIF_EXISTS(_mrt, _idx) ((_mrt)->vif_table[_idx].dev != NULL)
+#define MFC_LINES 64
+
+struct mr_table {
+        struct list_head        list;
+        possible_net_t          net;
+        u32                     id;
+        struct sock __rcu       *mroute_sk;
+        struct timer_list       ipmr_expire_timer;
+        struct list_head        mfc_unres_queue;
+        struct list_head        mfc_cache_array[MFC_LINES];
+        struct vif_device       vif_table[MAXVIFS];
+        int                     maxvif;
+        atomic_t                cache_resolve_queue_len;
+        bool                    mroute_do_assert;
+        bool                    mroute_do_pim;
+        int                     mroute_reg_vif_num;
+};
+
+/* mfc_flags:
+ * MFC_STATIC - the entry was added statically (not by a routing daemon)
+ */
+enum {
+        MFC_STATIC = BIT(0),
+};
+
 struct mfc_cache {
         struct list_head list;
         __be32 mfc_mcastgrp;                    /* Group the entry belongs to   */
@@ -89,19 +110,14 @@ struct mfc_cache {
         struct rcu_head rcu;
 };
 
-#define MFC_STATIC              1
-#define MFC_NOTIFY              2
-
-#define MFC_LINES               64
-
 #ifdef __BIG_ENDIAN
 #define MFC_HASH(a,b)   (((((__force u32)(__be32)a)>>24)^(((__force u32)(__be32)b)>>26))&(MFC_LINES-1))
 #else
 #define MFC_HASH(a,b)   ((((__force u32)(__be32)a)^(((__force u32)(__be32)b)>>2))&(MFC_LINES-1))
-#endif          
+#endif
 
 struct rtmsg;
-extern int ipmr_get_route(struct net *net, struct sk_buff *skb,
-                          __be32 saddr, __be32 daddr,
-                          struct rtmsg *rtm, int nowait);
+int ipmr_get_route(struct net *net, struct sk_buff *skb,
+                   __be32 saddr, __be32 daddr,
+                   struct rtmsg *rtm, int nowait);
 #endif
diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h
index f0d87347df19..d9654f0eecb3 100644
--- a/include/linux/netdev_features.h
+++ b/include/linux/netdev_features.h
@@ -52,7 +52,7 @@ enum {
                 NETIF_F_GSO_TUNNEL_REMCSUM_BIT,
 
         NETIF_F_FCOE_CRC_BIT,           /* FCoE CRC32 */
-        NETIF_F_SCTP_CSUM_BIT,          /* SCTP checksum offload */
+        NETIF_F_SCTP_CRC_BIT,           /* SCTP checksum offload */
         NETIF_F_FCOE_MTU_BIT,           /* Supports max FCoE MTU, 2158 bytes*/
         NETIF_F_NTUPLE_BIT,             /* N-tuple filters supported */
         NETIF_F_RXHASH_BIT,             /* Receive hashing offload */
@@ -103,7 +103,7 @@ enum {
 #define NETIF_F_NTUPLE          __NETIF_F(NTUPLE)
 #define NETIF_F_RXCSUM          __NETIF_F(RXCSUM)
 #define NETIF_F_RXHASH          __NETIF_F(RXHASH)
-#define NETIF_F_SCTP_CSUM       __NETIF_F(SCTP_CSUM)
+#define NETIF_F_SCTP_CRC        __NETIF_F(SCTP_CRC)
 #define NETIF_F_SG              __NETIF_F(SG)
 #define NETIF_F_TSO6            __NETIF_F(TSO6)
 #define NETIF_F_TSO_ECN         __NETIF_F(TSO_ECN)
@@ -146,10 +146,12 @@ enum {
 #define NETIF_F_GSO_SOFTWARE    (NETIF_F_TSO | NETIF_F_TSO_ECN | \
                                  NETIF_F_TSO6 | NETIF_F_UFO)
 
-#define NETIF_F_GEN_CSUM        NETIF_F_HW_CSUM
-#define NETIF_F_V4_CSUM         (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
-#define NETIF_F_V6_CSUM         (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
-#define NETIF_F_ALL_CSUM        (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
+/* List of IP checksum features. Note that NETIF_F_ HW_CSUM should not be
+ * set in features when NETIF_F_IP_CSUM or NETIF_F_IPV6_CSUM are set--
+ * this would be contradictory
+ */
+#define NETIF_F_CSUM_MASK       (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | \
+                                 NETIF_F_HW_CSUM)
 
 #define NETIF_F_ALL_TSO         (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN)
 
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 3143c847bddb..5ac140dcb789 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -132,7 +132,9 @@ static inline bool dev_xmit_complete(int rc)
  *      used.
  */
 
-#if defined(CONFIG_WLAN) || IS_ENABLED(CONFIG_AX25)
+#if defined(CONFIG_HYPERV_NET)
+# define LL_MAX_HEADER 128
+#elif defined(CONFIG_WLAN) || IS_ENABLED(CONFIG_AX25)
 # if defined(CONFIG_MAC80211_MESH)
 #  define LL_MAX_HEADER 128
 # else
@@ -326,7 +328,8 @@ enum {
         NAPI_STATE_SCHED,       /* Poll is scheduled */
         NAPI_STATE_DISABLE,     /* Disable pending */
         NAPI_STATE_NPSVC,       /* Netpoll - don't dequeue from poll_list */
-        NAPI_STATE_HASHED,      /* In NAPI hash */
+        NAPI_STATE_HASHED,      /* In NAPI hash (busy polling possible) */
+        NAPI_STATE_NO_BUSY_POLL,/* Do not add in napi_hash, no busy polling */
 };
 
 enum gro_result {
@@ -461,19 +464,13 @@ static inline void napi_complete(struct napi_struct *n)
 }
 
 /**
- *      napi_by_id - lookup a NAPI by napi_id
- *      @napi_id: hashed napi_id
- *
- * lookup @napi_id in napi_hash table
- * must be called under rcu_read_lock()
- */
-struct napi_struct *napi_by_id(unsigned int napi_id);
-
-/**
  *      napi_hash_add - add a NAPI to global hashtable
  *      @napi: napi context
  *
  * generate a new napi_id and store a @napi under it in napi_hash
+ * Used for busy polling (CONFIG_NET_RX_BUSY_POLL)
+ * Note: This is normally automatically done from netif_napi_add(),
+ * so might disappear in a future linux version.
  */
 void napi_hash_add(struct napi_struct *napi);
 
@@ -482,9 +479,14 @@ void napi_hash_add(struct napi_struct *napi);
  *      @napi: napi context
  *
  * Warning: caller must observe rcu grace period
- * before freeing memory containing @napi
+ * before freeing memory containing @napi, if
+ * this function returns true.
+ * Note: core networking stack automatically calls it
+ * from netif_napi_del()
+ * Drivers might want to call this helper to combine all
+ * the needed rcu grace periods into a single one.
  */
-void napi_hash_del(struct napi_struct *napi);
+bool napi_hash_del(struct napi_struct *napi);
 
 /**
  *      napi_disable - prevent NAPI from scheduling
@@ -810,6 +812,12 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
  *        (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
  *      Required can not be NULL.
  *
+ * netdev_features_t (*ndo_fix_features)(struct net_device *dev,
+ *              netdev_features_t features);
+ *      Adjusts the requested feature flags according to device-specific
+ *      constraints, and returns the resulting flags. Must not modify
+ *      the device state.
+ *
  * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb,
  *                         void *accel_priv, select_queue_fallback_t fallback);
  *      Called to decide which queue to when device supports multiple
@@ -957,12 +965,6 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
  *      Called to release previously enslaved netdev.
  *
  *      Feature/offload setting functions.
- * netdev_features_t (*ndo_fix_features)(struct net_device *dev,
- *              netdev_features_t features);
- *      Adjusts the requested feature flags according to device-specific
- *      constraints, and returns the resulting flags. Must not modify
- *      the device state.
- *
  * int (*ndo_set_features)(struct net_device *dev, netdev_features_t features);
  *      Called to update device configuration to new features. Passed
  *      feature set might be less than what was returned by ndo_fix_features()).
@@ -1011,6 +1013,19 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
  *      a new port starts listening. The operation is protected by the
  *      vxlan_net->sock_lock.
  *
+ * void (*ndo_add_geneve_port)(struct net_device *dev,
+ *                            sa_family_t sa_family, __be16 port);
+ *      Called by geneve to notify a driver about the UDP port and socket
+ *      address family that geneve is listnening to. It is called only when
+ *      a new port starts listening. The operation is protected by the
+ *      geneve_net->sock_lock.
+ *
+ * void (*ndo_del_geneve_port)(struct net_device *dev,
+ *                            sa_family_t sa_family, __be16 port);
+ *      Called by geneve to notify the driver about a UDP port and socket
+ *      address family that geneve is not listening to anymore. The operation
+ *      is protected by the geneve_net->sock_lock.
+ *
  * void (*ndo_del_vxlan_port)(struct  net_device *dev,
  *                            sa_family_t sa_family, __be16 port);
  *      Called by vxlan to notify the driver about a UDP port and socket
@@ -1066,8 +1081,11 @@ struct net_device_ops {
         void                    (*ndo_uninit)(struct net_device *dev);
         int                     (*ndo_open)(struct net_device *dev);
         int                     (*ndo_stop)(struct net_device *dev);
-        netdev_tx_t             (*ndo_start_xmit) (struct sk_buff *skb,
-                                                   struct net_device *dev);
+        netdev_tx_t             (*ndo_start_xmit)(struct sk_buff *skb,
+                                                  struct net_device *dev);
+        netdev_features_t       (*ndo_features_check)(struct sk_buff *skb,
+                                                      struct net_device *dev,
+                                                      netdev_features_t features);
         u16                     (*ndo_select_queue)(struct net_device *dev,
                                                     struct sk_buff *skb,
                                                     void *accel_priv,
@@ -1215,7 +1233,12 @@ struct net_device_ops {
         void                    (*ndo_del_vxlan_port)(struct  net_device *dev,
                                                       sa_family_t sa_family,
                                                       __be16 port);
-
+        void                    (*ndo_add_geneve_port)(struct  net_device *dev,
+                                                       sa_family_t sa_family,
+                                                       __be16 port);
+        void                    (*ndo_del_geneve_port)(struct  net_device *dev,
+                                                       sa_family_t sa_family,
+                                                       __be16 port);
         void*                   (*ndo_dfwd_add_station)(struct net_device *pdev,
                                                         struct net_device *dev);
         void                    (*ndo_dfwd_del_station)(struct net_device *pdev,
@@ -1225,9 +1248,6 @@ struct net_device_ops {
                                                         struct net_device *dev,
                                                         void *priv);
         int                     (*ndo_get_lock_subclass)(struct net_device *dev);
-        netdev_features_t       (*ndo_features_check) (struct sk_buff *skb,
-                                                       struct net_device *dev,
-                                                       netdev_features_t features);
         int                     (*ndo_set_tx_maxrate)(struct net_device *dev,
                                                       int queue_index,
                                                       u32 maxrate);
@@ -1271,6 +1291,7 @@ struct net_device_ops {
  * @IFF_NO_QUEUE: device can run without qdisc attached
  * @IFF_OPENVSWITCH: device is a Open vSwitch master
  * @IFF_L3MDEV_SLAVE: device is enslaved to an L3 master device
+ * @IFF_TEAM: device is a team device
  */
 enum netdev_priv_flags {
         IFF_802_1Q_VLAN                 = 1<<0,
@@ -1297,6 +1318,7 @@ enum netdev_priv_flags {
         IFF_NO_QUEUE                    = 1<<21,
         IFF_OPENVSWITCH                 = 1<<22,
         IFF_L3MDEV_SLAVE                = 1<<23,
+        IFF_TEAM                        = 1<<24,
 };
 
 #define IFF_802_1Q_VLAN                 IFF_802_1Q_VLAN
@@ -1323,6 +1345,7 @@ enum netdev_priv_flags {
 #define IFF_NO_QUEUE                    IFF_NO_QUEUE
 #define IFF_OPENVSWITCH                 IFF_OPENVSWITCH
 #define IFF_L3MDEV_SLAVE                IFF_L3MDEV_SLAVE
+#define IFF_TEAM                        IFF_TEAM
 
 /**
  *      struct net_device - The DEVICE structure.
@@ -1716,7 +1739,9 @@ struct net_device {
 #ifdef CONFIG_XPS
         struct xps_dev_maps __rcu *xps_maps;
 #endif
-
+#ifdef CONFIG_NET_CLS_ACT
+        struct tcf_proto __rcu  *egress_cl_list;
+#endif
 #ifdef CONFIG_NET_SWITCHDEV
         u32                     offload_fwd_mark;
 #endif
@@ -1949,6 +1974,26 @@ void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
                     int (*poll)(struct napi_struct *, int), int weight);
 
 /**
+ *      netif_tx_napi_add - initialize a napi context
+ *      @dev:  network device
+ *      @napi: napi context
+ *      @poll: polling function
+ *      @weight: default weight
+ *
+ * This variant of netif_napi_add() should be used from drivers using NAPI
+ * to exclusively poll a TX queue.
+ * This will avoid we add it into napi_hash[], thus polluting this hash table.
+ */
+static inline void netif_tx_napi_add(struct net_device *dev,
+                                     struct napi_struct *napi,
+                                     int (*poll)(struct napi_struct *, int),
+                                     int weight)
+{
+        set_bit(NAPI_STATE_NO_BUSY_POLL, &napi->state);
+        netif_napi_add(dev, napi, poll, weight);
+}
+
+/**
  *  netif_napi_del - remove a napi context
  *  @napi: napi context
  *
@@ -2086,6 +2131,24 @@ struct pcpu_sw_netstats {
 #define netdev_alloc_pcpu_stats(type)                                   \
         __netdev_alloc_pcpu_stats(type, GFP_KERNEL)
 
+enum netdev_lag_tx_type {
+        NETDEV_LAG_TX_TYPE_UNKNOWN,
+        NETDEV_LAG_TX_TYPE_RANDOM,
+        NETDEV_LAG_TX_TYPE_BROADCAST,
+        NETDEV_LAG_TX_TYPE_ROUNDROBIN,
+        NETDEV_LAG_TX_TYPE_ACTIVEBACKUP,
+        NETDEV_LAG_TX_TYPE_HASH,
+};
+
+struct netdev_lag_upper_info {
+        enum netdev_lag_tx_type tx_type;
+};
+
+struct netdev_lag_lower_state_info {
+        u8 link_up : 1,
+           tx_enabled : 1;
+};
+
 #include <linux/notifier.h>
 
 /* netdevice notifier chain. Please remember to update the rtnetlink
@@ -2121,6 +2184,7 @@ struct pcpu_sw_netstats {
 #define NETDEV_CHANGEINFODATA   0x0018
 #define NETDEV_BONDING_INFO     0x0019
 #define NETDEV_PRECHANGEUPPER   0x001A
+#define NETDEV_CHANGELOWERSTATE 0x001B
 
 int register_netdevice_notifier(struct notifier_block *nb);
 int unregister_netdevice_notifier(struct notifier_block *nb);
@@ -2139,6 +2203,12 @@ struct netdev_notifier_changeupper_info {
         struct net_device *upper_dev; /* new upper dev */
         bool master; /* is upper dev master */
         bool linking; /* is the nofication for link or unlink */
+        void *upper_info; /* upper dev info */
+};
+
+struct netdev_notifier_changelowerstate_info {
+        struct netdev_notifier_info info; /* must be first */
+        void *lower_state_info; /* is lower dev state */
 };
 
 static inline void netdev_notifier_info_init(struct netdev_notifier_info *info,
@@ -2472,6 +2542,71 @@ static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb,
         remcsum_unadjust((__sum16 *)ptr, grc->delta);
 }
 
+struct skb_csum_offl_spec {
+        __u16           ipv4_okay:1,
+                        ipv6_okay:1,
+                        encap_okay:1,
+                        ip_options_okay:1,
+                        ext_hdrs_okay:1,
+                        tcp_okay:1,
+                        udp_okay:1,
+                        sctp_okay:1,
+                        vlan_okay:1,
+                        no_encapped_ipv6:1,
+                        no_not_encapped:1;
+};
+
+bool __skb_csum_offload_chk(struct sk_buff *skb,
+                            const struct skb_csum_offl_spec *spec,
+                            bool *csum_encapped,
+                            bool csum_help);
+
+static inline bool skb_csum_offload_chk(struct sk_buff *skb,
+                                        const struct skb_csum_offl_spec *spec,
+                                        bool *csum_encapped,
+                                        bool csum_help)
+{
+        if (skb->ip_summed != CHECKSUM_PARTIAL)
+                return false;
+
+        return __skb_csum_offload_chk(skb, spec, csum_encapped, csum_help);
+}
+
+static inline bool skb_csum_offload_chk_help(struct sk_buff *skb,
+                                             const struct skb_csum_offl_spec *spec)
+{
+        bool csum_encapped;
+
+        return skb_csum_offload_chk(skb, spec, &csum_encapped, true);
+}
+
+static inline bool skb_csum_off_chk_help_cmn(struct sk_buff *skb)
+{
+        static const struct skb_csum_offl_spec csum_offl_spec = {
+                .ipv4_okay = 1,
+                .ip_options_okay = 1,
+                .ipv6_okay = 1,
+                .vlan_okay = 1,
+                .tcp_okay = 1,
+                .udp_okay = 1,
+        };
+
+        return skb_csum_offload_chk_help(skb, &csum_offl_spec);
+}
+
+static inline bool skb_csum_off_chk_help_cmn_v4_only(struct sk_buff *skb)
+{
+        static const struct skb_csum_offl_spec csum_offl_spec = {
+                .ipv4_okay = 1,
+                .ip_options_okay = 1,
+                .tcp_okay = 1,
+                .udp_okay = 1,
+                .vlan_okay = 1,
+        };
+
+        return skb_csum_offload_chk_help(skb, &csum_offl_spec);
+}
+
 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
                                   unsigned short type,
                                   const void *daddr, const void *saddr,
@@ -3595,15 +3730,15 @@ struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
 struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
 int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev);
 int netdev_master_upper_dev_link(struct net_device *dev,
-                                 struct net_device *upper_dev);
-int netdev_master_upper_dev_link_private(struct net_device *dev,
-                                         struct net_device *upper_dev,
-                                         void *private);
+                                 struct net_device *upper_dev,
+                                 void *upper_priv, void *upper_info);
 void netdev_upper_dev_unlink(struct net_device *dev,
                              struct net_device *upper_dev);
 void netdev_adjacent_rename_links(struct net_device *dev, char *oldname);
 void *netdev_lower_dev_get_private(struct net_device *dev,
                                    struct net_device *lower_dev);
+void netdev_lower_state_changed(struct net_device *lower_dev,
+                                void *lower_state_info);
 
 /* RSS keys are 40 or 52 bytes long */
 #define NETDEV_RSS_KEY_LEN 52
@@ -3611,7 +3746,7 @@ extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN];
 void netdev_rss_key_fill(void *buffer, size_t len);
 
 int dev_get_nest_level(struct net_device *dev,
-                       bool (*type_check)(struct net_device *dev));
+                       bool (*type_check)(const struct net_device *dev));
 int skb_checksum_help(struct sk_buff *skb);
 struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
                                   netdev_features_t features, bool tx_path);
@@ -3641,13 +3776,37 @@ __be16 skb_network_protocol(struct sk_buff *skb, int *depth);
 static inline bool can_checksum_protocol(netdev_features_t features,
                                          __be16 protocol)
 {
-        return ((features & NETIF_F_GEN_CSUM) ||
-                ((features & NETIF_F_V4_CSUM) &&
-                 protocol == htons(ETH_P_IP)) ||
-                ((features & NETIF_F_V6_CSUM) &&
-                 protocol == htons(ETH_P_IPV6)) ||
-                ((features & NETIF_F_FCOE_CRC) &&
-                 protocol == htons(ETH_P_FCOE)));
+        if (protocol == htons(ETH_P_FCOE))
+                return !!(features & NETIF_F_FCOE_CRC);
+
+        /* Assume this is an IP checksum (not SCTP CRC) */
+
+        if (features & NETIF_F_HW_CSUM) {
+                /* Can checksum everything */
+                return true;
+        }
+
+        switch (protocol) {
+        case htons(ETH_P_IP):
+                return !!(features & NETIF_F_IP_CSUM);
+        case htons(ETH_P_IPV6):
+                return !!(features & NETIF_F_IPV6_CSUM);
+        default:
+                return false;
+        }
+}
+
+/* Map an ethertype into IP protocol if possible */
+static inline int eproto_to_ipproto(int eproto)
+{
+        switch (eproto) {
+        case htons(ETH_P_IP):
+                return IPPROTO_IP;
+        case htons(ETH_P_IPV6):
+                return IPPROTO_IPV6;
+        default:
+                return -1;
+        }
 }
 
 #ifdef CONFIG_BUG
@@ -3712,15 +3871,14 @@ void linkwatch_run_queue(void);
 static inline netdev_features_t netdev_intersect_features(netdev_features_t f1,
                                                           netdev_features_t f2)
 {
-        if (f1 & NETIF_F_GEN_CSUM)
-                f1 |= (NETIF_F_ALL_CSUM & ~NETIF_F_GEN_CSUM);
-        if (f2 & NETIF_F_GEN_CSUM)
-                f2 |= (NETIF_F_ALL_CSUM & ~NETIF_F_GEN_CSUM);
-        f1 &= f2;
-        if (f1 & NETIF_F_GEN_CSUM)
-                f1 &= ~(NETIF_F_ALL_CSUM & ~NETIF_F_GEN_CSUM);
+        if ((f1 ^ f2) & NETIF_F_HW_CSUM) {
+                if (f1 & NETIF_F_HW_CSUM)
+                        f1 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
+                else
+                        f2 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
+        }
 
-        return f1;
+        return f1 & f2;
 }
 
 static inline netdev_features_t netdev_get_wanted_features(
@@ -3808,32 +3966,32 @@ static inline void skb_gso_error_unwind(struct sk_buff *skb, __be16 protocol,
         skb->mac_len = mac_len;
 }
 
-static inline bool netif_is_macvlan(struct net_device *dev)
+static inline bool netif_is_macvlan(const struct net_device *dev)
 {
         return dev->priv_flags & IFF_MACVLAN;
 }
 
-static inline bool netif_is_macvlan_port(struct net_device *dev)
+static inline bool netif_is_macvlan_port(const struct net_device *dev)
 {
         return dev->priv_flags & IFF_MACVLAN_PORT;
 }
 
-static inline bool netif_is_ipvlan(struct net_device *dev)
+static inline bool netif_is_ipvlan(const struct net_device *dev)
 {
         return dev->priv_flags & IFF_IPVLAN_SLAVE;
 }
 
-static inline bool netif_is_ipvlan_port(struct net_device *dev)
+static inline bool netif_is_ipvlan_port(const struct net_device *dev)
 {
         return dev->priv_flags & IFF_IPVLAN_MASTER;
 }
 
-static inline bool netif_is_bond_master(struct net_device *dev)
+static inline bool netif_is_bond_master(const struct net_device *dev)
 {
         return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING;
 }
 
-static inline bool netif_is_bond_slave(struct net_device *dev)
+static inline bool netif_is_bond_slave(const struct net_device *dev)
 {
         return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
 }
@@ -3868,6 +4026,26 @@ static inline bool netif_is_ovs_master(const struct net_device *dev)
         return dev->priv_flags & IFF_OPENVSWITCH;
 }
 
+static inline bool netif_is_team_master(const struct net_device *dev)
+{
+        return dev->priv_flags & IFF_TEAM;
+}
+
+static inline bool netif_is_team_port(const struct net_device *dev)
+{
+        return dev->priv_flags & IFF_TEAM_PORT;
+}
+
+static inline bool netif_is_lag_master(const struct net_device *dev)
+{
+        return netif_is_bond_master(dev) || netif_is_team_master(dev);
+}
+
+static inline bool netif_is_lag_port(const struct net_device *dev)
+{
+        return netif_is_bond_slave(dev) || netif_is_team_port(dev);
+}
+
 /* This device needs to keep skb dst for qdisc enqueue or ndo_start_xmit() */
 static inline void netif_keep_dst(struct net_device *dev)
 {
diff --git a/include/linux/netfilter/nf_conntrack_sctp.h b/include/linux/netfilter/nf_conntrack_sctp.h
new file mode 100644
index 000000000000..22a16a23cd8a
--- /dev/null
+++ b/include/linux/netfilter/nf_conntrack_sctp.h
@@ -0,0 +1,13 @@
+#ifndef _NF_CONNTRACK_SCTP_H
+#define _NF_CONNTRACK_SCTP_H
+/* SCTP tracking. */
+
+#include <uapi/linux/netfilter/nf_conntrack_sctp.h>
+
+struct ip_ct_sctp {
+        enum sctp_conntrack state;
+
+        __be32 vtag[IP_CT_DIR_MAX];
+};
+
+#endif /* _NF_CONNTRACK_SCTP_H */
diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h
index 5646b24bfc64..ba0d9789eb6e 100644
--- a/include/linux/netfilter/nfnetlink.h
+++ b/include/linux/netfilter/nfnetlink.h
@@ -8,12 +8,12 @@
 #include <uapi/linux/netfilter/nfnetlink.h>
 
 struct nfnl_callback {
-        int (*call)(struct sock *nl, struct sk_buff *skb, 
-                    const struct nlmsghdr *nlh,
-                    const struct nlattr * const cda[]);
-        int (*call_rcu)(struct sock *nl, struct sk_buff *skb, 
+        int (*call)(struct net *net, struct sock *nl, struct sk_buff *skb,
                     const struct nlmsghdr *nlh,
                     const struct nlattr * const cda[]);
+        int (*call_rcu)(struct net *net, struct sock *nl, struct sk_buff *skb,
+                        const struct nlmsghdr *nlh,
+                        const struct nlattr * const cda[]);
         int (*call_batch)(struct net *net, struct sock *nl, struct sk_buff *skb,
                           const struct nlmsghdr *nlh,
                           const struct nlattr * const cda[]);
@@ -26,8 +26,8 @@ struct nfnetlink_subsystem {
         __u8 subsys_id;                 /* nfnetlink subsystem ID */
         __u8 cb_count;                  /* number of callbacks */
         const struct nfnl_callback *cb; /* callback for individual types */
-        int (*commit)(struct sk_buff *skb);
-        int (*abort)(struct sk_buff *skb);
+        int (*commit)(struct net *net, struct sk_buff *skb);
+        int (*abort)(struct net *net, struct sk_buff *skb);
 };
 
 int nfnetlink_subsys_register(const struct nfnetlink_subsystem *n);
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 639e9b8b0e4d..0b41959aab9f 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -131,6 +131,7 @@ netlink_skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
 struct netlink_callback {
         struct sk_buff          *skb;
         const struct nlmsghdr   *nlh;
+        int                     (*start)(struct netlink_callback *);
         int                     (*dump)(struct sk_buff * skb,
                                         struct netlink_callback *cb);
         int                     (*done)(struct netlink_callback *cb);
@@ -153,6 +154,7 @@ struct nlmsghdr *
 __nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, int type, int len, int flags);
 
 struct netlink_dump_control {
+        int (*start)(struct netlink_callback *);
         int (*dump)(struct sk_buff *skb, struct netlink_callback *);
         int (*done)(struct netlink_callback *);
         void *data;
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index d9ba49cedc5d..1acbefc4bbda 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2495,6 +2495,8 @@
 #define PCI_DEVICE_ID_KORENIX_JETCARDF2 0x1700
 #define PCI_DEVICE_ID_KORENIX_JETCARDF3 0x17ff
 
+#define PCI_VENDOR_ID_NETRONOME         0x19ee
+
 #define PCI_VENDOR_ID_QMI               0x1a32
 
 #define PCI_VENDOR_ID_AZWAVE            0x1a3b
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 05fde31b6dc6..d6f3641e7933 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -16,8 +16,10 @@
 #ifndef __PHY_H
 #define __PHY_H
 
+#include <linux/compiler.h>
 #include <linux/spinlock.h>
 #include <linux/ethtool.h>
+#include <linux/mdio.h>
 #include <linux/mii.h>
 #include <linux/module.h>
 #include <linux/timer.h>
@@ -58,6 +60,7 @@
 #define PHY_HAS_INTERRUPT       0x00000001
 #define PHY_HAS_MAGICANEG       0x00000002
 #define PHY_IS_INTERNAL         0x00000004
+#define MDIO_DEVICE_IS_PHY      0x80000000
 
 /* Interface Mode definitions */
 typedef enum {
@@ -158,8 +161,8 @@ struct mii_bus {
         const char *name;
         char id[MII_BUS_ID_SIZE];
         void *priv;
-        int (*read)(struct mii_bus *bus, int phy_id, int regnum);
-        int (*write)(struct mii_bus *bus, int phy_id, int regnum, u16 val);
+        int (*read)(struct mii_bus *bus, int addr, int regnum);
+        int (*write)(struct mii_bus *bus, int addr, int regnum, u16 val);
         int (*reset)(struct mii_bus *bus);
 
         /*
@@ -178,7 +181,7 @@ struct mii_bus {
         struct device dev;
 
         /* list of all PHYs on bus */
-        struct phy_device *phy_map[PHY_MAX_ADDR];
+        struct mdio_device *mdio_map[PHY_MAX_ADDR];
 
         /* PHY addresses to be ignored when probing */
         u32 phy_mask;
@@ -187,10 +190,10 @@ struct mii_bus {
         u32 phy_ignore_ta_mask;
 
         /*
-         * Pointer to an array of interrupts, each PHY's
-         * interrupt at the index matching its address
+         * An array of interrupts, each PHY's interrupt at the index
+         * matching its address
          */
-        int *irq;
+        int irq[PHY_MAX_ADDR];
 };
 #define to_mii_bus(d) container_of(d, struct mii_bus, dev)
 
@@ -212,11 +215,6 @@ static inline struct mii_bus *devm_mdiobus_alloc(struct device *dev)
 
 void devm_mdiobus_free(struct device *dev, struct mii_bus *bus);
 struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr);
-int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum);
-int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum);
-int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val);
-int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val);
-
 
 #define PHY_INTERRUPT_DISABLED  0x0
 #define PHY_INTERRUPT_ENABLED   0x80000000
@@ -361,14 +359,12 @@ struct phy_c45_device_ids {
  * handling, as well as handling shifts in PHY hardware state
  */
 struct phy_device {
+        struct mdio_device mdio;
+
         /* Information about the PHY type */
         /* And management functions */
         struct phy_driver *drv;
 
-        struct mii_bus *bus;
-
-        struct device dev;
-
         u32 phy_id;
 
         struct phy_c45_device_ids c45_ids;
@@ -384,9 +380,6 @@ struct phy_device {
 
         phy_interface_t interface;
 
-        /* Bus address of the PHY (0-31) */
-        int addr;
-
         /*
          * forced speed & duplex (no autoneg)
          * partner speed & duplex & pause (autoneg)
@@ -435,10 +428,12 @@ struct phy_device {
 
         void (*adjust_link)(struct net_device *dev);
 };
-#define to_phy_device(d) container_of(d, struct phy_device, dev)
+#define to_phy_device(d) container_of(to_mdio_device(d), \
+                                      struct phy_device, mdio)
 
 /* struct phy_driver: Driver structure for a particular PHY type
  *
+ * driver_data: static driver data
  * phy_id: The result of reading the UID registers of this PHY
  *   type, and ANDing them with the phy_id_mask.  This driver
  *   only works for PHYs with IDs which match this field
@@ -448,7 +443,6 @@ struct phy_device {
  *   by this PHY
  * flags: A bitfield defining certain other features this PHY
  *   supports (like interrupts)
- * driver_data: static driver data
  *
  * The drivers must implement config_aneg and read_status.  All
  * other functions are optional. Note that none of these
@@ -459,6 +453,7 @@ struct phy_device {
  * supported in the driver).
  */
 struct phy_driver {
+        struct mdio_driver_common mdiodrv;
         u32 phy_id;
         char *name;
         unsigned int phy_id_mask;
@@ -589,9 +584,14 @@ struct phy_driver {
         int (*module_eeprom)(struct phy_device *dev,
                              struct ethtool_eeprom *ee, u8 *data);
 
-        struct device_driver driver;
+        /* Get statistics from the phy using ethtool */
+        int (*get_sset_count)(struct phy_device *dev);
+        void (*get_strings)(struct phy_device *dev, u8 *data);
+        void (*get_stats)(struct phy_device *dev,
+                          struct ethtool_stats *stats, u64 *data);
 };
-#define to_phy_driver(d) container_of(d, struct phy_driver, driver)
+#define to_phy_driver(d) container_of(to_mdio_common_driver(d),         \
+                                      struct phy_driver, mdiodrv)
 
 #define PHY_ANY_ID "MATCH ANY PHY"
 #define PHY_ANY_UID 0xffffffff
@@ -619,7 +619,7 @@ static inline int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
         if (!phydev->is_c45)
                 return -EOPNOTSUPP;
 
-        return mdiobus_read(phydev->bus, phydev->addr,
+        return mdiobus_read(phydev->mdio.bus, phydev->mdio.addr,
                             MII_ADDR_C45 | (devad << 16) | (regnum & 0xffff));
 }
 
@@ -627,14 +627,12 @@ static inline int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
  * phy_read_mmd_indirect - reads data from the MMD registers
  * @phydev: The PHY device bus
  * @prtad: MMD Address
- * @devad: MMD DEVAD
  * @addr: PHY address on the MII bus
  *
  * Description: it reads data from the MMD registers (clause 22 to access to
  * clause 45) of the specified phy address.
  */
-int phy_read_mmd_indirect(struct phy_device *phydev, int prtad,
-                          int devad, int addr);
+int phy_read_mmd_indirect(struct phy_device *phydev, int prtad, int devad);
 
 /**
  * phy_read - Convenience function for reading a given PHY register
@@ -647,7 +645,7 @@ int phy_read_mmd_indirect(struct phy_device *phydev, int prtad,
  */
 static inline int phy_read(struct phy_device *phydev, u32 regnum)
 {
-        return mdiobus_read(phydev->bus, phydev->addr, regnum);
+        return mdiobus_read(phydev->mdio.bus, phydev->mdio.addr, regnum);
 }
 
 /**
@@ -662,7 +660,7 @@ static inline int phy_read(struct phy_device *phydev, u32 regnum)
  */
 static inline int phy_write(struct phy_device *phydev, u32 regnum, u16 val)
 {
-        return mdiobus_write(phydev->bus, phydev->addr, regnum, val);
+        return mdiobus_write(phydev->mdio.bus, phydev->mdio.addr, regnum, val);
 }
 
 /**
@@ -725,7 +723,7 @@ static inline int phy_write_mmd(struct phy_device *phydev, int devad,
 
         regnum = MII_ADDR_C45 | ((devad & 0x1f) << 16) | (regnum & 0xffff);
 
-        return mdiobus_write(phydev->bus, phydev->addr, regnum, val);
+        return mdiobus_write(phydev->mdio.bus, phydev->mdio.addr, regnum, val);
 }
 
 /**
@@ -733,14 +731,13 @@ static inline int phy_write_mmd(struct phy_device *phydev, int devad,
  * @phydev: The PHY device
  * @prtad: MMD Address
  * @devad: MMD DEVAD
- * @addr: PHY address on the MII bus
  * @data: data to write in the MMD register
  *
  * Description: Write data from the MMD registers of the specified
  * phy address.
  */
 void phy_write_mmd_indirect(struct phy_device *phydev, int prtad,
-                            int devad, int addr, u32 data);
+                            int devad, u32 data);
 
 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
                                      bool is_c45,
@@ -775,6 +772,20 @@ static inline int phy_read_status(struct phy_device *phydev)
         return phydev->drv->read_status(phydev);
 }
 
+#define phydev_err(_phydev, format, args...)    \
+        dev_err(&_phydev->mdio.dev, format, ##args)
+
+#define phydev_dbg(_phydev, format, args...)    \
+        dev_dbg(&_phydev->mdio.dev, format, ##args);
+
+static inline const char *phydev_name(const struct phy_device *phydev)
+{
+        return dev_name(&phydev->mdio.dev);
+}
+
+void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
+        __printf(2, 3);
+void phy_attached_info(struct phy_device *phydev);
 int genphy_config_init(struct phy_device *phydev);
 int genphy_setup_forced(struct phy_device *phydev);
 int genphy_restart_aneg(struct phy_device *phydev);
@@ -787,8 +798,9 @@ int genphy_resume(struct phy_device *phydev);
 int genphy_soft_reset(struct phy_device *phydev);
 void phy_driver_unregister(struct phy_driver *drv);
 void phy_drivers_unregister(struct phy_driver *drv, int n);
-int phy_driver_register(struct phy_driver *new_driver);
-int phy_drivers_register(struct phy_driver *new_driver, int n);
+int phy_driver_register(struct phy_driver *new_driver, struct module *owner);
+int phy_drivers_register(struct phy_driver *new_driver, int n,
+                         struct module *owner);
 void phy_state_machine(struct work_struct *work);
 void phy_change(struct work_struct *work);
 void phy_mac_interrupt(struct phy_device *phydev, int new_link);
@@ -833,7 +845,7 @@ extern struct bus_type mdio_bus_type;
 #define phy_module_driver(__phy_drivers, __count)                       \
 static int __init phy_module_init(void)                                 \
 {                                                                       \
-        return phy_drivers_register(__phy_drivers, __count);            \
+        return phy_drivers_register(__phy_drivers, __count, THIS_MODULE); \
 }                                                                       \
 module_init(phy_module_init);                                           \
 static void __exit phy_module_exit(void)                                \
diff --git a/include/linux/pim.h b/include/linux/pim.h
index 252bf6644c51..e1d756f81348 100644
--- a/include/linux/pim.h
+++ b/include/linux/pim.h
@@ -13,6 +13,11 @@
 
 #define PIM_NULL_REGISTER       cpu_to_be32(0x40000000)
 
+static inline bool ipmr_pimsm_enabled(void)
+{
+        return IS_BUILTIN(CONFIG_IP_PIMSM_V1) || IS_BUILTIN(CONFIG_IP_PIMSM_V2);
+}
+
 /* PIMv2 register message header layout (ietf-draft-idmr-pimvsm-v2-00.ps */
 struct pimreghdr
 {
diff --git a/include/linux/platform_data/microread.h b/include/linux/platform_data/microread.h
index cfda59b226ee..ca13992089b8 100644
--- a/include/linux/platform_data/microread.h
+++ b/include/linux/platform_data/microread.h
@@ -1,5 +1,5 @@
 /*
- * Driver include for the PN544 NFC chip.
+ * Driver include for the Inside Secure microread NFC Chip.
  *
  * Copyright (C) 2011 Tieto Poland
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
diff --git a/include/linux/qed/qed_if.h b/include/linux/qed/qed_if.h
index dc9a1353f971..d4a32e878180 100644
--- a/include/linux/qed/qed_if.h
+++ b/include/linux/qed/qed_if.h
@@ -25,6 +25,12 @@
 #include <linux/qed/common_hsi.h>
 #include <linux/qed/qed_chain.h>
 
+enum qed_led_mode {
+        QED_LED_MODE_OFF,
+        QED_LED_MODE_ON,
+        QED_LED_MODE_RESTORE
+};
+
 #define DIRECT_REG_WR(reg_addr, val) writel((u32)val, \
                                             (void __iomem *)(reg_addr))
 
@@ -252,6 +258,17 @@ struct qed_common_ops {
 
         void            (*chain_free)(struct qed_dev *cdev,
                                       struct qed_chain *p_chain);
+
+/**
+ * @brief set_led - Configure LED mode
+ *
+ * @param cdev
+ * @param mode - LED mode
+ *
+ * @return 0 on success, error otherwise.
+ */
+        int (*set_led)(struct qed_dev *cdev,
+                       enum qed_led_mode mode);
 };
 
 /**
diff --git a/include/linux/rhashtable.h b/include/linux/rhashtable.h
index e50b31d18462..63bd7601b6de 100644
--- a/include/linux/rhashtable.h
+++ b/include/linux/rhashtable.h
@@ -823,4 +823,86 @@ out:
         return err;
 }
 
+/* Internal function, please use rhashtable_replace_fast() instead */
+static inline int __rhashtable_replace_fast(
+        struct rhashtable *ht, struct bucket_table *tbl,
+        struct rhash_head *obj_old, struct rhash_head *obj_new,
+        const struct rhashtable_params params)
+{
+        struct rhash_head __rcu **pprev;
+        struct rhash_head *he;
+        spinlock_t *lock;
+        unsigned int hash;
+        int err = -ENOENT;
+
+        /* Minimally, the old and new objects must have same hash
+         * (which should mean identifiers are the same).
+         */
+        hash = rht_head_hashfn(ht, tbl, obj_old, params);
+        if (hash != rht_head_hashfn(ht, tbl, obj_new, params))
+                return -EINVAL;
+
+        lock = rht_bucket_lock(tbl, hash);
+
+        spin_lock_bh(lock);
+
+        pprev = &tbl->buckets[hash];
+        rht_for_each(he, tbl, hash) {
+                if (he != obj_old) {
+                        pprev = &he->next;
+                        continue;
+                }
+
+                rcu_assign_pointer(obj_new->next, obj_old->next);
+                rcu_assign_pointer(*pprev, obj_new);
+                err = 0;
+                break;
+        }
+
+        spin_unlock_bh(lock);
+
+        return err;
+}
+
+/**
+ * rhashtable_replace_fast - replace an object in hash table
+ * @ht:         hash table
+ * @obj_old:    pointer to hash head inside object being replaced
+ * @obj_new:    pointer to hash head inside object which is new
+ * @params:     hash table parameters
+ *
+ * Replacing an object doesn't affect the number of elements in the hash table
+ * or bucket, so we don't need to worry about shrinking or expanding the
+ * table here.
+ *
+ * Returns zero on success, -ENOENT if the entry could not be found,
+ * -EINVAL if hash is not the same for the old and new objects.
+ */
+static inline int rhashtable_replace_fast(
+        struct rhashtable *ht, struct rhash_head *obj_old,
+        struct rhash_head *obj_new,
+        const struct rhashtable_params params)
+{
+        struct bucket_table *tbl;
+        int err;
+
+        rcu_read_lock();
+
+        tbl = rht_dereference_rcu(ht->tbl, ht);
+
+        /* Because we have already taken (and released) the bucket
+         * lock in old_tbl, if we find that future_tbl is not yet
+         * visible then that guarantees the entry to still be in
+         * the old tbl if it exists.
+         */
+        while ((err = __rhashtable_replace_fast(ht, tbl, obj_old,
+                                                obj_new, params)) &&
+               (tbl = rht_dereference_rcu(tbl->future_tbl, ht)))
+                ;
+
+        rcu_read_unlock();
+
+        return err;
+}
+
 #endif /* _LINUX_RHASHTABLE_H */
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index 4be5048b1fbe..c006cc900c44 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -84,6 +84,11 @@ void net_inc_ingress_queue(void);
 void net_dec_ingress_queue(void);
 #endif
 
+#ifdef CONFIG_NET_EGRESS
+void net_inc_egress_queue(void);
+void net_dec_egress_queue(void);
+#endif
+
 extern void rtnetlink_init(void);
 extern void __rtnl_unlock(void);
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 4bae8ab3b893..61aa9bbea871 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -834,6 +834,7 @@ struct user_struct {
         unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */
 #endif
         unsigned long locked_shm; /* How many pages of mlocked shm ? */
+        unsigned long unix_inflight;    /* How many files in flight in unix sockets */
 
 #ifdef CONFIG_KEYS
         struct key *uid_keyring;        /* UID specific keyring */
diff --git a/include/linux/sh_eth.h b/include/linux/sh_eth.h
index 8c9131db2b25..f2e27e078362 100644
--- a/include/linux/sh_eth.h
+++ b/include/linux/sh_eth.h
@@ -4,7 +4,7 @@
 #include <linux/phy.h>
 #include <linux/if_ether.h>
 
-enum {EDMAC_LITTLE_ENDIAN, EDMAC_BIG_ENDIAN};
+enum {EDMAC_LITTLE_ENDIAN};
 
 struct sh_eth_plat_data {
         int phy;
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 4355129fff91..07f9ccd28654 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -39,11 +39,55 @@
 #include <linux/in6.h>
 #include <net/flow.h>
 
-/* A. Checksumming of received packets by device.
+/* The interface for checksum offload between the stack and networking drivers
+ * is as follows...
+ *
+ * A. IP checksum related features
+ *
+ * Drivers advertise checksum offload capabilities in the features of a device.
+ * From the stack's point of view these are capabilities offered by the driver,
+ * a driver typically only advertises features that it is capable of offloading
+ * to its device.
+ *
+ * The checksum related features are:
+ *
+ *      NETIF_F_HW_CSUM - The driver (or its device) is able to compute one
+ *                        IP (one's complement) checksum for any combination
+ *                        of protocols or protocol layering. The checksum is
+ *                        computed and set in a packet per the CHECKSUM_PARTIAL
+ *                        interface (see below).
+ *
+ *      NETIF_F_IP_CSUM - Driver (device) is only able to checksum plain
+ *                        TCP or UDP packets over IPv4. These are specifically
+ *                        unencapsulated packets of the form IPv4|TCP or
+ *                        IPv4|UDP where the Protocol field in the IPv4 header
+ *                        is TCP or UDP. The IPv4 header may contain IP options
+ *                        This feature cannot be set in features for a device
+ *                        with NETIF_F_HW_CSUM also set. This feature is being
+ *                        DEPRECATED (see below).
+ *
+ *      NETIF_F_IPV6_CSUM - Driver (device) is only able to checksum plain
+ *                        TCP or UDP packets over IPv6. These are specifically
+ *                        unencapsulated packets of the form IPv6|TCP or
+ *                        IPv4|UDP where the Next Header field in the IPv6
+ *                        header is either TCP or UDP. IPv6 extension headers
+ *                        are not supported with this feature. This feature
+ *                        cannot be set in features for a device with
+ *                        NETIF_F_HW_CSUM also set. This feature is being
+ *                        DEPRECATED (see below).
+ *
+ *      NETIF_F_RXCSUM - Driver (device) performs receive checksum offload.
+ *                       This flag is used only used to disable the RX checksum
+ *                       feature for a device. The stack will accept receive
+ *                       checksum indication in packets received on a device
+ *                       regardless of whether NETIF_F_RXCSUM is set.
+ *
+ * B. Checksumming of received packets by device. Indication of checksum
+ *    verification is in set skb->ip_summed. Possible values are:
  *
  * CHECKSUM_NONE:
  *
- *   Device failed to checksum this packet e.g. due to lack of capabilities.
+ *   Device did not checksum this packet e.g. due to lack of capabilities.
  *   The packet contains full (though not verified) checksum in packet but
  *   not in skb->csum. Thus, skb->csum is undefined in this case.
  *
@@ -53,9 +97,8 @@
  *   (as in CHECKSUM_COMPLETE), but it does parse headers and verify checksums
  *   for specific protocols. For such packets it will set CHECKSUM_UNNECESSARY
  *   if their checksums are okay. skb->csum is still undefined in this case
- *   though. It is a bad option, but, unfortunately, nowadays most vendors do
- *   this. Apparently with the secret goal to sell you new devices, when you
- *   will add new protocol to your host, f.e. IPv6 8)
+ *   though. A driver or device must never modify the checksum field in the
+ *   packet even if checksum is verified.
  *
  *   CHECKSUM_UNNECESSARY is applicable to following protocols:
  *     TCP: IPv6 and IPv4.
@@ -96,40 +139,77 @@
  *   packet that are after the checksum being offloaded are not considered to
  *   be verified.
  *
- * B. Checksumming on output.
- *
- * CHECKSUM_NONE:
- *
- *   The skb was already checksummed by the protocol, or a checksum is not
- *   required.
+ * C. Checksumming on transmit for non-GSO. The stack requests checksum offload
+ *    in the skb->ip_summed for a packet. Values are:
  *
  * CHECKSUM_PARTIAL:
  *
- *   The device is required to checksum the packet as seen by hard_start_xmit()
+ *   The driver is required to checksum the packet as seen by hard_start_xmit()
  *   from skb->csum_start up to the end, and to record/write the checksum at
- *   offset skb->csum_start + skb->csum_offset.
+ *   offset skb->csum_start + skb->csum_offset. A driver may verify that the
+ *   csum_start and csum_offset values are valid values given the length and
+ *   offset of the packet, however they should not attempt to validate that the
+ *   checksum refers to a legitimate transport layer checksum-- it is the
+ *   purview of the stack to validate that csum_start and csum_offset are set
+ *   correctly.
+ *
+ *   When the stack requests checksum offload for a packet, the driver MUST
+ *   ensure that the checksum is set correctly. A driver can either offload the
+ *   checksum calculation to the device, or call skb_checksum_help (in the case
+ *   that the device does not support offload for a particular checksum).
+ *
+ *   NETIF_F_IP_CSUM and NETIF_F_IPV6_CSUM are being deprecated in favor of
+ *   NETIF_F_HW_CSUM. New devices should use NETIF_F_HW_CSUM to indicate
+ *   checksum offload capability. If a  device has limited checksum capabilities
+ *   (for instance can only perform NETIF_F_IP_CSUM or NETIF_F_IPV6_CSUM as
+ *   described above) a helper function can be called to resolve
+ *   CHECKSUM_PARTIAL. The helper functions are skb_csum_off_chk*. The helper
+ *   function takes a spec argument that describes the protocol layer that is
+ *   supported for checksum offload and can be called for each packet. If a
+ *   packet does not match the specification for offload, skb_checksum_help
+ *   is called to resolve the checksum.
  *
- *   The device must show its capabilities in dev->features, set up at device
- *   setup time, e.g. netdev_features.h:
+ * CHECKSUM_NONE:
  *
- *      NETIF_F_HW_CSUM - It's a clever device, it's able to checksum everything.
- *      NETIF_F_IP_CSUM - Device is dumb, it's able to checksum only TCP/UDP over
- *                        IPv4. Sigh. Vendors like this way for an unknown reason.
- *                        Though, see comment above about CHECKSUM_UNNECESSARY. 8)
- *      NETIF_F_IPV6_CSUM - About as dumb as the last one but does IPv6 instead.
- *      NETIF_F_...     - Well, you get the picture.
+ *   The skb was already checksummed by the protocol, or a checksum is not
+ *   required.
  *
  * CHECKSUM_UNNECESSARY:
  *
- *   Normally, the device will do per protocol specific checksumming. Protocol
- *   implementations that do not want the NIC to perform the checksum
- *   calculation should use this flag in their outgoing skbs.
- *
- *      NETIF_F_FCOE_CRC - This indicates that the device can do FCoE FC CRC
- *                         offload. Correspondingly, the FCoE protocol driver
- *                         stack should use CHECKSUM_UNNECESSARY.
+ *   This has the same meaning on as CHECKSUM_NONE for checksum offload on
+ *   output.
  *
- * Any questions? No questions, good.           --ANK
+ * CHECKSUM_COMPLETE:
+ *   Not used in checksum output. If a driver observes a packet with this value
+ *   set in skbuff, if should treat as CHECKSUM_NONE being set.
+ *
+ * D. Non-IP checksum (CRC) offloads
+ *
+ *   NETIF_F_SCTP_CRC - This feature indicates that a device is capable of
+ *     offloading the SCTP CRC in a packet. To perform this offload the stack
+ *     will set ip_summed to CHECKSUM_PARTIAL and set csum_start and csum_offset
+ *     accordingly. Note the there is no indication in the skbuff that the
+ *     CHECKSUM_PARTIAL refers to an SCTP checksum, a driver that supports
+ *     both IP checksum offload and SCTP CRC offload must verify which offload
+ *     is configured for a packet presumably by inspecting packet headers.
+ *
+ *   NETIF_F_FCOE_CRC - This feature indicates that a device is capable of
+ *     offloading the FCOE CRC in a packet. To perform this offload the stack
+ *     will set ip_summed to CHECKSUM_PARTIAL and set csum_start and csum_offset
+ *     accordingly. Note the there is no indication in the skbuff that the
+ *     CHECKSUM_PARTIAL refers to an FCOE checksum, a driver that supports
+ *     both IP checksum offload and FCOE CRC offload must verify which offload
+ *     is configured for a packet presumably by inspecting packet headers.
+ *
+ * E. Checksumming on output with GSO.
+ *
+ * In the case of a GSO packet (skb_is_gso(skb) is true), checksum offload
+ * is implied by the SKB_GSO_* flags in gso_type. Most obviously, if the
+ * gso_type is SKB_GSO_TCPV4 or SKB_GSO_TCPV6, TCP checksum offload as
+ * part of the GSO operation is implied. If a checksum is being offloaded
+ * with GSO then ip_summed is CHECKSUM_PARTIAL, csum_start and csum_offset
+ * are set to refer to the outermost checksum being offload (two offloaded
+ * checksums are possible with UDP encapsulation).
  */
 
 /* Don't change this without changing skb_csum_unnecessary! */
@@ -833,7 +913,7 @@ struct sk_buff_fclones {
  *      skb_fclone_busy - check if fclone is busy
  *      @skb: buffer
  *
- * Returns true is skb is a fast clone, and its clone is not freed.
+ * Returns true if skb is a fast clone, and its clone is not freed.
  * Some drivers call skb_orphan() in their ndo_start_xmit(),
  * so we also check that this didnt happen.
  */
@@ -1082,9 +1162,6 @@ static inline void skb_copy_hash(struct sk_buff *to, const struct sk_buff *from)
 
 static inline void skb_sender_cpu_clear(struct sk_buff *skb)
 {
-#ifdef CONFIG_XPS
-        skb->sender_cpu = 0;
-#endif
 }
 
 #ifdef NET_SKBUFF_DATA_USES_OFFSET
@@ -1942,6 +2019,11 @@ static inline unsigned char *skb_inner_transport_header(const struct sk_buff
         return skb->head + skb->inner_transport_header;
 }
 
+static inline int skb_inner_transport_offset(const struct sk_buff *skb)
+{
+        return skb_inner_transport_header(skb) - skb->data;
+}
+
 static inline void skb_reset_inner_transport_header(struct sk_buff *skb)
 {
         skb->inner_transport_header = skb->data - skb->head;
@@ -2723,6 +2805,23 @@ static inline void skb_postpull_rcsum(struct sk_buff *skb,
 
 unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len);
 
+static inline void skb_postpush_rcsum(struct sk_buff *skb,
+                                      const void *start, unsigned int len)
+{
+        /* For performing the reverse operation to skb_postpull_rcsum(),
+         * we can instead of ...
+         *
+         *   skb->csum = csum_add(skb->csum, csum_partial(start, len, 0));
+         *
+         * ... just use this equivalent version here to save a few
+         * instructions. Feeding csum of 0 in csum_partial() and later
+         * on adding skb->csum is equivalent to feed skb->csum in the
+         * first place.
+         */
+        if (skb->ip_summed == CHECKSUM_COMPLETE)
+                skb->csum = csum_partial(start, len, skb->csum);
+}
+
 /**
  *      pskb_trim_rcsum - trim received skb and update checksum
  *      @skb: buffer to trim
@@ -2788,6 +2887,12 @@ static inline void skb_frag_list_init(struct sk_buff *skb)
 #define skb_walk_frags(skb, iter)       \
         for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next)
 
+
+int __skb_wait_for_more_packets(struct sock *sk, int *err, long *timeo_p,
+                                const struct sk_buff *skb);
+struct sk_buff *__skb_try_recv_datagram(struct sock *sk, unsigned flags,
+                                        int *peeked, int *off, int *err,
+                                        struct sk_buff **last);
 struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
                                     int *peeked, int *off, int *err);
 struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock,
diff --git a/include/linux/soc/ti/knav_dma.h b/include/linux/soc/ti/knav_dma.h
index dad035c16d94..343c13ac4f71 100644
--- a/include/linux/soc/ti/knav_dma.h
+++ b/include/linux/soc/ti/knav_dma.h
@@ -144,17 +144,17 @@ struct knav_dma_cfg {
  * @psdata:                     Protocol specific
  */
 struct knav_dma_desc {
-        u32     desc_info;
-        u32     tag_info;
-        u32     packet_info;
-        u32     buff_len;
-        u32     buff;
-        u32     next_desc;
-        u32     orig_len;
-        u32     orig_buff;
-        u32     epib[KNAV_DMA_NUM_EPIB_WORDS];
-        u32     psdata[KNAV_DMA_NUM_PS_WORDS];
-        u32     pad[4];
+        __le32  desc_info;
+        __le32  tag_info;
+        __le32  packet_info;
+        __le32  buff_len;
+        __le32  buff;
+        __le32  next_desc;
+        __le32  orig_len;
+        __le32  orig_buff;
+        __le32  epib[KNAV_DMA_NUM_EPIB_WORDS];
+        __le32  psdata[KNAV_DMA_NUM_PS_WORDS];
+        __le32  pad[4];
 } ____cacheline_aligned;
 
 #if IS_ENABLED(CONFIG_KEYSTONE_NAVIGATOR_DMA)
diff --git a/include/linux/sock_diag.h b/include/linux/sock_diag.h
index fddebc617469..4018b48f2b3b 100644
--- a/include/linux/sock_diag.h
+++ b/include/linux/sock_diag.h
@@ -15,6 +15,7 @@ struct sock_diag_handler {
         __u8 family;
         int (*dump)(struct sk_buff *skb, struct nlmsghdr *nlh);
         int (*get_info)(struct sk_buff *skb, struct sock *sk);
+        int (*destroy)(struct sk_buff *skb, struct nlmsghdr *nlh);
 };
 
 int sock_diag_register(const struct sock_diag_handler *h);
@@ -68,4 +69,5 @@ bool sock_diag_has_destroy_listeners(const struct sock *sk)
 }
 void sock_diag_broadcast_destroy(struct sock *sk);
 
+int sock_diag_destroy(struct sock *sk, int err);
 #endif
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index c3d1a525bacc..26a0b3c3ce5f 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -524,13 +524,9 @@ struct ssb_init_invariants {
 typedef int (*ssb_invariants_func_t)(struct ssb_bus *bus,
                                      struct ssb_init_invariants *iv);
 
-/* Register a SSB system bus. get_invariants() is called after the
- * basic system devices are initialized.
- * The invariants are usually fetched from some NVRAM.
- * Put the invariants into the struct pointed to by iv. */
-extern int ssb_bus_ssbbus_register(struct ssb_bus *bus,
-                                   unsigned long baseaddr,
-                                   ssb_invariants_func_t get_invariants);
+/* Register SoC bus. */
+extern int ssb_bus_host_soc_register(struct ssb_bus *bus,
+                                     unsigned long baseaddr);
 #ifdef CONFIG_SSB_PCIHOST
 extern int ssb_bus_pcibus_register(struct ssb_bus *bus,
                                    struct pci_dev *host_pci);
diff --git a/include/linux/wait.h b/include/linux/wait.h
index d2f4ec7dba7c..ae71a769b89e 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -137,6 +137,27 @@ static inline int waitqueue_active(wait_queue_head_t *q)
         return !list_empty(&q->task_list);
 }
 
+/**
+ * wq_has_sleeper - check if there are any waiting processes
+ * @wq: wait queue head
+ *
+ * Returns true if wq has waiting processes
+ *
+ * Please refer to the comment for waitqueue_active.
+ */
+static inline bool wq_has_sleeper(wait_queue_head_t *wq)
+{
+        /*
+         * We need to be sure we are in sync with the
+         * add_wait_queue modifications to the wait queue.
+         *
+         * This memory barrier should be paired with one on the
+         * waiting side.
+         */
+        smp_mb();
+        return waitqueue_active(wq);
+}
+
 extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
 extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait);
 extern void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
diff --git a/include/net/6lowpan.h b/include/net/6lowpan.h
index cf3bc564ac03..2f6a3f2233ed 100644
--- a/include/net/6lowpan.h
+++ b/include/net/6lowpan.h
@@ -53,6 +53,8 @@
 #ifndef __6LOWPAN_H__
 #define __6LOWPAN_H__
 
+#include <linux/debugfs.h>
+
 #include <net/ipv6.h>
 #include <net/net_namespace.h>
 
@@ -98,6 +100,7 @@ enum lowpan_lltypes {
 
 struct lowpan_priv {
         enum lowpan_lltypes lltype;
+        struct dentry *iface_debugfs;
 
         /* must be last */
         u8 priv[0] __aligned(sizeof(void *));
@@ -185,7 +188,12 @@ static inline void lowpan_push_hc_data(u8 **hc_ptr, const void *data,
         *hc_ptr += len;
 }
 
-void lowpan_netdev_setup(struct net_device *dev, enum lowpan_lltypes lltype);
+int lowpan_register_netdevice(struct net_device *dev,
+                              enum lowpan_lltypes lltype);
+int lowpan_register_netdev(struct net_device *dev,
+                           enum lowpan_lltypes lltype);
+void lowpan_unregister_netdevice(struct net_device *dev);
+void lowpan_unregister_netdev(struct net_device *dev);
 
 /**
  * lowpan_header_decompress - replace 6LoWPAN header with IPv6 header
diff --git a/include/net/addrconf.h b/include/net/addrconf.h
index 78003dfb8539..47f52d3cd8df 100644
--- a/include/net/addrconf.h
+++ b/include/net/addrconf.h
@@ -87,7 +87,8 @@ int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
                       u32 banned_flags);
 int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
                     u32 banned_flags);
-int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2);
+int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2,
+                         bool match_wildcard);
 void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr);
 void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr);
 
diff --git a/include/net/bluetooth/bluetooth.h b/include/net/bluetooth/bluetooth.h
index 42844d7b154a..bfd1590821d6 100644
--- a/include/net/bluetooth/bluetooth.h
+++ b/include/net/bluetooth/bluetooth.h
@@ -29,6 +29,8 @@
 #include <net/sock.h>
 #include <linux/seq_file.h>
 
+#define BT_SUBSYS_VERSION "2.21"
+
 #ifndef AF_BLUETOOTH
 #define AF_BLUETOOTH    31
 #define PF_BLUETOOTH    AF_BLUETOOTH
@@ -296,12 +298,17 @@ typedef void (*hci_req_complete_t)(struct hci_dev *hdev, u8 status, u16 opcode);
 typedef void (*hci_req_complete_skb_t)(struct hci_dev *hdev, u8 status,
                                        u16 opcode, struct sk_buff *skb);
 
+#define HCI_REQ_START   BIT(0)
+#define HCI_REQ_SKB     BIT(1)
+
 struct hci_ctrl {
         __u16 opcode;
-        bool req_start;
+        u8 req_flags;
         u8 req_event;
-        hci_req_complete_t req_complete;
-        hci_req_complete_skb_t req_complete_skb;
+        union {
+                hci_req_complete_t req_complete;
+                hci_req_complete_skb_t req_complete_skb;
+        };
 };
 
 struct bt_skb_cb {
@@ -316,15 +323,17 @@ struct bt_skb_cb {
 };
 #define bt_cb(skb) ((struct bt_skb_cb *)((skb)->cb))
 
+#define hci_skb_pkt_type(skb) bt_cb((skb))->pkt_type
+#define hci_skb_expect(skb) bt_cb((skb))->expect
+#define hci_skb_opcode(skb) bt_cb((skb))->hci.opcode
+
 static inline struct sk_buff *bt_skb_alloc(unsigned int len, gfp_t how)
 {
         struct sk_buff *skb;
 
         skb = alloc_skb(len + BT_SKB_RESERVE, how);
-        if (skb) {
+        if (skb)
                 skb_reserve(skb, BT_SKB_RESERVE);
-                bt_cb(skb)->incoming  = 0;
-        }
         return skb;
 }
 
@@ -334,10 +343,8 @@ static inline struct sk_buff *bt_skb_send_alloc(struct sock *sk,
         struct sk_buff *skb;
 
         skb = sock_alloc_send_skb(sk, len + BT_SKB_RESERVE, nb, err);
-        if (skb) {
+        if (skb)
                 skb_reserve(skb, BT_SKB_RESERVE);
-                bt_cb(skb)->incoming  = 0;
-        }
 
         if (!skb && *err)
                 return NULL;
diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h
index 0205b80cc90b..339ea57be423 100644
--- a/include/net/bluetooth/hci.h
+++ b/include/net/bluetooth/hci.h
@@ -239,7 +239,6 @@ enum {
         HCI_LE_ENABLED,
         HCI_ADVERTISING,
         HCI_ADVERTISING_CONNECTABLE,
-        HCI_ADVERTISING_INSTANCE,
         HCI_CONNECTABLE,
         HCI_DISCOVERABLE,
         HCI_LIMITED_DISCOVERABLE,
@@ -452,7 +451,8 @@ enum {
 #define HCI_ERROR_REMOTE_POWER_OFF      0x15
 #define HCI_ERROR_LOCAL_HOST_TERM       0x16
 #define HCI_ERROR_PAIRING_NOT_ALLOWED   0x18
-#define HCI_ERROR_INVALID_LL_PARAMS     0x1E
+#define HCI_ERROR_INVALID_LL_PARAMS     0x1e
+#define HCI_ERROR_UNSPECIFIED           0x1f
 #define HCI_ERROR_ADVERTISING_TIMEOUT   0x3c
 
 /* Flow control modes */
diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index 1878d0a96333..d4f82edb5cff 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -77,6 +77,7 @@ struct discovery_state {
         u8                      last_adv_data_len;
         bool                    report_invalid_rssi;
         bool                    result_filtering;
+        bool                    limited;
         s8                      rssi;
         u16                     uuid_count;
         u8                      (*uuids)[16];
@@ -327,6 +328,14 @@ struct hci_dev {
         struct work_struct      cmd_work;
         struct work_struct      tx_work;
 
+        struct work_struct      discov_update;
+        struct work_struct      bg_scan_update;
+        struct work_struct      scan_update;
+        struct work_struct      connectable_update;
+        struct work_struct      discoverable_update;
+        struct delayed_work     le_scan_disable;
+        struct delayed_work     le_scan_restart;
+
         struct sk_buff_head     rx_q;
         struct sk_buff_head     raw_q;
         struct sk_buff_head     cmd_q;
@@ -370,9 +379,6 @@ struct hci_dev {
 
         DECLARE_BITMAP(dev_flags, __HCI_NUM_FLAGS);
 
-        struct delayed_work     le_scan_disable;
-        struct delayed_work     le_scan_restart;
-
         __s8                    adv_tx_power;
         __u8                    adv_data[HCI_MAX_AD_LENGTH];
         __u8                    adv_data_len;
@@ -875,7 +881,7 @@ struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle);
 
 struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
                                      u8 dst_type, u8 sec_level,
-                                     u16 conn_timeout, u8 role);
+                                     u16 conn_timeout);
 struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
                                 u8 dst_type, u8 sec_level, u16 conn_timeout,
                                 u8 role);
@@ -1036,7 +1042,6 @@ struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev,
 struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev,
                                             bdaddr_t *addr, u8 addr_type);
 void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type);
-void hci_conn_params_clear_all(struct hci_dev *hdev);
 void hci_conn_params_clear_disabled(struct hci_dev *hdev);
 
 struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list,
@@ -1279,31 +1284,41 @@ static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
         mutex_unlock(&hci_cb_list_lock);
 }
 
-static inline bool eir_has_data_type(u8 *data, size_t data_len, u8 type)
+static inline void *eir_get_data(u8 *eir, size_t eir_len, u8 type,
+                                 size_t *data_len)
 {
         size_t parsed = 0;
 
-        if (data_len < 2)
-                return false;
+        if (eir_len < 2)
+                return NULL;
 
-        while (parsed < data_len - 1) {
-                u8 field_len = data[0];
+        while (parsed < eir_len - 1) {
+                u8 field_len = eir[0];
 
                 if (field_len == 0)
                         break;
 
                 parsed += field_len + 1;
 
-                if (parsed > data_len)
+                if (parsed > eir_len)
                         break;
 
-                if (data[1] == type)
-                        return true;
+                if (eir[1] != type) {
+                        eir += field_len + 1;
+                        continue;
+                }
+
+                /* Zero length data */
+                if (field_len == 1)
+                        return NULL;
 
-                data += field_len + 1;
+                if (data_len)
+                        *data_len = field_len - 1;
+
+                return &eir[2];
         }
 
-        return false;
+        return NULL;
 }
 
 static inline bool hci_bdaddr_is_rpa(bdaddr_t *bdaddr, u8 addr_type)
@@ -1431,10 +1446,8 @@ int mgmt_new_settings(struct hci_dev *hdev);
 void mgmt_index_added(struct hci_dev *hdev);
 void mgmt_index_removed(struct hci_dev *hdev);
 void mgmt_set_powered_failed(struct hci_dev *hdev, int err);
-int mgmt_powered(struct hci_dev *hdev, u8 powered);
-int mgmt_update_adv_data(struct hci_dev *hdev);
-void mgmt_discoverable_timeout(struct hci_dev *hdev);
-void mgmt_adv_timeout_expired(struct hci_dev *hdev);
+void mgmt_power_on(struct hci_dev *hdev, int err);
+void __mgmt_power_off(struct hci_dev *hdev);
 void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
                        bool persistent);
 void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
@@ -1473,6 +1486,8 @@ void mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
 void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
                                     u8 status);
 void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
+void mgmt_start_discovery_complete(struct hci_dev *hdev, u8 status);
+void mgmt_stop_discovery_complete(struct hci_dev *hdev, u8 status);
 void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
                        u8 addr_type, u8 *dev_class, s8 rssi, u32 flags,
                        u8 *eir, u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len);
@@ -1487,8 +1502,15 @@ void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
 void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr,
                          u8 bdaddr_type, u8 store_hint, u16 min_interval,
                          u16 max_interval, u16 latency, u16 timeout);
-void mgmt_reenable_advertising(struct hci_dev *hdev);
 void mgmt_smp_complete(struct hci_conn *conn, bool complete);
+bool mgmt_get_connectable(struct hci_dev *hdev);
+void mgmt_set_connectable_complete(struct hci_dev *hdev, u8 status);
+void mgmt_set_discoverable_complete(struct hci_dev *hdev, u8 status);
+u8 mgmt_get_adv_discov_flags(struct hci_dev *hdev);
+void mgmt_advertising_added(struct sock *sk, struct hci_dev *hdev,
+                            u8 instance);
+void mgmt_advertising_removed(struct sock *sk, struct hci_dev *hdev,
+                              u8 instance);
 
 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
                       u16 to_multiplier);
diff --git a/include/net/bluetooth/hci_mon.h b/include/net/bluetooth/hci_mon.h
index 2b67567cf28d..587d0131b349 100644
--- a/include/net/bluetooth/hci_mon.h
+++ b/include/net/bluetooth/hci_mon.h
@@ -43,6 +43,8 @@ struct hci_mon_hdr {
 #define HCI_MON_CLOSE_INDEX     9
 #define HCI_MON_INDEX_INFO      10
 #define HCI_MON_VENDOR_DIAG     11
+#define HCI_MON_SYSTEM_NOTE     12
+#define HCI_MON_USER_LOGGING    13
 
 struct hci_mon_new_index {
         __u8            type;
diff --git a/include/net/bluetooth/hci_sock.h b/include/net/bluetooth/hci_sock.h
index 9a46d665c1b5..8e9138acdae1 100644
--- a/include/net/bluetooth/hci_sock.h
+++ b/include/net/bluetooth/hci_sock.h
@@ -45,6 +45,7 @@ struct sockaddr_hci {
 #define HCI_CHANNEL_USER        1
 #define HCI_CHANNEL_MONITOR     2
 #define HCI_CHANNEL_CONTROL     3
+#define HCI_CHANNEL_LOGGING     4
 
 struct hci_filter {
         unsigned long type_mask;
diff --git a/include/net/bluetooth/mgmt.h b/include/net/bluetooth/mgmt.h
index b831242d48a4..ea73e0826aa7 100644
--- a/include/net/bluetooth/mgmt.h
+++ b/include/net/bluetooth/mgmt.h
@@ -571,6 +571,21 @@ struct mgmt_rp_remove_advertising {
         __u8    instance;
 } __packed;
 
+#define MGMT_OP_GET_ADV_SIZE_INFO       0x0040
+struct mgmt_cp_get_adv_size_info {
+        __u8    instance;
+        __le32  flags;
+} __packed;
+#define MGMT_GET_ADV_SIZE_INFO_SIZE     5
+struct mgmt_rp_get_adv_size_info {
+        __u8    instance;
+        __le32  flags;
+        __u8    max_adv_data_len;
+        __u8    max_scan_rsp_len;
+} __packed;
+
+#define MGMT_OP_START_LIMITED_DISCOVERY 0x0041
+
 #define MGMT_EV_CMD_COMPLETE            0x0001
 struct mgmt_ev_cmd_complete {
         __le16  opcode;
diff --git a/include/net/bonding.h b/include/net/bonding.h
index c1740a2794a3..ee6c52053aa3 100644
--- a/include/net/bonding.h
+++ b/include/net/bonding.h
@@ -165,7 +165,8 @@ struct slave {
         u8     backup:1,   /* indicates backup slave. Value corresponds with
                               BOND_STATE_ACTIVE and BOND_STATE_BACKUP */
                inactive:1, /* indicates inactive slave */
-               should_notify:1; /* indicateds whether the state changed */
+               should_notify:1, /* indicates whether the state changed */
+               should_notify_link:1; /* indicates whether the link changed */
         u8     duplex;
         u32    original_mtu;
         u32    link_failure_count;
@@ -246,6 +247,7 @@ struct bonding {
         ((struct slave *) rtnl_dereference(dev->rx_handler_data))
 
 void bond_queue_slave_event(struct slave *slave);
+void bond_lower_state_changed(struct slave *slave);
 
 struct bond_vlan_tag {
         __be16          vlan_proto;
@@ -327,6 +329,7 @@ static inline void bond_set_active_slave(struct slave *slave)
         if (slave->backup) {
                 slave->backup = 0;
                 bond_queue_slave_event(slave);
+                bond_lower_state_changed(slave);
                 rtmsg_ifinfo(RTM_NEWLINK, slave->dev, 0, GFP_ATOMIC);
         }
 }
@@ -336,6 +339,7 @@ static inline void bond_set_backup_slave(struct slave *slave)
         if (!slave->backup) {
                 slave->backup = 1;
                 bond_queue_slave_event(slave);
+                bond_lower_state_changed(slave);
                 rtmsg_ifinfo(RTM_NEWLINK, slave->dev, 0, GFP_ATOMIC);
         }
 }
@@ -348,6 +352,7 @@ static inline void bond_set_slave_state(struct slave *slave,
 
         slave->backup = slave_state;
         if (notify) {
+                bond_lower_state_changed(slave);
                 rtmsg_ifinfo(RTM_NEWLINK, slave->dev, 0, GFP_ATOMIC);
                 bond_queue_slave_event(slave);
                 slave->should_notify = 0;
@@ -379,6 +384,7 @@ static inline void bond_slave_state_notify(struct bonding *bond)
 
         bond_for_each_slave(bond, tmp, iter) {
                 if (tmp->should_notify) {
+                        bond_lower_state_changed(tmp);
                         rtmsg_ifinfo(RTM_NEWLINK, tmp->dev, 0, GFP_ATOMIC);
                         tmp->should_notify = 0;
                 }
@@ -504,10 +510,37 @@ static inline bool bond_is_slave_inactive(struct slave *slave)
         return slave->inactive;
 }
 
-static inline void bond_set_slave_link_state(struct slave *slave, int state)
+static inline void bond_set_slave_link_state(struct slave *slave, int state,
+                                             bool notify)
 {
+        if (slave->link == state)
+                return;
+
         slave->link = state;
-        bond_queue_slave_event(slave);
+        if (notify) {
+                bond_queue_slave_event(slave);
+                bond_lower_state_changed(slave);
+                slave->should_notify_link = 0;
+        } else {
+                if (slave->should_notify_link)
+                        slave->should_notify_link = 0;
+                else
+                        slave->should_notify_link = 1;
+        }
+}
+
+static inline void bond_slave_link_notify(struct bonding *bond)
+{
+        struct list_head *iter;
+        struct slave *tmp;
+
+        bond_for_each_slave(bond, tmp, iter) {
+                if (tmp->should_notify_link) {
+                        bond_queue_slave_event(tmp);
+                        bond_lower_state_changed(tmp);
+                        tmp->should_notify_link = 0;
+                }
+        }
 }
 
 static inline __be32 bond_confirm_addr(struct net_device *dev, __be32 dst, __be32 local)
diff --git a/include/net/busy_poll.h b/include/net/busy_poll.h
index 1d67fb6b23a0..2fbeb1313c0f 100644
--- a/include/net/busy_poll.h
+++ b/include/net/busy_poll.h
@@ -72,50 +72,7 @@ static inline bool busy_loop_timeout(unsigned long end_time)
         return time_after(now, end_time);
 }
 
-/* when used in sock_poll() nonblock is known at compile time to be true
- * so the loop and end_time will be optimized out
- */
-static inline bool sk_busy_loop(struct sock *sk, int nonblock)
-{
-        unsigned long end_time = !nonblock ? sk_busy_loop_end_time(sk) : 0;
-        const struct net_device_ops *ops;
-        struct napi_struct *napi;
-        int rc = false;
-
-        /*
-         * rcu read lock for napi hash
-         * bh so we don't race with net_rx_action
-         */
-        rcu_read_lock_bh();
-
-        napi = napi_by_id(sk->sk_napi_id);
-        if (!napi)
-                goto out;
-
-        ops = napi->dev->netdev_ops;
-        if (!ops->ndo_busy_poll)
-                goto out;
-
-        do {
-                rc = ops->ndo_busy_poll(napi);
-
-                if (rc == LL_FLUSH_FAILED)
-                        break; /* permanent failure */
-
-                if (rc > 0)
-                        /* local bh are disabled so it is ok to use _BH */
-                        NET_ADD_STATS_BH(sock_net(sk),
-                                         LINUX_MIB_BUSYPOLLRXPACKETS, rc);
-                cpu_relax();
-
-        } while (!nonblock && skb_queue_empty(&sk->sk_receive_queue) &&
-                 !need_resched() && !busy_loop_timeout(end_time));
-
-        rc = !skb_queue_empty(&sk->sk_receive_queue);
-out:
-        rcu_read_unlock_bh();
-        return rc;
-}
+bool sk_busy_loop(struct sock *sk, int nonblock);
 
 /* used in the NIC receive handler to mark the skb */
 static inline void skb_mark_napi_id(struct sk_buff *skb,
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index 2c7bdb81d30c..9bcaaf7cd15a 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -2321,6 +2321,8 @@ struct cfg80211_qos_map {
  *      the driver, and will be valid until passed to cfg80211_scan_done().
  *      For scan results, call cfg80211_inform_bss(); you can call this outside
  *      the scan/scan_done bracket too.
+ * @abort_scan: Tell the driver to abort an ongoing scan. The driver shall
+ *      indicate the status of the scan through cfg80211_scan_done().
  *
  * @auth: Request to authenticate with the specified peer
  *      (invoked with the wireless_dev mutex held)
@@ -2593,6 +2595,7 @@ struct cfg80211_ops {
 
         int     (*scan)(struct wiphy *wiphy,
                         struct cfg80211_scan_request *request);
+        void    (*abort_scan)(struct wiphy *wiphy, struct wireless_dev *wdev);
 
         int     (*auth)(struct wiphy *wiphy, struct net_device *dev,
                         struct cfg80211_auth_request *req);
@@ -5173,8 +5176,11 @@ size_t ieee80211_ie_split_ric(const u8 *ies, size_t ielen,
  * buffer starts, which may be @ielen if the entire (remainder)
  * of the buffer should be used.
  */
-size_t ieee80211_ie_split(const u8 *ies, size_t ielen,
-                          const u8 *ids, int n_ids, size_t offset);
+static inline size_t ieee80211_ie_split(const u8 *ies, size_t ielen,
+                                        const u8 *ids, int n_ids, size_t offset)
+{
+        return ieee80211_ie_split_ric(ies, ielen, ids, n_ids, NULL, 0, offset);
+}
 
 /**
  * cfg80211_report_wowlan_wakeup - report wakeup from WoWLAN
diff --git a/include/net/checksum.h b/include/net/checksum.h
index 9fcaedf994ee..10a16b5bd1c7 100644
--- a/include/net/checksum.h
+++ b/include/net/checksum.h
@@ -165,7 +165,8 @@ static inline __wsum remcsum_adjust(void *ptr, __wsum csum,
         csum = csum_sub(csum, csum_partial(ptr, start, 0));
 
         /* Set derived checksum in packet */
-        delta = csum_sub(csum_fold(csum), *psum);
+        delta = csum_sub((__force __wsum)csum_fold(csum),
+                         (__force __wsum)*psum);
         *psum = csum_fold(csum);
 
         return delta;
diff --git a/include/net/cls_cgroup.h b/include/net/cls_cgroup.h
index ccd6d8bffa4d..c0a92e2c286d 100644
--- a/include/net/cls_cgroup.h
+++ b/include/net/cls_cgroup.h
@@ -41,13 +41,12 @@ static inline u32 task_cls_classid(struct task_struct *p)
         return classid;
 }
 
-static inline void sock_update_classid(struct sock *sk)
+static inline void sock_update_classid(struct sock_cgroup_data *skcd)
 {
         u32 classid;
 
         classid = task_cls_classid(current);
-        if (classid != sk->sk_classid)
-                sk->sk_classid = classid;
+        sock_cgroup_set_classid(skcd, classid);
 }
 
 static inline u32 task_get_classid(const struct sk_buff *skb)
@@ -64,17 +63,17 @@ static inline u32 task_get_classid(const struct sk_buff *skb)
          * softirqs always disables bh.
          */
         if (in_serving_softirq()) {
-                /* If there is an sk_classid we'll use that. */
+                /* If there is an sock_cgroup_classid we'll use that. */
                 if (!skb->sk)
                         return 0;
 
-                classid = skb->sk->sk_classid;
+                classid = sock_cgroup_classid(&skb->sk->sk_cgrp_data);
         }
 
         return classid;
 }
 #else /* !CONFIG_CGROUP_NET_CLASSID */
-static inline void sock_update_classid(struct sock *sk)
+static inline void sock_update_classid(struct sock_cgroup_data *skcd)
 {
 }
 
diff --git a/include/net/dsa.h b/include/net/dsa.h
index 82a4c6011173..26a0e86e611e 100644
--- a/include/net/dsa.h
+++ b/include/net/dsa.h
@@ -16,6 +16,7 @@
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 #include <linux/of.h>
+#include <linux/of_gpio.h>
 #include <linux/phy.h>
 #include <linux/phy_fixed.h>
 #include <linux/ethtool.h>
@@ -64,6 +65,13 @@ struct dsa_chip_data {
          * NULL if there is only one switch chip.
          */
         s8              *rtable;
+
+        /*
+         * A switch may have a GPIO line tied to its reset pin. Parse
+         * this from the device tree, and use it before performing
+         * switch soft reset.
+         */
+        struct gpio_desc *reset;
 };
 
 struct dsa_platform_data {
@@ -109,13 +117,6 @@ struct dsa_switch_tree {
         s8                      cpu_port;
 
         /*
-         * Link state polling.
-         */
-        int                     link_poll_needed;
-        struct work_struct      link_poll_work;
-        struct timer_list       link_poll_timer;
-
-        /*
          * Data for the individual switch chips.
          */
         struct dsa_switch       *ds[DSA_MAX_SWITCHES];
@@ -224,11 +225,6 @@ struct dsa_switch_driver {
                              int regnum, u16 val);
 
         /*
-         * Link state polling and IRQ handling.
-         */
-        void    (*poll_link)(struct dsa_switch *ds);
-
-        /*
          * Link state adjustment (called from libphy)
          */
         void    (*adjust_link)(struct dsa_switch *ds, int port,
diff --git a/include/net/genetlink.h b/include/net/genetlink.h
index 1b6b6dcb018d..43c0e771f417 100644
--- a/include/net/genetlink.h
+++ b/include/net/genetlink.h
@@ -114,6 +114,7 @@ static inline void genl_info_net_set(struct genl_info *info, struct net *net)
  * @flags: flags
  * @policy: attribute validation policy
  * @doit: standard command callback
+ * @start: start callback for dumps
  * @dumpit: callback for dumpers
  * @done: completion callback for dumps
  * @ops_list: operations list
@@ -122,6 +123,7 @@ struct genl_ops {
         const struct nla_policy *policy;
         int                    (*doit)(struct sk_buff *skb,
                                        struct genl_info *info);
+        int                    (*start)(struct netlink_callback *cb);
         int                    (*dumpit)(struct sk_buff *skb,
                                          struct netlink_callback *cb);
         int                    (*done)(struct netlink_callback *cb);
diff --git a/include/net/geneve.h b/include/net/geneve.h
index 3106ed6eae0d..e6c23dc765f7 100644
--- a/include/net/geneve.h
+++ b/include/net/geneve.h
@@ -62,6 +62,14 @@ struct genevehdr {
         struct geneve_opt options[];
 };
 
+#if IS_ENABLED(CONFIG_GENEVE)
+void geneve_get_rx_port(struct net_device *netdev);
+#else
+static inline void geneve_get_rx_port(struct net_device *netdev)
+{
+}
+#endif
+
 #ifdef CONFIG_INET
 struct net_device *geneve_dev_create_fb(struct net *net, const char *name,
                                         u8 name_assign_type, u16 dst_port);
diff --git a/include/net/ieee802154_netdev.h b/include/net/ieee802154_netdev.h
index a62a051a3a2f..c4b31601cd53 100644
--- a/include/net/ieee802154_netdev.h
+++ b/include/net/ieee802154_netdev.h
@@ -337,7 +337,7 @@ struct ieee802154_mlme_ops {
         void (*get_mac_params)(struct net_device *dev,
                                struct ieee802154_mac_params *params);
 
-        struct ieee802154_llsec_ops *llsec;
+        const struct ieee802154_llsec_ops *llsec;
 };
 
 static inline struct ieee802154_mlme_ops *
diff --git a/include/net/ila.h b/include/net/ila.h
new file mode 100644
index 000000000000..9f4f43e94ae4
--- /dev/null
+++ b/include/net/ila.h
@@ -0,0 +1,18 @@
+/*
+ * ILA kernel interface
+ *
+ * Copyright (c) 2015 Tom Herbert <tom@herbertland.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ */
+
+#ifndef _NET_ILA_H
+#define _NET_ILA_H
+
+int ila_xlat_outgoing(struct sk_buff *skb);
+int ila_xlat_incoming(struct sk_buff *skb);
+
+#endif /* _NET_ILA_H */
diff --git a/include/net/inet_frag.h b/include/net/inet_frag.h
index ac42bbb37b2d..12aac0fd6ee7 100644
--- a/include/net/inet_frag.h
+++ b/include/net/inet_frag.h
@@ -99,7 +99,6 @@ struct inet_frags {
         void                    (*constructor)(struct inet_frag_queue *q,
                                                const void *arg);
         void                    (*destructor)(struct inet_frag_queue *);
-        void                    (*skb_free)(struct sk_buff *);
         void                    (*frag_expire)(unsigned long data);
         struct kmem_cache       *frags_cachep;
         const char              *frags_cache_name;
diff --git a/include/net/inet_sock.h b/include/net/inet_sock.h
index 625bdf95d673..012b1f91f3ec 100644
--- a/include/net/inet_sock.h
+++ b/include/net/inet_sock.h
@@ -28,6 +28,7 @@
 #include <net/request_sock.h>
 #include <net/netns/hash.h>
 #include <net/tcp_states.h>
+#include <net/l3mdev.h>
 
 /** struct ip_options - IP Options
  *
@@ -113,6 +114,19 @@ static inline u32 inet_request_mark(const struct sock *sk, struct sk_buff *skb)
         return sk->sk_mark;
 }
 
+static inline int inet_request_bound_dev_if(const struct sock *sk,
+                                            struct sk_buff *skb)
+{
+#ifdef CONFIG_NET_L3_MASTER_DEV
+        struct net *net = sock_net(sk);
+
+        if (!sk->sk_bound_dev_if && net->ipv4.sysctl_tcp_l3mdev_accept)
+                return l3mdev_master_ifindex_by_index(net, skb->skb_iif);
+#endif
+
+        return sk->sk_bound_dev_if;
+}
+
 struct inet_cork {
         unsigned int            flags;
         __be32                  addr;
diff --git a/include/net/ip6_tunnel.h b/include/net/ip6_tunnel.h
index ff788b665277..0d0ce0b2d870 100644
--- a/include/net/ip6_tunnel.h
+++ b/include/net/ip6_tunnel.h
@@ -5,6 +5,7 @@
 #include <linux/netdevice.h>
 #include <linux/if_tunnel.h>
 #include <linux/ip6_tunnel.h>
+#include <net/ip_tunnels.h>
 
 #define IP6TUNNEL_ERR_TIMEO (30*HZ)
 
@@ -80,25 +81,17 @@ __u32 ip6_tnl_get_cap(struct ip6_tnl *t, const struct in6_addr *laddr,
 struct net *ip6_tnl_get_link_net(const struct net_device *dev);
 int ip6_tnl_get_iflink(const struct net_device *dev);
 
+#ifdef CONFIG_INET
 static inline void ip6tunnel_xmit(struct sock *sk, struct sk_buff *skb,
                                   struct net_device *dev)
 {
-        struct net_device_stats *stats = &dev->stats;
         int pkt_len, err;
 
         pkt_len = skb->len - skb_inner_network_offset(skb);
         err = ip6_local_out(dev_net(skb_dst(skb)->dev), sk, skb);
-
-        if (net_xmit_eval(err) == 0) {
-                struct pcpu_sw_netstats *tstats = get_cpu_ptr(dev->tstats);
-                u64_stats_update_begin(&tstats->syncp);
-                tstats->tx_bytes += pkt_len;
-                tstats->tx_packets++;
-                u64_stats_update_end(&tstats->syncp);
-                put_cpu_ptr(tstats);
-        } else {
-                stats->tx_errors++;
-                stats->tx_aborted_errors++;
-        }
+        if (unlikely(net_xmit_eval(err)))
+                pkt_len = -1;
+        iptunnel_xmit_stats(dev, pkt_len);
 }
 #endif
+#endif
diff --git a/include/net/ip_fib.h b/include/net/ip_fib.h
index 9f4df68105ab..7029527725dd 100644
--- a/include/net/ip_fib.h
+++ b/include/net/ip_fib.h
@@ -325,7 +325,8 @@ extern u32 fib_multipath_secret __read_mostly;
 
 static inline int fib_multipath_hash(__be32 saddr, __be32 daddr)
 {
-        return jhash_2words(saddr, daddr, fib_multipath_secret) >> 1;
+        return jhash_2words((__force u32)saddr, (__force u32)daddr,
+                            fib_multipath_secret) >> 1;
 }
 
 void fib_select_multipath(struct fib_result *res, int hash);
diff --git a/include/net/ip_tunnels.h b/include/net/ip_tunnels.h
index 62a750a6a8f8..6db96ea0144f 100644
--- a/include/net/ip_tunnels.h
+++ b/include/net/ip_tunnels.h
@@ -273,32 +273,34 @@ static inline u8 ip_tunnel_ecn_encap(u8 tos, const struct iphdr *iph,
 }
 
 int iptunnel_pull_header(struct sk_buff *skb, int hdr_len, __be16 inner_proto);
-int iptunnel_xmit(struct sock *sk, struct rtable *rt, struct sk_buff *skb,
-                  __be32 src, __be32 dst, u8 proto,
-                  u8 tos, u8 ttl, __be16 df, bool xnet);
+void iptunnel_xmit(struct sock *sk, struct rtable *rt, struct sk_buff *skb,
+                   __be32 src, __be32 dst, u8 proto,
+                   u8 tos, u8 ttl, __be16 df, bool xnet);
 struct metadata_dst *iptunnel_metadata_reply(struct metadata_dst *md,
                                              gfp_t flags);
 
 struct sk_buff *iptunnel_handle_offloads(struct sk_buff *skb, bool gre_csum,
                                          int gso_type_mask);
 
-static inline void iptunnel_xmit_stats(int err,
-                                       struct net_device_stats *err_stats,
-                                       struct pcpu_sw_netstats __percpu *stats)
+static inline void iptunnel_xmit_stats(struct net_device *dev, int pkt_len)
 {
-        if (err > 0) {
-                struct pcpu_sw_netstats *tstats = get_cpu_ptr(stats);
+        if (pkt_len > 0) {
+                struct pcpu_sw_netstats *tstats = get_cpu_ptr(dev->tstats);
 
                 u64_stats_update_begin(&tstats->syncp);
-                tstats->tx_bytes += err;
+                tstats->tx_bytes += pkt_len;
                 tstats->tx_packets++;
                 u64_stats_update_end(&tstats->syncp);
                 put_cpu_ptr(tstats);
-        } else if (err < 0) {
-                err_stats->tx_errors++;
-                err_stats->tx_aborted_errors++;
         } else {
-                err_stats->tx_dropped++;
+                struct net_device_stats *err_stats = &dev->stats;
+
+                if (pkt_len < 0) {
+                        err_stats->tx_errors++;
+                        err_stats->tx_aborted_errors++;
+                } else {
+                        err_stats->tx_dropped++;
+                }
         }
 }
 
diff --git a/include/net/ipv6.h b/include/net/ipv6.h
index 9a5c9f013784..6570f379aba2 100644
--- a/include/net/ipv6.h
+++ b/include/net/ipv6.h
@@ -401,6 +401,21 @@ static inline void ipv6_addr_prefix(struct in6_addr *pfx,
                 pfx->s6_addr[o] = addr->s6_addr[o] & (0xff00 >> b);
 }
 
+static inline void ipv6_addr_prefix_copy(struct in6_addr *addr,
+                                         const struct in6_addr *pfx,
+                                         int plen)
+{
+        /* caller must guarantee 0 <= plen <= 128 */
+        int o = plen >> 3,
+            b = plen & 0x7;
+
+        memcpy(addr->s6_addr, pfx, o);
+        if (b != 0) {
+                addr->s6_addr[o] &= ~(0xff00 >> b);
+                addr->s6_addr[o] |= (pfx->s6_addr[o] & (0xff00 >> b));
+        }
+}
+
 static inline void __ipv6_addr_set_half(__be32 *addr,
                                         __be32 wh, __be32 wl)
 {
diff --git a/include/net/l3mdev.h b/include/net/l3mdev.h
index 5689a0c749f7..5567d46b3cff 100644
--- a/include/net/l3mdev.h
+++ b/include/net/l3mdev.h
@@ -51,6 +51,24 @@ static inline int l3mdev_master_ifindex(struct net_device *dev)
         return ifindex;
 }
 
+static inline int l3mdev_master_ifindex_by_index(struct net *net, int ifindex)
+{
+        struct net_device *dev;
+        int rc = 0;
+
+        if (likely(ifindex)) {
+                rcu_read_lock();
+
+                dev = dev_get_by_index_rcu(net, ifindex);
+                if (dev)
+                        rc = l3mdev_master_ifindex_rcu(dev);
+
+                rcu_read_unlock();
+        }
+
+        return rc;
+}
+
 /* get index of an interface to use for FIB lookups. For devices
  * enslaved to an L3 master device FIB lookups are based on the
  * master index
@@ -170,6 +188,11 @@ static inline int l3mdev_master_ifindex(struct net_device *dev)
         return 0;
 }
 
+static inline int l3mdev_master_ifindex_by_index(struct net *net, int ifindex)
+{
+        return 0;
+}
+
 static inline int l3mdev_fib_oif_rcu(struct net_device *dev)
 {
         return dev ? dev->ifindex : 0;
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index 760bc4d5a2cf..7c30faff245f 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -1321,11 +1321,15 @@ struct ieee80211_channel_switch {
  *      interface. This flag should be set during interface addition,
  *      but may be set/cleared as late as authentication to an AP. It is
  *      only valid for managed/station mode interfaces.
+ * @IEEE80211_VIF_GET_NOA_UPDATE: request to handle NOA attributes
+ *      and send P2P_PS notification to the driver if NOA changed, even
+ *      this is not pure P2P vif.
  */
 enum ieee80211_vif_flags {
         IEEE80211_VIF_BEACON_FILTER             = BIT(0),
         IEEE80211_VIF_SUPPORTS_CQM_RSSI         = BIT(1),
         IEEE80211_VIF_SUPPORTS_UAPSD            = BIT(2),
+        IEEE80211_VIF_GET_NOA_UPDATE            = BIT(3),
 };
 
 /**
@@ -1901,6 +1905,11 @@ struct ieee80211_txq {
  * @IEEE80211_HW_BEACON_TX_STATUS: The device/driver provides TX status
  *      for sent beacons.
  *
+ * @IEEE80211_HW_NEEDS_UNIQUE_STA_ADDR: Hardware (or driver) requires that each
+ *      station has a unique address, i.e. each station entry can be identified
+ *      by just its MAC address; this prevents, for example, the same station
+ *      from connecting to two virtual AP interfaces at the same time.
+ *
  * @NUM_IEEE80211_HW_FLAGS: number of hardware flags, used for sizing arrays
  */
 enum ieee80211_hw_flags {
@@ -1936,6 +1945,7 @@ enum ieee80211_hw_flags {
         IEEE80211_HW_TDLS_WIDER_BW,
         IEEE80211_HW_SUPPORTS_AMSDU_IN_AMPDU,
         IEEE80211_HW_BEACON_TX_STATUS,
+        IEEE80211_HW_NEEDS_UNIQUE_STA_ADDR,
 
         /* keep last, obviously */
         NUM_IEEE80211_HW_FLAGS
@@ -4863,6 +4873,28 @@ void ieee80211_sta_block_awake(struct ieee80211_hw *hw,
 void ieee80211_sta_eosp(struct ieee80211_sta *pubsta);
 
 /**
+ * ieee80211_send_eosp_nullfunc - ask mac80211 to send NDP with EOSP
+ * @pubsta: the station
+ * @tid: the tid of the NDP
+ *
+ * Sometimes the device understands that it needs to close
+ * the Service Period unexpectedly. This can happen when
+ * sending frames that are filling holes in the BA window.
+ * In this case, the device can ask mac80211 to send a
+ * Nullfunc frame with EOSP set. When that happens, the
+ * driver must have called ieee80211_sta_set_buffered() to
+ * let mac80211 know that there are no buffered frames any
+ * more, otherwise mac80211 will get the more_data bit wrong.
+ * The low level driver must have made sure that the frame
+ * will be sent despite the station being in power-save.
+ * Mac80211 won't call allow_buffered_frames().
+ * Note that calling this function, doesn't exempt the driver
+ * from closing the EOSP properly, it will still have to call
+ * ieee80211_sta_eosp when the NDP is sent.
+ */
+void ieee80211_send_eosp_nullfunc(struct ieee80211_sta *pubsta, int tid);
+
+/**
  * ieee80211_iter_keys - iterate keys programmed into the device
  * @hw: pointer obtained from ieee80211_alloc_hw()
  * @vif: virtual interface to iterate, may be %NULL for all
@@ -4890,6 +4922,30 @@ void ieee80211_iter_keys(struct ieee80211_hw *hw,
                          void *iter_data);
 
 /**
+ * ieee80211_iter_keys_rcu - iterate keys programmed into the device
+ * @hw: pointer obtained from ieee80211_alloc_hw()
+ * @vif: virtual interface to iterate, may be %NULL for all
+ * @iter: iterator function that will be called for each key
+ * @iter_data: custom data to pass to the iterator function
+ *
+ * This function can be used to iterate all the keys known to
+ * mac80211, even those that weren't previously programmed into
+ * the device. Note that due to locking reasons, keys of station
+ * in removal process will be skipped.
+ *
+ * This function requires being called in an RCU critical section,
+ * and thus iter must be atomic.
+ */
+void ieee80211_iter_keys_rcu(struct ieee80211_hw *hw,
+                             struct ieee80211_vif *vif,
+                             void (*iter)(struct ieee80211_hw *hw,
+                                          struct ieee80211_vif *vif,
+                                          struct ieee80211_sta *sta,
+                                          struct ieee80211_key_conf *key,
+                                          void *data),
+                             void *iter_data);
+
+/**
  * ieee80211_iter_chan_contexts_atomic - iterate channel contexts
  * @hw: pointre obtained from ieee80211_alloc_hw().
  * @iter: iterator function
diff --git a/include/net/net_namespace.h b/include/net/net_namespace.h
index 2dcea635ecce..4089abc6e9c0 100644
--- a/include/net/net_namespace.h
+++ b/include/net/net_namespace.h
@@ -121,6 +121,9 @@ struct net {
 #if IS_ENABLED(CONFIG_NETFILTER_NETLINK_ACCT)
         struct list_head        nfnl_acct_list;
 #endif
+#if IS_ENABLED(CONFIG_NF_CT_NETLINK_TIMEOUT)
+        struct list_head        nfct_timeout_list;
+#endif
 #endif
 #ifdef CONFIG_WEXT_CORE
         struct sk_buff_head     wext_nlevents;
diff --git a/include/net/netfilter/ipv6/nf_defrag_ipv6.h b/include/net/netfilter/ipv6/nf_defrag_ipv6.h
index fb7da5bb76cc..ddf162f7966f 100644
--- a/include/net/netfilter/ipv6/nf_defrag_ipv6.h
+++ b/include/net/netfilter/ipv6/nf_defrag_ipv6.h
@@ -5,8 +5,7 @@ void nf_defrag_ipv6_enable(void);
 
 int nf_ct_frag6_init(void);
 void nf_ct_frag6_cleanup(void);
-struct sk_buff *nf_ct_frag6_gather(struct net *net, struct sk_buff *skb, u32 user);
-void nf_ct_frag6_consume_orig(struct sk_buff *skb);
+int nf_ct_frag6_gather(struct net *net, struct sk_buff *skb, u32 user);
 
 struct inet_frags_ctl;
 
diff --git a/include/net/netfilter/nf_conntrack_timeout.h b/include/net/netfilter/nf_conntrack_timeout.h
index f72be38860a7..5cc5e9e6171a 100644
--- a/include/net/netfilter/nf_conntrack_timeout.h
+++ b/include/net/netfilter/nf_conntrack_timeout.h
@@ -104,7 +104,7 @@ static inline void nf_conntrack_timeout_fini(void)
 #endif /* CONFIG_NF_CONNTRACK_TIMEOUT */
 
 #ifdef CONFIG_NF_CONNTRACK_TIMEOUT
-extern struct ctnl_timeout *(*nf_ct_timeout_find_get_hook)(const char *name);
+extern struct ctnl_timeout *(*nf_ct_timeout_find_get_hook)(struct net *net, const char *name);
 extern void (*nf_ct_timeout_put_hook)(struct ctnl_timeout *timeout);
 #endif
 
diff --git a/include/net/netfilter/nf_dup_netdev.h b/include/net/netfilter/nf_dup_netdev.h
new file mode 100644
index 000000000000..397dcae349f9
--- /dev/null
+++ b/include/net/netfilter/nf_dup_netdev.h
@@ -0,0 +1,6 @@
+#ifndef _NF_DUP_NETDEV_H_
+#define _NF_DUP_NETDEV_H_
+
+void nf_dup_netdev_egress(const struct nft_pktinfo *pkt, int oif);
+
+#endif
diff --git a/include/net/netfilter/nf_tables.h b/include/net/netfilter/nf_tables.h
index 4bd7508bedc9..f6b1daf2e698 100644
--- a/include/net/netfilter/nf_tables.h
+++ b/include/net/netfilter/nf_tables.h
@@ -19,8 +19,6 @@ struct nft_pktinfo {
         const struct net_device         *out;
         u8                              pf;
         u8                              hook;
-        u8                              nhoff;
-        u8                              thoff;
         u8                              tprot;
         /* for x_tables compatibility */
         struct xt_action_param          xt;
@@ -293,6 +291,8 @@ void nft_unregister_set(struct nft_set_ops *ops);
  *      @timeout: default timeout value in msecs
  *      @gc_int: garbage collection interval in msecs
  *      @policy: set parameterization (see enum nft_set_policies)
+ *      @udlen: user data length
+ *      @udata: user data
  *      @ops: set ops
  *      @pnet: network namespace
  *      @flags: set flags
@@ -312,6 +312,8 @@ struct nft_set {
         u64                             timeout;
         u32                             gc_int;
         u16                             policy;
+        u16                             udlen;
+        unsigned char                   *udata;
         /* runtime data below here */
         const struct nft_set_ops        *ops ____cacheline_aligned;
         possible_net_t                  pnet;
@@ -823,10 +825,7 @@ static inline struct nft_base_chain *nft_base_chain(const struct nft_chain *chai
         return container_of(chain, struct nft_base_chain, chain);
 }
 
-int nft_register_basechain(struct nft_base_chain *basechain,
-                           unsigned int hook_nops);
-void nft_unregister_basechain(struct nft_base_chain *basechain,
-                              unsigned int hook_nops);
+int __nft_release_basechain(struct nft_ctx *ctx);
 
 unsigned int nft_do_chain(struct nft_pktinfo *pkt, void *priv);
 
@@ -882,7 +881,7 @@ struct nft_af_info {
 };
 
 int nft_register_afinfo(struct net *, struct nft_af_info *);
-void nft_unregister_afinfo(struct nft_af_info *);
+void nft_unregister_afinfo(struct net *, struct nft_af_info *);
 
 int nft_register_chain_type(const struct nf_chain_type *);
 void nft_unregister_chain_type(const struct nf_chain_type *);
@@ -890,6 +889,38 @@ void nft_unregister_chain_type(const struct nf_chain_type *);
 int nft_register_expr(struct nft_expr_type *);
 void nft_unregister_expr(struct nft_expr_type *);
 
+int nft_verdict_dump(struct sk_buff *skb, int type,
+                     const struct nft_verdict *v);
+
+/**
+ *      struct nft_traceinfo - nft tracing information and state
+ *
+ *      @pkt: pktinfo currently processed
+ *      @basechain: base chain currently processed
+ *      @chain: chain currently processed
+ *      @rule:  rule that was evaluated
+ *      @verdict: verdict given by rule
+ *      @type: event type (enum nft_trace_types)
+ *      @packet_dumped: packet headers sent in a previous traceinfo message
+ *      @trace: other struct members are initialised
+ */
+struct nft_traceinfo {
+        const struct nft_pktinfo        *pkt;
+        const struct nft_base_chain     *basechain;
+        const struct nft_chain          *chain;
+        const struct nft_rule           *rule;
+        const struct nft_verdict        *verdict;
+        enum nft_trace_types            type;
+        bool                            packet_dumped;
+        bool                            trace;
+};
+
+void nft_trace_init(struct nft_traceinfo *info, const struct nft_pktinfo *pkt,
+                    const struct nft_verdict *verdict,
+                    const struct nft_chain *basechain);
+
+void nft_trace_notify(struct nft_traceinfo *info);
+
 #define nft_dereference(p)                                      \
         nfnl_dereference(p, NFNL_SUBSYS_NFTABLES)
 
diff --git a/include/net/netfilter/nf_tables_core.h b/include/net/netfilter/nf_tables_core.h
index c6f400cfaac8..a9060dd99db7 100644
--- a/include/net/netfilter/nf_tables_core.h
+++ b/include/net/netfilter/nf_tables_core.h
@@ -47,7 +47,17 @@ struct nft_payload {
         enum nft_registers      dreg:8;
 };
 
+struct nft_payload_set {
+        enum nft_payload_bases  base:8;
+        u8                      offset;
+        u8                      len;
+        enum nft_registers      sreg:8;
+        u8                      csum_type;
+        u8                      csum_offset;
+};
+
 extern const struct nft_expr_ops nft_payload_fast_ops;
+extern struct static_key_false nft_trace_enabled;
 
 int nft_payload_module_init(void);
 void nft_payload_module_exit(void);
diff --git a/include/net/netfilter/nft_meta.h b/include/net/netfilter/nft_meta.h
index 711887a09e91..d27588c8dbd9 100644
--- a/include/net/netfilter/nft_meta.h
+++ b/include/net/netfilter/nft_meta.h
@@ -33,4 +33,7 @@ void nft_meta_set_eval(const struct nft_expr *expr,
                        struct nft_regs *regs,
                        const struct nft_pktinfo *pkt);
 
+void nft_meta_set_destroy(const struct nft_ctx *ctx,
+                          const struct nft_expr *expr);
+
 #endif
diff --git a/include/net/netns/ipv4.h b/include/net/netns/ipv4.h
index c68926b4899c..2b7907a35568 100644
--- a/include/net/netns/ipv4.h
+++ b/include/net/netns/ipv4.h
@@ -86,11 +86,18 @@ struct netns_ipv4 {
 
         int sysctl_fwmark_reflect;
         int sysctl_tcp_fwmark_accept;
+#ifdef CONFIG_NET_L3_MASTER_DEV
+        int sysctl_tcp_l3mdev_accept;
+#endif
         int sysctl_tcp_mtu_probing;
         int sysctl_tcp_base_mss;
         int sysctl_tcp_probe_threshold;
         u32 sysctl_tcp_probe_interval;
 
+        int sysctl_tcp_keepalive_time;
+        int sysctl_tcp_keepalive_probes;
+        int sysctl_tcp_keepalive_intvl;
+
         struct ping_group_range ping_group_range;
 
         atomic_t dev_addr_genid;
diff --git a/include/net/netns/sctp.h b/include/net/netns/sctp.h
index 8ba379f9e467..c501d67172b1 100644
--- a/include/net/netns/sctp.h
+++ b/include/net/netns/sctp.h
@@ -89,6 +89,13 @@ struct netns_sctp {
         int pf_retrans;
 
         /*
+         * Disable Potentially-Failed feature, the feature is enabled by default
+         * pf_enable    -  0  : disable pf
+         *              - >0  : enable pf
+         */
+        int pf_enable;
+
+        /*
          * Policy for preforming sctp/socket accounting
          * 0   - do socket level accounting, all assocs share sk_sndbuf
          * 1   - do sctp accounting, each asoc may use sk_sndbuf bytes
diff --git a/include/net/netprio_cgroup.h b/include/net/netprio_cgroup.h
index f2a9597ff53c..604190596cde 100644
--- a/include/net/netprio_cgroup.h
+++ b/include/net/netprio_cgroup.h
@@ -25,8 +25,6 @@ struct netprio_map {
         u32 priomap[];
 };
 
-void sock_update_netprioidx(struct sock *sk);
-
 static inline u32 task_netprioidx(struct task_struct *p)
 {
         struct cgroup_subsys_state *css;
@@ -38,13 +36,25 @@ static inline u32 task_netprioidx(struct task_struct *p)
         rcu_read_unlock();
         return idx;
 }
+
+static inline void sock_update_netprioidx(struct sock_cgroup_data *skcd)
+{
+        if (in_interrupt())
+                return;
+
+        sock_cgroup_set_prioidx(skcd, task_netprioidx(current));
+}
+
 #else /* !CONFIG_CGROUP_NET_PRIO */
+
 static inline u32 task_netprioidx(struct task_struct *p)
 {
         return 0;
 }
 
-#define sock_update_netprioidx(sk)
+static inline void sock_update_netprioidx(struct sock_cgroup_data *skcd)
+{
+}
 
 #endif /* CONFIG_CGROUP_NET_PRIO */
 #endif  /* _NET_CLS_CGROUP_H */
diff --git a/include/net/nfc/nfc.h b/include/net/nfc/nfc.h
index dcfcfc9c00bf..1a3de8b34ad2 100644
--- a/include/net/nfc/nfc.h
+++ b/include/net/nfc/nfc.h
@@ -299,6 +299,7 @@ void nfc_driver_failure(struct nfc_dev *dev, int err);
 
 int nfc_se_transaction(struct nfc_dev *dev, u8 se_idx,
                        struct nfc_evt_transaction *evt_transaction);
+int nfc_se_connectivity(struct nfc_dev *dev, u8 se_idx);
 int nfc_add_se(struct nfc_dev *dev, u32 se_idx, u16 type);
 int nfc_remove_se(struct nfc_dev *dev, u32 se_idx);
 struct nfc_se *nfc_find_se(struct nfc_dev *dev, u32 se_idx);
diff --git a/include/net/protocol.h b/include/net/protocol.h
index d6fcc1fcdb5b..da689f5432de 100644
--- a/include/net/protocol.h
+++ b/include/net/protocol.h
@@ -107,7 +107,7 @@ int inet_del_offload(const struct net_offload *prot, unsigned char num);
 void inet_register_protosw(struct inet_protosw *p);
 void inet_unregister_protosw(struct inet_protosw *p);
 
-int  udp_add_offload(struct udp_offload *prot);
+int  udp_add_offload(struct net *net, struct udp_offload *prot);
 void udp_del_offload(struct udp_offload *prot);
 
 #if IS_ENABLED(CONFIG_IPV6)
diff --git a/include/net/request_sock.h b/include/net/request_sock.h
index a0dde04eb178..f49759decb28 100644
--- a/include/net/request_sock.h
+++ b/include/net/request_sock.h
@@ -68,7 +68,7 @@ struct request_sock {
         u32                             peer_secid;
 };
 
-static inline struct request_sock *inet_reqsk(struct sock *sk)
+static inline struct request_sock *inet_reqsk(const struct sock *sk)
 {
         return (struct request_sock *)sk;
 }
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index b2a8e6338576..636a362a0e03 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -407,6 +407,15 @@ bool tcf_destroy(struct tcf_proto *tp, bool force);
 void tcf_destroy_chain(struct tcf_proto __rcu **fl);
 int skb_do_redirect(struct sk_buff *);
 
+static inline bool skb_at_tc_ingress(const struct sk_buff *skb)
+{
+#ifdef CONFIG_NET_CLS_ACT
+        return G_TC_AT(skb->tc_verd) & AT_INGRESS;
+#else
+        return false;
+#endif
+}
+
 /* Reset all TX qdiscs greater then index of a device.  */
 static inline void qdisc_reset_all_tx_gt(struct net_device *dev, unsigned int i)
 {
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h
index ce13cf20f625..835aa2ed9870 100644
--- a/include/net/sctp/sctp.h
+++ b/include/net/sctp/sctp.h
@@ -126,8 +126,6 @@ int sctp_primitive_ASCONF(struct net *, struct sctp_association *, void *arg);
  */
 int sctp_rcv(struct sk_buff *skb);
 void sctp_v4_err(struct sk_buff *skb, u32 info);
-void sctp_hash_established(struct sctp_association *);
-void sctp_unhash_established(struct sctp_association *);
 void sctp_hash_endpoint(struct sctp_endpoint *);
 void sctp_unhash_endpoint(struct sctp_endpoint *);
 struct sock *sctp_err_lookup(struct net *net, int family, struct sk_buff *,
@@ -143,6 +141,17 @@ void sctp_icmp_proto_unreachable(struct sock *sk,
                                  struct sctp_transport *t);
 void sctp_backlog_migrate(struct sctp_association *assoc,
                           struct sock *oldsk, struct sock *newsk);
+int sctp_transport_hashtable_init(void);
+void sctp_transport_hashtable_destroy(void);
+void sctp_hash_transport(struct sctp_transport *t);
+void sctp_unhash_transport(struct sctp_transport *t);
+struct sctp_transport *sctp_addrs_lookup_transport(
+                                struct net *net,
+                                const union sctp_addr *laddr,
+                                const union sctp_addr *paddr);
+struct sctp_transport *sctp_epaddr_lookup_transport(
+                                const struct sctp_endpoint *ep,
+                                const union sctp_addr *paddr);
 
 /*
  * sctp/proc.c
@@ -519,25 +528,6 @@ static inline int sctp_ep_hashfn(struct net *net, __u16 lport)
         return (net_hash_mix(net) + lport) & (sctp_ep_hashsize - 1);
 }
 
-/* This is the hash function for the association hash table. */
-static inline int sctp_assoc_hashfn(struct net *net, __u16 lport, __u16 rport)
-{
-        int h = (lport << 16) + rport + net_hash_mix(net);
-        h ^= h>>8;
-        return h & (sctp_assoc_hashsize - 1);
-}
-
-/* This is the hash function for the association hash table.  This is
- * not used yet, but could be used as a better hash function when
- * we have a vtag.
- */
-static inline int sctp_vtag_hashfn(__u16 lport, __u16 rport, __u32 vtag)
-{
-        int h = (lport << 16) + rport;
-        h ^= vtag;
-        return h & (sctp_assoc_hashsize - 1);
-}
-
 #define sctp_for_each_hentry(epb, head) \
         hlist_for_each_entry(epb, head, node)
 
diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index eea9bdeecba2..20e72129be1c 100644
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -48,6 +48,7 @@
 #define __sctp_structs_h__
 
 #include <linux/ktime.h>
+#include <linux/rhashtable.h>
 #include <linux/socket.h>       /* linux/in.h needs this!!    */
 #include <linux/in.h>           /* We get struct sockaddr_in. */
 #include <linux/in6.h>          /* We get struct in6_addr     */
@@ -119,14 +120,13 @@ extern struct sctp_globals {
 
         /* This is the hash of all endpoints. */
         struct sctp_hashbucket *ep_hashtable;
-        /* This is the hash of all associations. */
-        struct sctp_hashbucket *assoc_hashtable;
         /* This is the sctp port control hash.  */
         struct sctp_bind_hashbucket *port_hashtable;
+        /* This is the hash of all transports. */
+        struct rhashtable transport_hashtable;
 
         /* Sizes of above hashtables. */
         int ep_hashsize;
-        int assoc_hashsize;
         int port_hashsize;
 
         /* Default initialization values to be applied to new associations. */
@@ -143,10 +143,9 @@ extern struct sctp_globals {
 #define sctp_address_families           (sctp_globals.address_families)
 #define sctp_ep_hashsize                (sctp_globals.ep_hashsize)
 #define sctp_ep_hashtable               (sctp_globals.ep_hashtable)
-#define sctp_assoc_hashsize             (sctp_globals.assoc_hashsize)
-#define sctp_assoc_hashtable            (sctp_globals.assoc_hashtable)
 #define sctp_port_hashsize              (sctp_globals.port_hashsize)
 #define sctp_port_hashtable             (sctp_globals.port_hashtable)
+#define sctp_transport_hashtable        (sctp_globals.transport_hashtable)
 #define sctp_checksum_disable           (sctp_globals.checksum_disable)
 
 /* SCTP Socket type: UDP or TCP style. */
@@ -753,6 +752,7 @@ static inline int sctp_packet_empty(struct sctp_packet *packet)
 struct sctp_transport {
         /* A list of transports. */
         struct list_head transports;
+        struct rhash_head node;
 
         /* Reference counting. */
         atomic_t refcnt;
diff --git a/include/net/sock.h b/include/net/sock.h
index 14d3c0734007..e830c1006935 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -58,6 +58,8 @@
 #include <linux/memcontrol.h>
 #include <linux/static_key.h>
 #include <linux/sched.h>
+#include <linux/wait.h>
+#include <linux/cgroup-defs.h>
 
 #include <linux/filter.h>
 #include <linux/rculist_nulls.h>
@@ -287,7 +289,6 @@ struct cg_proto;
   *     @sk_ack_backlog: current listen backlog
   *     @sk_max_ack_backlog: listen backlog set in listen()
   *     @sk_priority: %SO_PRIORITY setting
-  *     @sk_cgrp_prioidx: socket group's priority map index
   *     @sk_type: socket type (%SOCK_STREAM, etc)
   *     @sk_protocol: which protocol this socket belongs in this network family
   *     @sk_peer_pid: &struct pid for this socket's peer
@@ -308,7 +309,7 @@ struct cg_proto;
   *     @sk_send_head: front of stuff to transmit
   *     @sk_security: used by security modules
   *     @sk_mark: generic packet mark
-  *     @sk_classid: this socket's cgroup classid
+  *     @sk_cgrp_data: cgroup data for this cgroup
   *     @sk_cgrp: this socket's cgroup-specific proto data
   *     @sk_write_pending: a write to stream socket waits to start
   *     @sk_state_change: callback to indicate change in the state of the sock
@@ -317,6 +318,7 @@ struct cg_proto;
   *     @sk_error_report: callback to indicate errors (e.g. %MSG_ERRQUEUE)
   *     @sk_backlog_rcv: callback to process the backlog
   *     @sk_destruct: called at sock freeing time, i.e. when all refcnt == 0
+  *     @sk_reuseport_cb: reuseport group container
  */
 struct sock {
         /*
@@ -425,9 +427,7 @@ struct sock {
         u32                     sk_ack_backlog;
         u32                     sk_max_ack_backlog;
         __u32                   sk_priority;
-#if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
-        __u32                   sk_cgrp_prioidx;
-#endif
+        __u32                   sk_mark;
         struct pid              *sk_peer_pid;
         const struct cred       *sk_peer_cred;
         long                    sk_rcvtimeo;
@@ -445,10 +445,7 @@ struct sock {
 #ifdef CONFIG_SECURITY
         void                    *sk_security;
 #endif
-        __u32                   sk_mark;
-#ifdef CONFIG_CGROUP_NET_CLASSID
-        u32                     sk_classid;
-#endif
+        struct sock_cgroup_data sk_cgrp_data;
         struct cg_proto         *sk_cgrp;
         void                    (*sk_state_change)(struct sock *sk);
         void                    (*sk_data_ready)(struct sock *sk);
@@ -457,6 +454,7 @@ struct sock {
         int                     (*sk_backlog_rcv)(struct sock *sk,
                                                   struct sk_buff *skb);
         void                    (*sk_destruct)(struct sock *sk);
+        struct sock_reuseport __rcu     *sk_reuseport_cb;
 };
 
 #define __sk_user_data(sk) ((*((void __rcu **)&(sk)->sk_user_data)))
@@ -778,9 +776,9 @@ static inline int sk_memalloc_socks(void)
 
 #endif
 
-static inline gfp_t sk_gfp_atomic(const struct sock *sk, gfp_t gfp_mask)
+static inline gfp_t sk_gfp_mask(const struct sock *sk, gfp_t gfp_mask)
 {
-        return GFP_ATOMIC | (sk->sk_allocation & __GFP_MEMALLOC);
+        return gfp_mask | (sk->sk_allocation & __GFP_MEMALLOC);
 }
 
 static inline void sk_acceptq_removed(struct sock *sk)
@@ -1067,6 +1065,7 @@ struct proto {
         void                    (*destroy_cgroup)(struct mem_cgroup *memcg);
         struct cg_proto         *(*proto_cgroup)(struct mem_cgroup *memcg);
 #endif
+        int                     (*diag_destroy)(struct sock *sk, int err);
 };
 
 int proto_register(struct proto *prot, int alloc_slab);
@@ -1798,6 +1797,15 @@ static inline void sk_nocaps_add(struct sock *sk, netdev_features_t flags)
         sk->sk_route_caps &= ~flags;
 }
 
+static inline bool sk_check_csum_caps(struct sock *sk)
+{
+        return (sk->sk_route_caps & NETIF_F_HW_CSUM) ||
+               (sk->sk_family == PF_INET &&
+                (sk->sk_route_caps & NETIF_F_IP_CSUM)) ||
+               (sk->sk_family == PF_INET6 &&
+                (sk->sk_route_caps & NETIF_F_IPV6_CSUM));
+}
+
 static inline int skb_do_copy_data_nocache(struct sock *sk, struct sk_buff *skb,
                                            struct iov_iter *from, char *to,
                                            int copy, int offset)
@@ -1883,12 +1891,12 @@ static inline bool sk_has_allocations(const struct sock *sk)
 }
 
 /**
- * wq_has_sleeper - check if there are any waiting processes
+ * skwq_has_sleeper - check if there are any waiting processes
  * @wq: struct socket_wq
  *
  * Returns true if socket_wq has waiting processes
  *
- * The purpose of the wq_has_sleeper and sock_poll_wait is to wrap the memory
+ * The purpose of the skwq_has_sleeper and sock_poll_wait is to wrap the memory
  * barrier call. They were added due to the race found within the tcp code.
  *
  * Consider following tcp code paths:
@@ -1914,15 +1922,9 @@ static inline bool sk_has_allocations(const struct sock *sk)
  * data on the socket.
  *
  */
-static inline bool wq_has_sleeper(struct socket_wq *wq)
+static inline bool skwq_has_sleeper(struct socket_wq *wq)
 {
-        /* We need to be sure we are in sync with the
-         * add_wait_queue modifications to the wait queue.
-         *
-         * This memory barrier is paired in the sock_poll_wait.
-         */
-        smp_mb();
-        return wq && waitqueue_active(&wq->wait);
+        return wq && wq_has_sleeper(&wq->wait);
 }
 
 /**
diff --git a/include/net/sock_reuseport.h b/include/net/sock_reuseport.h
new file mode 100644
index 000000000000..7dda3d7adba8
--- /dev/null
+++ b/include/net/sock_reuseport.h
@@ -0,0 +1,28 @@
+#ifndef _SOCK_REUSEPORT_H
+#define _SOCK_REUSEPORT_H
+
+#include <linux/filter.h>
+#include <linux/skbuff.h>
+#include <linux/types.h>
+#include <net/sock.h>
+
+struct sock_reuseport {
+        struct rcu_head         rcu;
+
+        u16                     max_socks;      /* length of socks */
+        u16                     num_socks;      /* elements in socks */
+        struct bpf_prog __rcu   *prog;          /* optional BPF sock selector */
+        struct sock             *socks[0];      /* array of sock pointers */
+};
+
+extern int reuseport_alloc(struct sock *sk);
+extern int reuseport_add_sock(struct sock *sk, const struct sock *sk2);
+extern void reuseport_detach_sock(struct sock *sk);
+extern struct sock *reuseport_select_sock(struct sock *sk,
+                                          u32 hash,
+                                          struct sk_buff *skb,
+                                          int hdr_len);
+extern struct bpf_prog *reuseport_attach_prog(struct sock *sk,
+                                              struct bpf_prog *prog);
+
+#endif  /* _SOCK_REUSEPORT_H */
diff --git a/include/net/switchdev.h b/include/net/switchdev.h
index 1d22ce9f352e..d451122e8404 100644
--- a/include/net/switchdev.h
+++ b/include/net/switchdev.h
@@ -47,9 +47,11 @@ enum switchdev_attr_id {
         SWITCHDEV_ATTR_ID_PORT_STP_STATE,
         SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS,
         SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME,
+        SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING,
 };
 
 struct switchdev_attr {
+        struct net_device *orig_dev;
         enum switchdev_attr_id id;
         u32 flags;
         union {
@@ -57,6 +59,7 @@ struct switchdev_attr {
                 u8 stp_state;                           /* PORT_STP_STATE */
                 unsigned long brport_flags;             /* PORT_BRIDGE_FLAGS */
                 u32 ageing_time;                        /* BRIDGE_AGEING_TIME */
+                bool vlan_filtering;                    /* BRIDGE_VLAN_FILTERING */
         } u;
 };
 
@@ -65,9 +68,11 @@ enum switchdev_obj_id {
         SWITCHDEV_OBJ_ID_PORT_VLAN,
         SWITCHDEV_OBJ_ID_IPV4_FIB,
         SWITCHDEV_OBJ_ID_PORT_FDB,
+        SWITCHDEV_OBJ_ID_PORT_MDB,
 };
 
 struct switchdev_obj {
+        struct net_device *orig_dev;
         enum switchdev_obj_id id;
         u32 flags;
 };
@@ -109,6 +114,16 @@ struct switchdev_obj_port_fdb {
 #define SWITCHDEV_OBJ_PORT_FDB(obj) \
         container_of(obj, struct switchdev_obj_port_fdb, obj)
 
+/* SWITCHDEV_OBJ_ID_PORT_MDB */
+struct switchdev_obj_port_mdb {
+        struct switchdev_obj obj;
+        unsigned char addr[ETH_ALEN];
+        u16 vid;
+};
+
+#define SWITCHDEV_OBJ_PORT_MDB(obj) \
+        container_of(obj, struct switchdev_obj_port_mdb, obj)
+
 void switchdev_trans_item_enqueue(struct switchdev_trans *trans,
                                   void *data, void (*destructor)(void const *),
                                   struct switchdev_trans_item *tritem);
diff --git a/include/net/tcp.h b/include/net/tcp.h
index f80e74c5ad18..a80255f4ca33 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -240,9 +240,6 @@ extern int sysctl_tcp_timestamps;
 extern int sysctl_tcp_window_scaling;
 extern int sysctl_tcp_sack;
 extern int sysctl_tcp_fin_timeout;
-extern int sysctl_tcp_keepalive_time;
-extern int sysctl_tcp_keepalive_probes;
-extern int sysctl_tcp_keepalive_intvl;
 extern int sysctl_tcp_syn_retries;
 extern int sysctl_tcp_synack_retries;
 extern int sysctl_tcp_retries1;
@@ -1170,6 +1167,8 @@ void tcp_set_state(struct sock *sk, int state);
 
 void tcp_done(struct sock *sk);
 
+int tcp_abort(struct sock *sk, int err);
+
 static inline void tcp_sack_reset(struct tcp_options_received *rx_opt)
 {
         rx_opt->dsack = 0;
@@ -1223,17 +1222,23 @@ void tcp_enter_memory_pressure(struct sock *sk);
 
 static inline int keepalive_intvl_when(const struct tcp_sock *tp)
 {
-        return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl;
+        struct net *net = sock_net((struct sock *)tp);
+
+        return tp->keepalive_intvl ? : net->ipv4.sysctl_tcp_keepalive_intvl;
 }
 
 static inline int keepalive_time_when(const struct tcp_sock *tp)
 {
-        return tp->keepalive_time ? : sysctl_tcp_keepalive_time;
+        struct net *net = sock_net((struct sock *)tp);
+
+        return tp->keepalive_time ? : net->ipv4.sysctl_tcp_keepalive_time;
 }
 
 static inline int keepalive_probes(const struct tcp_sock *tp)
 {
-        return tp->keepalive_probes ? : sysctl_tcp_keepalive_probes;
+        struct net *net = sock_net((struct sock *)tp);
+
+        return tp->keepalive_probes ? : net->ipv4.sysctl_tcp_keepalive_probes;
 }
 
 static inline u32 keepalive_time_elapsed(const struct tcp_sock *tp)
@@ -1618,6 +1623,18 @@ static inline void tcp_highest_sack_combine(struct sock *sk,
                 tcp_sk(sk)->highest_sack = new;
 }
 
+/* This helper checks if socket has IP_TRANSPARENT set */
+static inline bool inet_sk_transparent(const struct sock *sk)
+{
+        switch (sk->sk_state) {
+        case TCP_TIME_WAIT:
+                return inet_twsk(sk)->tw_transparent;
+        case TCP_NEW_SYN_RECV:
+                return inet_rsk(inet_reqsk(sk))->no_srccheck;
+        }
+        return inet_sk(sk)->transparent;
+}
+
 /* Determines whether this is a thin stream (which may suffer from
  * increased latency). Used to trigger latency-reducing mechanisms.
  */
diff --git a/include/net/udp.h b/include/net/udp.h
index 6d4ed18e1427..2842541e28e7 100644
--- a/include/net/udp.h
+++ b/include/net/udp.h
@@ -191,7 +191,7 @@ static inline void udp_lib_close(struct sock *sk, long timeout)
 }
 
 int udp_lib_get_port(struct sock *sk, unsigned short snum,
-                     int (*)(const struct sock *, const struct sock *),
+                     int (*)(const struct sock *, const struct sock *, bool),
                      unsigned int hash2_nulladdr);
 
 u32 udp_flow_hashrnd(void);
@@ -258,7 +258,7 @@ struct sock *udp4_lib_lookup(struct net *net, __be32 saddr, __be16 sport,
                              __be32 daddr, __be16 dport, int dif);
 struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr, __be16 sport,
                                __be32 daddr, __be16 dport, int dif,
-                               struct udp_table *tbl);
+                               struct udp_table *tbl, struct sk_buff *skb);
 struct sock *udp6_lib_lookup(struct net *net,
                              const struct in6_addr *saddr, __be16 sport,
                              const struct in6_addr *daddr, __be16 dport,
@@ -266,7 +266,8 @@ struct sock *udp6_lib_lookup(struct net *net,
 struct sock *__udp6_lib_lookup(struct net *net,
                                const struct in6_addr *saddr, __be16 sport,
                                const struct in6_addr *daddr, __be16 dport,
-                               int dif, struct udp_table *tbl);
+                               int dif, struct udp_table *tbl,
+                               struct sk_buff *skb);
 
 /*
  *      SNMP statistics for UDP and UDP-Lite
diff --git a/include/net/udp_tunnel.h b/include/net/udp_tunnel.h
index cb2f89f20f5c..cca2ad3082c3 100644
--- a/include/net/udp_tunnel.h
+++ b/include/net/udp_tunnel.h
@@ -78,10 +78,10 @@ void setup_udp_tunnel_sock(struct net *net, struct socket *sock,
                            struct udp_tunnel_sock_cfg *sock_cfg);
 
 /* Transmit the skb using UDP encapsulation. */
-int udp_tunnel_xmit_skb(struct rtable *rt, struct sock *sk, struct sk_buff *skb,
-                        __be32 src, __be32 dst, __u8 tos, __u8 ttl,
-                        __be16 df, __be16 src_port, __be16 dst_port,
-                        bool xnet, bool nocheck);
+void udp_tunnel_xmit_skb(struct rtable *rt, struct sock *sk, struct sk_buff *skb,
+                         __be32 src, __be32 dst, __u8 tos, __u8 ttl,
+                         __be16 df, __be16 src_port, __be16 dst_port,
+                         bool xnet, bool nocheck);
 
 #if IS_ENABLED(CONFIG_IPV6)
 int udp_tunnel6_xmit_skb(struct dst_entry *dst, struct sock *sk,
diff --git a/include/net/vxlan.h b/include/net/vxlan.h
index e289ada6adf6..0fb86442544b 100644
--- a/include/net/vxlan.h
+++ b/include/net/vxlan.h
@@ -232,7 +232,7 @@ static inline netdev_features_t vxlan_features_check(struct sk_buff *skb,
              skb->inner_protocol != htons(ETH_P_TEB) ||
              (skb_inner_mac_header(skb) - skb_transport_header(skb) !=
               sizeof(struct udphdr) + sizeof(struct vxlanhdr))))
-                return features & ~(NETIF_F_ALL_CSUM | NETIF_F_GSO_MASK);
+                return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
 
         return features;
 }
diff --git a/include/trace/events/fib6.h b/include/trace/events/fib6.h
new file mode 100644
index 000000000000..4cf6bac4686d
--- /dev/null
+++ b/include/trace/events/fib6.h
@@ -0,0 +1,76 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM fib6
+
+#if !defined(_TRACE_FIB6_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_FIB6_H
+
+#include <linux/in6.h>
+#include <net/flow.h>
+#include <net/ip6_fib.h>
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(fib6_table_lookup,
+
+        TP_PROTO(const struct net *net, const struct rt6_info *rt,
+                 u32 tb_id, const struct flowi6 *flp),
+
+        TP_ARGS(net, rt, tb_id, flp),
+
+        TP_STRUCT__entry(
+                __field(        u32,    tb_id           )
+
+                __field(        int,    oif             )
+                __field(        int,    iif             )
+                __field(        __u8,   tos             )
+                __field(        __u8,   scope           )
+                __field(        __u8,   flags           )
+                __array(        __u8,   src,    16      )
+                __array(        __u8,   dst,    16      )
+
+                __dynamic_array(        char,   name,   IFNAMSIZ )
+                __array(                __u8,   gw,     16       )
+        ),
+
+        TP_fast_assign(
+                struct in6_addr *in6;
+
+                __entry->tb_id = tb_id;
+                __entry->oif = flp->flowi6_oif;
+                __entry->iif = flp->flowi6_iif;
+                __entry->tos = flp->flowi6_tos;
+                __entry->scope = flp->flowi6_scope;
+                __entry->flags = flp->flowi6_flags;
+
+                in6 = (struct in6_addr *)__entry->src;
+                *in6 = flp->saddr;
+
+                in6 = (struct in6_addr *)__entry->dst;
+                *in6 = flp->daddr;
+
+                if (rt->rt6i_idev) {
+                        __assign_str(name, rt->rt6i_idev->dev->name);
+                } else {
+                        __assign_str(name, "");
+                }
+                if (rt == net->ipv6.ip6_null_entry) {
+                        struct in6_addr in6_zero = {};
+
+                        in6 = (struct in6_addr *)__entry->gw;
+                        *in6 = in6_zero;
+
+                } else if (rt) {
+                        in6 = (struct in6_addr *)__entry->gw;
+                        *in6 = rt->rt6i_gateway;
+                }
+        ),
+
+        TP_printk("table %3u oif %d iif %d src %pI6c dst %pI6c tos %d scope %d flags %x ==> dev %s gw %pI6c",
+                  __entry->tb_id, __entry->oif, __entry->iif,
+                  __entry->src, __entry->dst, __entry->tos, __entry->scope,
+                  __entry->flags, __get_str(name), __entry->gw)
+);
+
+#endif /* _TRACE_FIB6_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/uapi/asm-generic/socket.h b/include/uapi/asm-generic/socket.h
index 5c15c2a5c123..fb8a41668382 100644
--- a/include/uapi/asm-generic/socket.h
+++ b/include/uapi/asm-generic/socket.h
@@ -87,4 +87,7 @@
 #define SO_ATTACH_BPF           50
 #define SO_DETACH_BPF           SO_DETACH_FILTER
 
+#define SO_ATTACH_REUSEPORT_CBPF        51
+#define SO_ATTACH_REUSEPORT_EBPF        52
+
 #endif /* __ASM_GENERIC_SOCKET_H */
diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h
index 9ea2d22fa2cb..aa6f8571de13 100644
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -269,9 +269,29 @@ enum bpf_func_id {
          * Return: 0 on success
          */
         BPF_FUNC_perf_event_output,
+        BPF_FUNC_skb_load_bytes,
         __BPF_FUNC_MAX_ID,
 };
 
+/* All flags used by eBPF helper functions, placed here. */
+
+/* BPF_FUNC_skb_store_bytes flags. */
+#define BPF_F_RECOMPUTE_CSUM            (1ULL << 0)
+
+/* BPF_FUNC_l3_csum_replace and BPF_FUNC_l4_csum_replace flags.
+ * First 4 bits are for passing the header field size.
+ */
+#define BPF_F_HDR_FIELD_MASK            0xfULL
+
+/* BPF_FUNC_l4_csum_replace flags. */
+#define BPF_F_PSEUDO_HDR                (1ULL << 4)
+
+/* BPF_FUNC_clone_redirect and BPF_FUNC_redirect flags. */
+#define BPF_F_INGRESS                   (1ULL << 0)
+
+/* BPF_FUNC_skb_set_tunnel_key and BPF_FUNC_skb_get_tunnel_key flags. */
+#define BPF_F_TUNINFO_IPV6              (1ULL << 0)
+
 /* user accessible mirror of in-kernel sk_buff.
  * new fields can only be added to the end of this structure
  */
@@ -295,7 +315,12 @@ struct __sk_buff {
 
 struct bpf_tunnel_key {
         __u32 tunnel_id;
-        __u32 remote_ipv4;
+        union {
+                __u32 remote_ipv4;
+                __u32 remote_ipv6[4];
+        };
+        __u8 tunnel_tos;
+        __u8 tunnel_ttl;
 };
 
 #endif /* _UAPI__LINUX_BPF_H__ */
diff --git a/include/uapi/linux/ethtool.h b/include/uapi/linux/ethtool.h
index cd1629170103..57fa39005e79 100644
--- a/include/uapi/linux/ethtool.h
+++ b/include/uapi/linux/ethtool.h
@@ -542,6 +542,7 @@ struct ethtool_pauseparam {
  *      now deprecated
  * @ETH_SS_FEATURES: Device feature names
  * @ETH_SS_RSS_HASH_FUNCS: RSS hush function names
+ * @ETH_SS_PHY_STATS: Statistic names, for use with %ETHTOOL_GPHYSTATS
  */
 enum ethtool_stringset {
         ETH_SS_TEST             = 0,
@@ -551,6 +552,7 @@ enum ethtool_stringset {
         ETH_SS_FEATURES,
         ETH_SS_RSS_HASH_FUNCS,
         ETH_SS_TUNABLES,
+        ETH_SS_PHY_STATS,
 };
 
 /**
@@ -1225,6 +1227,7 @@ enum ethtool_sfeatures_retval_bits {
 #define ETHTOOL_SRSSH           0x00000047 /* Set RX flow hash configuration */
 #define ETHTOOL_GTUNABLE        0x00000048 /* Get tunable configuration */
 #define ETHTOOL_STUNABLE        0x00000049 /* Set tunable configuration */
+#define ETHTOOL_GPHYSTATS       0x0000004a /* get PHY-specific statistics */
 
 /* compatibility with older code */
 #define SPARC_ETH_GSET          ETHTOOL_GSET
diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h
index 5ad57375a99f..a30b78090594 100644
--- a/include/uapi/linux/if_link.h
+++ b/include/uapi/linux/if_link.h
@@ -218,6 +218,7 @@ enum in6_addr_gen_mode {
         IN6_ADDR_GEN_MODE_EUI64,
         IN6_ADDR_GEN_MODE_NONE,
         IN6_ADDR_GEN_MODE_STABLE_PRIVACY,
+        IN6_ADDR_GEN_MODE_RANDOM,
 };
 
 /* Bridge section */
@@ -462,6 +463,9 @@ enum {
         IFLA_GENEVE_PORT,       /* destination port */
         IFLA_GENEVE_COLLECT_METADATA,
         IFLA_GENEVE_REMOTE6,
+        IFLA_GENEVE_UDP_CSUM,
+        IFLA_GENEVE_UDP_ZERO_CSUM6_TX,
+        IFLA_GENEVE_UDP_ZERO_CSUM6_RX,
         __IFLA_GENEVE_MAX
 };
 #define IFLA_GENEVE_MAX (__IFLA_GENEVE_MAX - 1)
diff --git a/include/uapi/linux/ila.h b/include/uapi/linux/ila.h
index 7ed9e670814e..abde7bbd6f3b 100644
--- a/include/uapi/linux/ila.h
+++ b/include/uapi/linux/ila.h
@@ -3,13 +3,35 @@
 #ifndef _UAPI_LINUX_ILA_H
 #define _UAPI_LINUX_ILA_H
 
+/* NETLINK_GENERIC related info */
+#define ILA_GENL_NAME           "ila"
+#define ILA_GENL_VERSION        0x1
+
 enum {
         ILA_ATTR_UNSPEC,
         ILA_ATTR_LOCATOR,                       /* u64 */
+        ILA_ATTR_IDENTIFIER,                    /* u64 */
+        ILA_ATTR_LOCATOR_MATCH,                 /* u64 */
+        ILA_ATTR_IFINDEX,                       /* s32 */
+        ILA_ATTR_DIR,                           /* u32 */
 
         __ILA_ATTR_MAX,
 };
 
 #define ILA_ATTR_MAX            (__ILA_ATTR_MAX - 1)
 
+enum {
+        ILA_CMD_UNSPEC,
+        ILA_CMD_ADD,
+        ILA_CMD_DEL,
+        ILA_CMD_GET,
+
+        __ILA_CMD_MAX,
+};
+
+#define ILA_CMD_MAX     (__ILA_CMD_MAX - 1)
+
+#define ILA_DIR_IN      (1 << 0)
+#define ILA_DIR_OUT     (1 << 1)
+
 #endif /* _UAPI_LINUX_ILA_H */
diff --git a/include/uapi/linux/in6.h b/include/uapi/linux/in6.h
index 79b12b004ade..318a4828bf98 100644
--- a/include/uapi/linux/in6.h
+++ b/include/uapi/linux/in6.h
@@ -196,6 +196,7 @@ struct in6_flowlabel_req {
 
 #define IPV6_IPSEC_POLICY       34
 #define IPV6_XFRM_POLICY        35
+#define IPV6_HDRINCL            36
 #endif
 
 /*
diff --git a/include/uapi/linux/mroute.h b/include/uapi/linux/mroute.h
index a382d2c04a42..cf943016930f 100644
--- a/include/uapi/linux/mroute.h
+++ b/include/uapi/linux/mroute.h
@@ -4,15 +4,13 @@
 #include <linux/sockios.h>
 #include <linux/types.h>
 
-/*
- *      Based on the MROUTING 3.5 defines primarily to keep
- *      source compatibility with BSD.
+/* Based on the MROUTING 3.5 defines primarily to keep
+ * source compatibility with BSD.
  *
- *      See the mrouted code for the original history.
- *
- *      Protocol Independent Multicast (PIM) data structures included
- *      Carlos Picoto (cap@di.fc.ul.pt)
+ * See the mrouted code for the original history.
  *
+ * Protocol Independent Multicast (PIM) data structures included
+ * Carlos Picoto (cap@di.fc.ul.pt)
  */
 
 #define MRT_BASE        200
@@ -34,15 +32,13 @@
 #define SIOCGETSGCNT    (SIOCPROTOPRIVATE+1)
 #define SIOCGETRPF      (SIOCPROTOPRIVATE+2)
 
-#define MAXVIFS         32      
+#define MAXVIFS         32
 typedef unsigned long vifbitmap_t;      /* User mode code depends on this lot */
 typedef unsigned short vifi_t;
 #define ALL_VIFS        ((vifi_t)(-1))
 
-/*
- *      Same idea as select
- */
- 
+/* Same idea as select */
+
 #define VIFM_SET(n,m)   ((m)|=(1<<(n)))
 #define VIFM_CLR(n,m)   ((m)&=~(1<<(n)))
 #define VIFM_ISSET(n,m) ((m)&(1<<(n)))
@@ -50,11 +46,9 @@ typedef unsigned short vifi_t;
 #define VIFM_COPY(mfrom,mto)    ((mto)=(mfrom))
 #define VIFM_SAME(m1,m2)        ((m1)==(m2))
 
-/*
- *      Passed by mrouted for an MRT_ADD_VIF - again we use the
- *      mrouted 3.6 structures for compatibility
+/* Passed by mrouted for an MRT_ADD_VIF - again we use the
+ * mrouted 3.6 structures for compatibility
  */
- 
 struct vifctl {
         vifi_t  vifc_vifi;              /* Index of VIF */
         unsigned char vifc_flags;       /* VIFF_ flags */
@@ -73,10 +67,7 @@ struct vifctl {
 #define VIFF_USE_IFINDEX        0x8     /* use vifc_lcl_ifindex instead of
                                            vifc_lcl_addr to find an interface */
 
-/*
- *      Cache manipulation structures for mrouted and PIMd
- */
- 
+/* Cache manipulation structures for mrouted and PIMd */
 struct mfcctl {
         struct in_addr mfcc_origin;             /* Origin of mcast      */
         struct in_addr mfcc_mcastgrp;           /* Group in question    */
@@ -88,10 +79,7 @@ struct mfcctl {
         int          mfcc_expire;
 };
 
-/* 
- *      Group count retrieval for mrouted
- */
- 
+/*  Group count retrieval for mrouted */
 struct sioc_sg_req {
         struct in_addr src;
         struct in_addr grp;
@@ -100,10 +88,7 @@ struct sioc_sg_req {
         unsigned long wrong_if;
 };
 
-/*
- *      To get vif packet counts
- */
-
+/* To get vif packet counts */
 struct sioc_vif_req {
         vifi_t  vifi;           /* Which iface */
         unsigned long icount;   /* In packets */
@@ -112,11 +97,9 @@ struct sioc_vif_req {
         unsigned long obytes;   /* Out bytes */
 };
 
-/*
- *      This is the format the mroute daemon expects to see IGMP control
- *      data. Magically happens to be like an IP packet as per the original
+/* This is the format the mroute daemon expects to see IGMP control
+ * data. Magically happens to be like an IP packet as per the original
  */
- 
 struct igmpmsg {
         __u32 unused1,unused2;
         unsigned char im_msgtype;               /* What is this */
@@ -126,21 +109,13 @@ struct igmpmsg {
         struct in_addr im_src,im_dst;
 };
 
-/*
- *      That's all usermode folks
- */
-
-
+/* That's all usermode folks */
 
 #define MFC_ASSERT_THRESH (3*HZ)                /* Maximal freq. of asserts */
 
-/*
- *      Pseudo messages used by mrouted
- */
-
+/* Pseudo messages used by mrouted */
 #define IGMPMSG_NOCACHE         1               /* Kern cache fill request to mrouted */
 #define IGMPMSG_WRONGVIF        2               /* For PIM assert processing (unused) */
 #define IGMPMSG_WHOLEPKT        3               /* For PIM Register processing */
 
-
 #endif /* _UAPI__LINUX_MROUTE_H */
diff --git a/include/uapi/linux/netfilter/ipset/ip_set_bitmap.h b/include/uapi/linux/netfilter/ipset/ip_set_bitmap.h
index 6a2c038d1888..fd5024d26269 100644
--- a/include/uapi/linux/netfilter/ipset/ip_set_bitmap.h
+++ b/include/uapi/linux/netfilter/ipset/ip_set_bitmap.h
@@ -1,6 +1,8 @@
 #ifndef _UAPI__IP_SET_BITMAP_H
 #define _UAPI__IP_SET_BITMAP_H
 
+#include <linux/netfilter/ipset/ip_set.h>
+
 /* Bitmap type specific error codes */
 enum {
         /* The element is out of the range of the set */
diff --git a/include/uapi/linux/netfilter/ipset/ip_set_hash.h b/include/uapi/linux/netfilter/ipset/ip_set_hash.h
index 352eeccdc7f2..82deeb883ac4 100644
--- a/include/uapi/linux/netfilter/ipset/ip_set_hash.h
+++ b/include/uapi/linux/netfilter/ipset/ip_set_hash.h
@@ -1,6 +1,8 @@
 #ifndef _UAPI__IP_SET_HASH_H
 #define _UAPI__IP_SET_HASH_H
 
+#include <linux/netfilter/ipset/ip_set.h>
+
 /* Hash type specific error codes */
 enum {
         /* Hash is full */
diff --git a/include/uapi/linux/netfilter/ipset/ip_set_list.h b/include/uapi/linux/netfilter/ipset/ip_set_list.h
index a44efaa98213..84d430368266 100644
--- a/include/uapi/linux/netfilter/ipset/ip_set_list.h
+++ b/include/uapi/linux/netfilter/ipset/ip_set_list.h
@@ -1,6 +1,8 @@
 #ifndef _UAPI__IP_SET_LIST_H
 #define _UAPI__IP_SET_LIST_H
 
+#include <linux/netfilter/ipset/ip_set.h>
+
 /* List type specific error codes */
 enum {
         /* Set name to be added/deleted/tested does not exist. */
diff --git a/include/uapi/linux/netfilter/nf_conntrack_sctp.h b/include/uapi/linux/netfilter/nf_conntrack_sctp.h
index ed4e776e1242..2cbc366c3fb4 100644
--- a/include/uapi/linux/netfilter/nf_conntrack_sctp.h
+++ b/include/uapi/linux/netfilter/nf_conntrack_sctp.h
@@ -1,5 +1,5 @@
-#ifndef _NF_CONNTRACK_SCTP_H
-#define _NF_CONNTRACK_SCTP_H
+#ifndef _UAPI_NF_CONNTRACK_SCTP_H
+#define _UAPI_NF_CONNTRACK_SCTP_H
 /* SCTP tracking. */
 
 #include <linux/netfilter/nf_conntrack_tuple_common.h>
@@ -18,10 +18,4 @@ enum sctp_conntrack {
         SCTP_CONNTRACK_MAX
 };
 
-struct ip_ct_sctp {
-        enum sctp_conntrack state;
-
-        __be32 vtag[IP_CT_DIR_MAX];
-};
-
-#endif /* _NF_CONNTRACK_SCTP_H */
+#endif /* _UAPI_NF_CONNTRACK_SCTP_H */
diff --git a/include/uapi/linux/netfilter/nf_conntrack_tuple_common.h b/include/uapi/linux/netfilter/nf_conntrack_tuple_common.h
index 2f6bbc5b8125..a9c3834abdd4 100644
--- a/include/uapi/linux/netfilter/nf_conntrack_tuple_common.h
+++ b/include/uapi/linux/netfilter/nf_conntrack_tuple_common.h
@@ -1,6 +1,9 @@
 #ifndef _NF_CONNTRACK_TUPLE_COMMON_H
 #define _NF_CONNTRACK_TUPLE_COMMON_H
 
+#include <linux/types.h>
+#include <linux/netfilter.h>
+
 enum ip_conntrack_dir {
         IP_CT_DIR_ORIGINAL,
         IP_CT_DIR_REPLY,
diff --git a/include/uapi/linux/netfilter/nf_tables.h b/include/uapi/linux/netfilter/nf_tables.h
index d8c8a7c9d88a..be41ffc128b8 100644
--- a/include/uapi/linux/netfilter/nf_tables.h
+++ b/include/uapi/linux/netfilter/nf_tables.h
@@ -83,6 +83,7 @@ enum nft_verdicts {
  * @NFT_MSG_DELSETELEM: delete a set element (enum nft_set_elem_attributes)
  * @NFT_MSG_NEWGEN: announce a new generation, only for events (enum nft_gen_attributes)
  * @NFT_MSG_GETGEN: get the rule-set generation (enum nft_gen_attributes)
+ * @NFT_MSG_TRACE: trace event (enum nft_trace_attributes)
  */
 enum nf_tables_msg_types {
         NFT_MSG_NEWTABLE,
@@ -102,6 +103,7 @@ enum nf_tables_msg_types {
         NFT_MSG_DELSETELEM,
         NFT_MSG_NEWGEN,
         NFT_MSG_GETGEN,
+        NFT_MSG_TRACE,
         NFT_MSG_MAX,
 };
 
@@ -289,6 +291,7 @@ enum nft_set_desc_attributes {
  * @NFTA_SET_ID: uniquely identifies a set in a transaction (NLA_U32)
  * @NFTA_SET_TIMEOUT: default timeout value (NLA_U64)
  * @NFTA_SET_GC_INTERVAL: garbage collection interval (NLA_U32)
+ * @NFTA_SET_USERDATA: user data (NLA_BINARY)
  */
 enum nft_set_attributes {
         NFTA_SET_UNSPEC,
@@ -304,6 +307,7 @@ enum nft_set_attributes {
         NFTA_SET_ID,
         NFTA_SET_TIMEOUT,
         NFTA_SET_GC_INTERVAL,
+        NFTA_SET_USERDATA,
         __NFTA_SET_MAX
 };
 #define NFTA_SET_MAX            (__NFTA_SET_MAX - 1)
@@ -598,12 +602,26 @@ enum nft_payload_bases {
 };
 
 /**
+ * enum nft_payload_csum_types - nf_tables payload expression checksum types
+ *
+ * @NFT_PAYLOAD_CSUM_NONE: no checksumming
+ * @NFT_PAYLOAD_CSUM_INET: internet checksum (RFC 791)
+ */
+enum nft_payload_csum_types {
+        NFT_PAYLOAD_CSUM_NONE,
+        NFT_PAYLOAD_CSUM_INET,
+};
+
+/**
  * enum nft_payload_attributes - nf_tables payload expression netlink attributes
  *
  * @NFTA_PAYLOAD_DREG: destination register to load data into (NLA_U32: nft_registers)
  * @NFTA_PAYLOAD_BASE: payload base (NLA_U32: nft_payload_bases)
  * @NFTA_PAYLOAD_OFFSET: payload offset relative to base (NLA_U32)
  * @NFTA_PAYLOAD_LEN: payload length (NLA_U32)
+ * @NFTA_PAYLOAD_SREG: source register to load data from (NLA_U32: nft_registers)
+ * @NFTA_PAYLOAD_CSUM_TYPE: checksum type (NLA_U32)
+ * @NFTA_PAYLOAD_CSUM_OFFSET: checksum offset relative to base (NLA_U32)
  */
 enum nft_payload_attributes {
         NFTA_PAYLOAD_UNSPEC,
@@ -611,6 +629,9 @@ enum nft_payload_attributes {
         NFTA_PAYLOAD_BASE,
         NFTA_PAYLOAD_OFFSET,
         NFTA_PAYLOAD_LEN,
+        NFTA_PAYLOAD_SREG,
+        NFTA_PAYLOAD_CSUM_TYPE,
+        NFTA_PAYLOAD_CSUM_OFFSET,
         __NFTA_PAYLOAD_MAX
 };
 #define NFTA_PAYLOAD_MAX        (__NFTA_PAYLOAD_MAX - 1)
@@ -736,6 +757,8 @@ enum nft_ct_keys {
         NFT_CT_PROTO_SRC,
         NFT_CT_PROTO_DST,
         NFT_CT_LABELS,
+        NFT_CT_PKTS,
+        NFT_CT_BYTES,
 };
 
 /**
@@ -761,6 +784,10 @@ enum nft_limit_type {
         NFT_LIMIT_PKT_BYTES
 };
 
+enum nft_limit_flags {
+        NFT_LIMIT_F_INV = (1 << 0),
+};
+
 /**
  * enum nft_limit_attributes - nf_tables limit expression netlink attributes
  *
@@ -768,6 +795,7 @@ enum nft_limit_type {
  * @NFTA_LIMIT_UNIT: refill unit (NLA_U64)
  * @NFTA_LIMIT_BURST: burst (NLA_U32)
  * @NFTA_LIMIT_TYPE: type of limit (NLA_U32: enum nft_limit_type)
+ * @NFTA_LIMIT_FLAGS: flags (NLA_U32: enum nft_limit_flags)
  */
 enum nft_limit_attributes {
         NFTA_LIMIT_UNSPEC,
@@ -775,6 +803,7 @@ enum nft_limit_attributes {
         NFTA_LIMIT_UNIT,
         NFTA_LIMIT_BURST,
         NFTA_LIMIT_TYPE,
+        NFTA_LIMIT_FLAGS,
         __NFTA_LIMIT_MAX
 };
 #define NFTA_LIMIT_MAX          (__NFTA_LIMIT_MAX - 1)
@@ -959,6 +988,18 @@ enum nft_dup_attributes {
 #define NFTA_DUP_MAX            (__NFTA_DUP_MAX - 1)
 
 /**
+ * enum nft_fwd_attributes - nf_tables fwd expression netlink attributes
+ *
+ * @NFTA_FWD_SREG_DEV: source register of output interface (NLA_U32: nft_register)
+ */
+enum nft_fwd_attributes {
+        NFTA_FWD_UNSPEC,
+        NFTA_FWD_SREG_DEV,
+        __NFTA_FWD_MAX
+};
+#define NFTA_FWD_MAX    (__NFTA_FWD_MAX - 1)
+
+/**
  * enum nft_gen_attributes - nf_tables ruleset generation attributes
  *
  * @NFTA_GEN_ID: Ruleset generation ID (NLA_U32)
@@ -970,4 +1011,54 @@ enum nft_gen_attributes {
 };
 #define NFTA_GEN_MAX            (__NFTA_GEN_MAX - 1)
 
+/**
+ * enum nft_trace_attributes - nf_tables trace netlink attributes
+ *
+ * @NFTA_TRACE_TABLE: name of the table (NLA_STRING)
+ * @NFTA_TRACE_CHAIN: name of the chain (NLA_STRING)
+ * @NFTA_TRACE_RULE_HANDLE: numeric handle of the rule (NLA_U64)
+ * @NFTA_TRACE_TYPE: type of the event (NLA_U32: nft_trace_types)
+ * @NFTA_TRACE_VERDICT: verdict returned by hook (NLA_NESTED: nft_verdicts)
+ * @NFTA_TRACE_ID: pseudo-id, same for each skb traced (NLA_U32)
+ * @NFTA_TRACE_LL_HEADER: linklayer header (NLA_BINARY)
+ * @NFTA_TRACE_NETWORK_HEADER: network header (NLA_BINARY)
+ * @NFTA_TRACE_TRANSPORT_HEADER: transport header (NLA_BINARY)
+ * @NFTA_TRACE_IIF: indev ifindex (NLA_U32)
+ * @NFTA_TRACE_IIFTYPE: netdev->type of indev (NLA_U16)
+ * @NFTA_TRACE_OIF: outdev ifindex (NLA_U32)
+ * @NFTA_TRACE_OIFTYPE: netdev->type of outdev (NLA_U16)
+ * @NFTA_TRACE_MARK: nfmark (NLA_U32)
+ * @NFTA_TRACE_NFPROTO: nf protocol processed (NLA_U32)
+ * @NFTA_TRACE_POLICY: policy that decided fate of packet (NLA_U32)
+ */
+enum nft_trace_attibutes {
+        NFTA_TRACE_UNSPEC,
+        NFTA_TRACE_TABLE,
+        NFTA_TRACE_CHAIN,
+        NFTA_TRACE_RULE_HANDLE,
+        NFTA_TRACE_TYPE,
+        NFTA_TRACE_VERDICT,
+        NFTA_TRACE_ID,
+        NFTA_TRACE_LL_HEADER,
+        NFTA_TRACE_NETWORK_HEADER,
+        NFTA_TRACE_TRANSPORT_HEADER,
+        NFTA_TRACE_IIF,
+        NFTA_TRACE_IIFTYPE,
+        NFTA_TRACE_OIF,
+        NFTA_TRACE_OIFTYPE,
+        NFTA_TRACE_MARK,
+        NFTA_TRACE_NFPROTO,
+        NFTA_TRACE_POLICY,
+        __NFTA_TRACE_MAX
+};
+#define NFTA_TRACE_MAX (__NFTA_TRACE_MAX - 1)
+
+enum nft_trace_types {
+        NFT_TRACETYPE_UNSPEC,
+        NFT_TRACETYPE_POLICY,
+        NFT_TRACETYPE_RETURN,
+        NFT_TRACETYPE_RULE,
+        __NFT_TRACETYPE_MAX
+};
+#define NFT_TRACETYPE_MAX (__NFT_TRACETYPE_MAX - 1)
 #endif /* _LINUX_NF_TABLES_H */
diff --git a/include/uapi/linux/netfilter/nfnetlink.h b/include/uapi/linux/netfilter/nfnetlink.h
index 354a7e5e50f2..4bb8cb7730e7 100644
--- a/include/uapi/linux/netfilter/nfnetlink.h
+++ b/include/uapi/linux/netfilter/nfnetlink.h
@@ -22,6 +22,8 @@ enum nfnetlink_groups {
 #define NFNLGRP_NFTABLES                NFNLGRP_NFTABLES
         NFNLGRP_ACCT_QUOTA,
 #define NFNLGRP_ACCT_QUOTA              NFNLGRP_ACCT_QUOTA
+        NFNLGRP_NFTRACE,
+#define NFNLGRP_NFTRACE                 NFNLGRP_NFTRACE
         __NFNLGRP_MAX,
 };
 #define NFNLGRP_MAX     (__NFNLGRP_MAX - 1)
diff --git a/include/uapi/linux/netfilter/xt_HMARK.h b/include/uapi/linux/netfilter/xt_HMARK.h
index 826fc5807577..3fb48c8d8d78 100644
--- a/include/uapi/linux/netfilter/xt_HMARK.h
+++ b/include/uapi/linux/netfilter/xt_HMARK.h
@@ -2,6 +2,7 @@
 #define XT_HMARK_H_
 
 #include <linux/types.h>
+#include <linux/netfilter.h>
 
 enum {
         XT_HMARK_SADDR_MASK,
diff --git a/include/uapi/linux/netfilter/xt_RATEEST.h b/include/uapi/linux/netfilter/xt_RATEEST.h
index 6605e20ad8cf..ec1b57047e03 100644
--- a/include/uapi/linux/netfilter/xt_RATEEST.h
+++ b/include/uapi/linux/netfilter/xt_RATEEST.h
@@ -2,6 +2,7 @@
 #define _XT_RATEEST_TARGET_H
 
 #include <linux/types.h>
+#include <linux/if.h>
 
 struct xt_rateest_target_info {
         char                    name[IFNAMSIZ];
diff --git a/include/uapi/linux/netfilter/xt_TEE.h b/include/uapi/linux/netfilter/xt_TEE.h
index 5c21d5c829af..01092023404b 100644
--- a/include/uapi/linux/netfilter/xt_TEE.h
+++ b/include/uapi/linux/netfilter/xt_TEE.h
@@ -1,6 +1,8 @@
 #ifndef _XT_TEE_TARGET_H
 #define _XT_TEE_TARGET_H
 
+#include <linux/netfilter.h>
+
 struct xt_tee_tginfo {
         union nf_inet_addr gw;
         char oif[16];
diff --git a/include/uapi/linux/netfilter/xt_TPROXY.h b/include/uapi/linux/netfilter/xt_TPROXY.h
index 902043c2073f..8d693eefdc1f 100644
--- a/include/uapi/linux/netfilter/xt_TPROXY.h
+++ b/include/uapi/linux/netfilter/xt_TPROXY.h
@@ -2,6 +2,7 @@
 #define _XT_TPROXY_H
 
 #include <linux/types.h>
+#include <linux/netfilter.h>
 
 /* TPROXY target is capable of marking the packet to perform
  * redirection. We can get rid of that whenever we get support for
diff --git a/include/uapi/linux/netfilter/xt_cgroup.h b/include/uapi/linux/netfilter/xt_cgroup.h
index 43acb7e175f6..1e4b37b93bef 100644
--- a/include/uapi/linux/netfilter/xt_cgroup.h
+++ b/include/uapi/linux/netfilter/xt_cgroup.h
@@ -2,10 +2,23 @@
 #define _UAPI_XT_CGROUP_H
 
 #include <linux/types.h>
+#include <linux/limits.h>
 
-struct xt_cgroup_info {
+struct xt_cgroup_info_v0 {
         __u32 id;
         __u32 invert;
 };
 
+struct xt_cgroup_info_v1 {
+        __u8            has_path;
+        __u8            has_classid;
+        __u8            invert_path;
+        __u8            invert_classid;
+        char            path[PATH_MAX];
+        __u32           classid;
+
+        /* kernel internal data */
+        void            *priv __attribute__((aligned(8)));
+};
+
 #endif /* _UAPI_XT_CGROUP_H */
diff --git a/include/uapi/linux/netfilter/xt_hashlimit.h b/include/uapi/linux/netfilter/xt_hashlimit.h
index cbfc43d1af68..6db90372f09c 100644
--- a/include/uapi/linux/netfilter/xt_hashlimit.h
+++ b/include/uapi/linux/netfilter/xt_hashlimit.h
@@ -2,6 +2,7 @@
 #define _UAPI_XT_HASHLIMIT_H
 
 #include <linux/types.h>
+#include <linux/if.h>
 
 /* timings are in milliseconds. */
 #define XT_HASHLIMIT_SCALE 10000
diff --git a/include/uapi/linux/netfilter/xt_ipvs.h b/include/uapi/linux/netfilter/xt_ipvs.h
index eff34ac18808..e03b9c31a39d 100644
--- a/include/uapi/linux/netfilter/xt_ipvs.h
+++ b/include/uapi/linux/netfilter/xt_ipvs.h
@@ -2,6 +2,7 @@
 #define _XT_IPVS_H
 
 #include <linux/types.h>
+#include <linux/netfilter.h>
 
 enum {
         XT_IPVS_IPVS_PROPERTY = 1 << 0, /* all other options imply this one */
diff --git a/include/uapi/linux/netfilter/xt_mac.h b/include/uapi/linux/netfilter/xt_mac.h
index b892cdc67e06..9a19a08a9181 100644
--- a/include/uapi/linux/netfilter/xt_mac.h
+++ b/include/uapi/linux/netfilter/xt_mac.h
@@ -1,6 +1,8 @@
 #ifndef _XT_MAC_H
 #define _XT_MAC_H
 
+#include <linux/if_ether.h>
+
 struct xt_mac_info {
     unsigned char srcaddr[ETH_ALEN];
     int invert;
diff --git a/include/uapi/linux/netfilter/xt_osf.h b/include/uapi/linux/netfilter/xt_osf.h
index 5d66caeba3ee..e6159958b2fb 100644
--- a/include/uapi/linux/netfilter/xt_osf.h
+++ b/include/uapi/linux/netfilter/xt_osf.h
@@ -20,6 +20,8 @@
 #define _XT_OSF_H
 
 #include <linux/types.h>
+#include <linux/ip.h>
+#include <linux/tcp.h>
 
 #define MAXGENRELEN             32
 
diff --git a/include/uapi/linux/netfilter/xt_physdev.h b/include/uapi/linux/netfilter/xt_physdev.h
index db7a2982e9c0..ccdde87da214 100644
--- a/include/uapi/linux/netfilter/xt_physdev.h
+++ b/include/uapi/linux/netfilter/xt_physdev.h
@@ -2,7 +2,7 @@
 #define _UAPI_XT_PHYSDEV_H
 
 #include <linux/types.h>
-
+#include <linux/if.h>
 
 #define XT_PHYSDEV_OP_IN                0x01
 #define XT_PHYSDEV_OP_OUT               0x02
diff --git a/include/uapi/linux/netfilter/xt_policy.h b/include/uapi/linux/netfilter/xt_policy.h
index be8ead05c316..d8a9800dce61 100644
--- a/include/uapi/linux/netfilter/xt_policy.h
+++ b/include/uapi/linux/netfilter/xt_policy.h
@@ -2,6 +2,8 @@
 #define _XT_POLICY_H
 
 #include <linux/types.h>
+#include <linux/in.h>
+#include <linux/in6.h>
 
 #define XT_POLICY_MAX_ELEM      4
 
diff --git a/include/uapi/linux/netfilter/xt_rateest.h b/include/uapi/linux/netfilter/xt_rateest.h
index d40a6196842a..13fe50d4e4b3 100644
--- a/include/uapi/linux/netfilter/xt_rateest.h
+++ b/include/uapi/linux/netfilter/xt_rateest.h
@@ -2,6 +2,7 @@
 #define _XT_RATEEST_MATCH_H
 
 #include <linux/types.h>
+#include <linux/if.h>
 
 enum xt_rateest_match_flags {
         XT_RATEEST_MATCH_INVERT = 1<<0,
diff --git a/include/uapi/linux/netfilter/xt_recent.h b/include/uapi/linux/netfilter/xt_recent.h
index 6ef36c113e89..955d562031cc 100644
--- a/include/uapi/linux/netfilter/xt_recent.h
+++ b/include/uapi/linux/netfilter/xt_recent.h
@@ -2,6 +2,7 @@
 #define _LINUX_NETFILTER_XT_RECENT_H 1
 
 #include <linux/types.h>
+#include <linux/netfilter.h>
 
 enum {
         XT_RECENT_CHECK    = 1 << 0,
diff --git a/include/uapi/linux/netfilter/xt_sctp.h b/include/uapi/linux/netfilter/xt_sctp.h
index 29287be696a2..58ffcfb7978e 100644
--- a/include/uapi/linux/netfilter/xt_sctp.h
+++ b/include/uapi/linux/netfilter/xt_sctp.h
@@ -66,26 +66,26 @@ struct xt_sctp_info {
 
 #define SCTP_CHUNKMAP_IS_CLEAR(chunkmap) \
         __sctp_chunkmap_is_clear((chunkmap), ARRAY_SIZE(chunkmap))
-static inline bool
+static inline _Bool
 __sctp_chunkmap_is_clear(const __u32 *chunkmap, unsigned int n)
 {
         unsigned int i;
         for (i = 0; i < n; ++i)
                 if (chunkmap[i])
-                        return false;
-        return true;
+                        return 0;
+        return 1;
 }
 
 #define SCTP_CHUNKMAP_IS_ALL_SET(chunkmap) \
         __sctp_chunkmap_is_all_set((chunkmap), ARRAY_SIZE(chunkmap))
-static inline bool
+static inline _Bool
 __sctp_chunkmap_is_all_set(const __u32 *chunkmap, unsigned int n)
 {
         unsigned int i;
         for (i = 0; i < n; ++i)
                 if (chunkmap[i] != ~0U)
-                        return false;
-        return true;
+                        return 0;
+        return 1;
 }
 
 #endif /* _XT_SCTP_H_ */
diff --git a/include/uapi/linux/netfilter_arp/arp_tables.h b/include/uapi/linux/netfilter_arp/arp_tables.h
index a5a86a4db6b3..ece3ad4eecda 100644
--- a/include/uapi/linux/netfilter_arp/arp_tables.h
+++ b/include/uapi/linux/netfilter_arp/arp_tables.h
@@ -11,6 +11,7 @@
 
 #include <linux/types.h>
 #include <linux/compiler.h>
+#include <linux/if.h>
 #include <linux/netfilter_arp.h>
 
 #include <linux/netfilter/x_tables.h>
diff --git a/include/uapi/linux/netfilter_bridge.h b/include/uapi/linux/netfilter_bridge.h
index a5eda6db8d79..514519b47651 100644
--- a/include/uapi/linux/netfilter_bridge.h
+++ b/include/uapi/linux/netfilter_bridge.h
@@ -4,6 +4,7 @@
 /* bridge-specific defines for netfilter. 
  */
 
+#include <linux/in.h>
 #include <linux/netfilter.h>
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
diff --git a/include/uapi/linux/netfilter_bridge/ebt_arp.h b/include/uapi/linux/netfilter_bridge/ebt_arp.h
index 522f3e427f49..dd4df25330e8 100644
--- a/include/uapi/linux/netfilter_bridge/ebt_arp.h
+++ b/include/uapi/linux/netfilter_bridge/ebt_arp.h
@@ -2,6 +2,7 @@
 #define __LINUX_BRIDGE_EBT_ARP_H
 
 #include <linux/types.h>
+#include <linux/if_ether.h>
 
 #define EBT_ARP_OPCODE 0x01
 #define EBT_ARP_HTYPE 0x02
diff --git a/include/uapi/linux/netfilter_bridge/ebt_arpreply.h b/include/uapi/linux/netfilter_bridge/ebt_arpreply.h
index 7e77896e1fbf..6fee3402e307 100644
--- a/include/uapi/linux/netfilter_bridge/ebt_arpreply.h
+++ b/include/uapi/linux/netfilter_bridge/ebt_arpreply.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_BRIDGE_EBT_ARPREPLY_H
 #define __LINUX_BRIDGE_EBT_ARPREPLY_H
 
+#include <linux/if_ether.h>
+
 struct ebt_arpreply_info {
         unsigned char mac[ETH_ALEN];
         int target;
diff --git a/include/uapi/linux/netfilter_bridge/ebt_ip6.h b/include/uapi/linux/netfilter_bridge/ebt_ip6.h
index 42b889682721..a062f0ce95f9 100644
--- a/include/uapi/linux/netfilter_bridge/ebt_ip6.h
+++ b/include/uapi/linux/netfilter_bridge/ebt_ip6.h
@@ -13,6 +13,7 @@
 #define __LINUX_BRIDGE_EBT_IP6_H
 
 #include <linux/types.h>
+#include <linux/in6.h>
 
 #define EBT_IP6_SOURCE 0x01
 #define EBT_IP6_DEST 0x02
diff --git a/include/uapi/linux/netfilter_bridge/ebt_nat.h b/include/uapi/linux/netfilter_bridge/ebt_nat.h
index 5e74e3b03bd6..c990d74ee966 100644
--- a/include/uapi/linux/netfilter_bridge/ebt_nat.h
+++ b/include/uapi/linux/netfilter_bridge/ebt_nat.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_BRIDGE_EBT_NAT_H
 #define __LINUX_BRIDGE_EBT_NAT_H
 
+#include <linux/if_ether.h>
+
 #define NAT_ARP_BIT  (0x00000010)
 struct ebt_nat_info {
         unsigned char mac[ETH_ALEN];
diff --git a/include/uapi/linux/netfilter_bridge/ebtables.h b/include/uapi/linux/netfilter_bridge/ebtables.h
index fd2ee501726d..e3cdf9f1a259 100644
--- a/include/uapi/linux/netfilter_bridge/ebtables.h
+++ b/include/uapi/linux/netfilter_bridge/ebtables.h
@@ -12,6 +12,8 @@
 
 #ifndef _UAPI__LINUX_BRIDGE_EFF_H
 #define _UAPI__LINUX_BRIDGE_EFF_H
+#include <linux/types.h>
+#include <linux/if.h>
 #include <linux/netfilter_bridge.h>
 
 #define EBT_TABLE_MAXNAMELEN 32
@@ -33,8 +35,8 @@ struct xt_match;
 struct xt_target;
 
 struct ebt_counter {
-        uint64_t pcnt;
-        uint64_t bcnt;
+        __u64 pcnt;
+        __u64 bcnt;
 };
 
 struct ebt_replace {
diff --git a/include/uapi/linux/netfilter_ipv4/ip_tables.h b/include/uapi/linux/netfilter_ipv4/ip_tables.h
index f1e6ef256034..d0da53d96d93 100644
--- a/include/uapi/linux/netfilter_ipv4/ip_tables.h
+++ b/include/uapi/linux/netfilter_ipv4/ip_tables.h
@@ -17,6 +17,7 @@
 
 #include <linux/types.h>
 #include <linux/compiler.h>
+#include <linux/if.h>
 #include <linux/netfilter_ipv4.h>
 
 #include <linux/netfilter/x_tables.h>
diff --git a/include/uapi/linux/netfilter_ipv6/ip6_tables.h b/include/uapi/linux/netfilter_ipv6/ip6_tables.h
index 649c68062dca..d1b22653daf2 100644
--- a/include/uapi/linux/netfilter_ipv6/ip6_tables.h
+++ b/include/uapi/linux/netfilter_ipv6/ip6_tables.h
@@ -17,6 +17,7 @@
 
 #include <linux/types.h>
 #include <linux/compiler.h>
+#include <linux/if.h>
 #include <linux/netfilter_ipv6.h>
 
 #include <linux/netfilter/x_tables.h>
diff --git a/include/uapi/linux/netfilter_ipv6/ip6t_rt.h b/include/uapi/linux/netfilter_ipv6/ip6t_rt.h
index 7605a5ff81cd..558f81e46fb9 100644
--- a/include/uapi/linux/netfilter_ipv6/ip6t_rt.h
+++ b/include/uapi/linux/netfilter_ipv6/ip6t_rt.h
@@ -2,7 +2,7 @@
 #define _IP6T_RT_H
 
 #include <linux/types.h>
-/*#include <linux/in6.h>*/
+#include <linux/in6.h>
 
 #define IP6T_RT_HOPS 16
 
diff --git a/include/uapi/linux/nl80211.h b/include/uapi/linux/nl80211.h
index 1f0b4cf5dd03..5b7b5ebe7ca8 100644
--- a/include/uapi/linux/nl80211.h
+++ b/include/uapi/linux/nl80211.h
@@ -820,6 +820,10 @@
  *      as an event to indicate changes for devices with wiphy-specific regdom
  *      management.
  *
+ * @NL80211_CMD_ABORT_SCAN: Stop an ongoing scan. Returns -ENOENT if a scan is
+ *      not running. The driver indicates the status of the scan through
+ *      cfg80211_scan_done().
+ *
  * @NL80211_CMD_MAX: highest used command number
  * @__NL80211_CMD_AFTER_LAST: internal use
  */
@@ -1006,6 +1010,8 @@ enum nl80211_commands {
 
         NL80211_CMD_WIPHY_REG_CHANGE,
 
+        NL80211_CMD_ABORT_SCAN,
+
         /* add new commands above here */
 
         /* used to define NL80211_CMD_MAX below */
@@ -1764,8 +1770,9 @@ enum nl80211_commands {
  *      over all channels.
  *
  * @NL80211_ATTR_SCHED_SCAN_DELAY: delay before the first cycle of a
- *      scheduled scan (or a WoWLAN net-detect scan) is started, u32
- *      in seconds.
+ *      scheduled scan is started.  Or the delay before a WoWLAN
+ *      net-detect scan is started, counting from the moment the
+ *      system is suspended.  This value is a u32, in seconds.
 
  * @NL80211_ATTR_REG_INDOOR: flag attribute, if set indicates that the device
  *      is operating in an indoor environment.
diff --git a/include/uapi/linux/pkt_sched.h b/include/uapi/linux/pkt_sched.h
index 8d2530daca9f..8cb18b44968e 100644
--- a/include/uapi/linux/pkt_sched.h
+++ b/include/uapi/linux/pkt_sched.h
@@ -72,6 +72,10 @@ struct tc_estimator {
 #define TC_H_UNSPEC     (0U)
 #define TC_H_ROOT       (0xFFFFFFFFU)
 #define TC_H_INGRESS    (0xFFFFFFF1U)
+#define TC_H_CLSACT     TC_H_INGRESS
+
+#define TC_H_MIN_INGRESS        0xFFF2U
+#define TC_H_MIN_EGRESS         0xFFF3U
 
 /* Need to corrospond to iproute2 tc/tc_core.h "enum link_layer" */
 enum tc_link_layer {
diff --git a/include/uapi/linux/rtnetlink.h b/include/uapi/linux/rtnetlink.h
index 123a5af4e8bb..ca764b5da86d 100644
--- a/include/uapi/linux/rtnetlink.h
+++ b/include/uapi/linux/rtnetlink.h
@@ -311,6 +311,7 @@ enum rtattr_type_t {
         RTA_PREF,
         RTA_ENCAP_TYPE,
         RTA_ENCAP,
+        RTA_EXPIRES,
         __RTA_MAX
 };
 
diff --git a/include/uapi/linux/sock_diag.h b/include/uapi/linux/sock_diag.h
index 49230d36f9ce..bae2d80034d4 100644
--- a/include/uapi/linux/sock_diag.h
+++ b/include/uapi/linux/sock_diag.h
@@ -4,6 +4,7 @@
 #include <linux/types.h>
 
 #define SOCK_DIAG_BY_FAMILY 20
+#define SOCK_DESTROY 21
 
 struct sock_diag_req {
         __u8    sdiag_family;
diff --git a/include/uapi/linux/sockios.h b/include/uapi/linux/sockios.h
index e888b1aed69f..8e7890b26d9a 100644
--- a/include/uapi/linux/sockios.h
+++ b/include/uapi/linux/sockios.h
@@ -27,7 +27,7 @@
 /* Routing table calls. */
 #define SIOCADDRT       0x890B          /* add routing table entry      */
 #define SIOCDELRT       0x890C          /* delete routing table entry   */
-#define SIOCRTMSG       0x890D          /* call to routing system       */
+#define SIOCRTMSG       0x890D          /* unused                       */
 
 /* Socket configuration controls. */
 #define SIOCGIFNAME     0x8910          /* get iface name               */