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

Resolve conflicts between 5888b93 ("Merge branch 'nf-hook-compress'") and
Florian Westphal br_netfilter works.

Conflicts:
        net/bridge/br_netfilter.c

Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

171 files changed, 2047 insertions, 1639 deletions

diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c
index 8b5ab9033b41..01d7ba840df8 100644
--- a/net/8021q/vlan_dev.c
+++ b/net/8021q/vlan_dev.c
@@ -538,7 +538,6 @@ static int vlan_dev_init(struct net_device *dev)
         /* IFF_BROADCAST|IFF_MULTICAST; ??? */
         dev->flags  = real_dev->flags & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
                                           IFF_MASTER | IFF_SLAVE);
-        dev->iflink = real_dev->ifindex;
         dev->state  = (real_dev->state & ((1<<__LINK_STATE_NOCARRIER) |
                                           (1<<__LINK_STATE_DORMANT))) |
                       (1<<__LINK_STATE_PRESENT);
@@ -733,6 +732,13 @@ static void vlan_dev_netpoll_cleanup(struct net_device *dev)
 }
 #endif /* CONFIG_NET_POLL_CONTROLLER */
 
+static int vlan_dev_get_iflink(const struct net_device *dev)
+{
+        struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
+
+        return real_dev->ifindex;
+}
+
 static const struct ethtool_ops vlan_ethtool_ops = {
         .get_settings           = vlan_ethtool_get_settings,
         .get_drvinfo            = vlan_ethtool_get_drvinfo,
@@ -769,6 +775,7 @@ static const struct net_device_ops vlan_netdev_ops = {
 #endif
         .ndo_fix_features       = vlan_dev_fix_features,
         .ndo_get_lock_subclass  = vlan_dev_get_lock_subclass,
+        .ndo_get_iflink         = vlan_dev_get_iflink,
 };
 
 static void vlan_dev_free(struct net_device *dev)
diff --git a/net/batman-adv/hard-interface.c b/net/batman-adv/hard-interface.c
index fbda6b54baff..baf1f9843f2c 100644
--- a/net/batman-adv/hard-interface.c
+++ b/net/batman-adv/hard-interface.c
@@ -83,11 +83,12 @@ static bool batadv_is_on_batman_iface(const struct net_device *net_dev)
                 return true;
 
         /* no more parents..stop recursion */
-        if (net_dev->iflink == 0 || net_dev->iflink == net_dev->ifindex)
+        if (dev_get_iflink(net_dev) == 0 ||
+            dev_get_iflink(net_dev) == net_dev->ifindex)
                 return false;
 
         /* recurse over the parent device */
-        parent_dev = __dev_get_by_index(&init_net, net_dev->iflink);
+        parent_dev = __dev_get_by_index(&init_net, dev_get_iflink(net_dev));
         /* if we got a NULL parent_dev there is something broken.. */
         if (WARN(!parent_dev, "Cannot find parent device"))
                 return false;
diff --git a/net/bluetooth/bnep/bnep.h b/net/bluetooth/bnep/bnep.h
index 5a5b16f365e9..40854c99bc1e 100644
--- a/net/bluetooth/bnep/bnep.h
+++ b/net/bluetooth/bnep/bnep.h
@@ -111,6 +111,10 @@ struct bnep_ext_hdr {
 #define BNEPCONNDEL     _IOW('B', 201, int)
 #define BNEPGETCONNLIST _IOR('B', 210, int)
 #define BNEPGETCONNINFO _IOR('B', 211, int)
+#define BNEPGETSUPPFEAT _IOR('B', 212, int)
+
+#define BNEP_SETUP_RESPONSE     0
+#define BNEP_SETUP_RSP_SENT     10
 
 struct bnep_connadd_req {
         int   sock;             /* Connected socket */
diff --git a/net/bluetooth/bnep/core.c b/net/bluetooth/bnep/core.c
index 05f57e491ccb..1641367e54ca 100644
--- a/net/bluetooth/bnep/core.c
+++ b/net/bluetooth/bnep/core.c
@@ -231,7 +231,14 @@ static int bnep_rx_control(struct bnep_session *s, void *data, int len)
                 break;
 
         case BNEP_SETUP_CONN_REQ:
-                err = bnep_send_rsp(s, BNEP_SETUP_CONN_RSP, BNEP_CONN_NOT_ALLOWED);
+                /* Successful response should be sent only once */
+                if (test_bit(BNEP_SETUP_RESPONSE, &s->flags) &&
+                    !test_and_set_bit(BNEP_SETUP_RSP_SENT, &s->flags))
+                        err = bnep_send_rsp(s, BNEP_SETUP_CONN_RSP,
+                                            BNEP_SUCCESS);
+                else
+                        err = bnep_send_rsp(s, BNEP_SETUP_CONN_RSP,
+                                            BNEP_CONN_NOT_ALLOWED);
                 break;
 
         default: {
@@ -239,7 +246,7 @@ static int bnep_rx_control(struct bnep_session *s, void *data, int len)
                         pkt[0] = BNEP_CONTROL;
                         pkt[1] = BNEP_CMD_NOT_UNDERSTOOD;
                         pkt[2] = cmd;
-                        bnep_send(s, pkt, sizeof(pkt));
+                        err = bnep_send(s, pkt, sizeof(pkt));
                 }
                 break;
         }
@@ -292,29 +299,55 @@ static int bnep_rx_frame(struct bnep_session *s, struct sk_buff *skb)
 {
         struct net_device *dev = s->dev;
         struct sk_buff *nskb;
-        u8 type;
+        u8 type, ctrl_type;
 
         dev->stats.rx_bytes += skb->len;
 
         type = *(u8 *) skb->data;
         skb_pull(skb, 1);
+        ctrl_type = *(u8 *)skb->data;
 
         if ((type & BNEP_TYPE_MASK) >= sizeof(__bnep_rx_hlen))
                 goto badframe;
 
         if ((type & BNEP_TYPE_MASK) == BNEP_CONTROL) {
-                bnep_rx_control(s, skb->data, skb->len);
-                kfree_skb(skb);
-                return 0;
-        }
+                if (bnep_rx_control(s, skb->data, skb->len) < 0) {
+                        dev->stats.tx_errors++;
+                        kfree_skb(skb);
+                        return 0;
+                }
 
-        skb_reset_mac_header(skb);
+                if (!(type & BNEP_EXT_HEADER)) {
+                        kfree_skb(skb);
+                        return 0;
+                }
 
-        /* Verify and pull out header */
-        if (!skb_pull(skb, __bnep_rx_hlen[type & BNEP_TYPE_MASK]))
-                goto badframe;
+                /* Verify and pull ctrl message since it's already processed */
+                switch (ctrl_type) {
+                case BNEP_SETUP_CONN_REQ:
+                        /* Pull: ctrl type (1 b), len (1 b), data (len bytes) */
+                        if (!skb_pull(skb, 2 + *(u8 *)(skb->data + 1) * 2))
+                                goto badframe;
+                        break;
+                case BNEP_FILTER_MULTI_ADDR_SET:
+                case BNEP_FILTER_NET_TYPE_SET:
+                        /* Pull: ctrl type (1 b), len (2 b), data (len bytes) */
+                        if (!skb_pull(skb, 3 + *(u16 *)(skb->data + 1) * 2))
+                                goto badframe;
+                        break;
+                default:
+                        kfree_skb(skb);
+                        return 0;
+                }
+        } else {
+                skb_reset_mac_header(skb);
 
-        s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
+                /* Verify and pull out header */
+                if (!skb_pull(skb, __bnep_rx_hlen[type & BNEP_TYPE_MASK]))
+                        goto badframe;
+
+                s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
+        }
 
         if (type & BNEP_EXT_HEADER) {
                 if (bnep_rx_extension(s, skb) < 0)
@@ -525,6 +558,7 @@ static struct device_type bnep_type = {
 
 int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
 {
+        u32 valid_flags = BIT(BNEP_SETUP_RESPONSE);
         struct net_device *dev;
         struct bnep_session *s, *ss;
         u8 dst[ETH_ALEN], src[ETH_ALEN];
@@ -535,6 +569,9 @@ int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
         if (!l2cap_is_socket(sock))
                 return -EBADFD;
 
+        if (req->flags & ~valid_flags)
+                return -EINVAL;
+
         baswap((void *) dst, &l2cap_pi(sock->sk)->chan->dst);
         baswap((void *) src, &l2cap_pi(sock->sk)->chan->src);
 
@@ -566,6 +603,7 @@ int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
         s->sock  = sock;
         s->role  = req->role;
         s->state = BT_CONNECTED;
+        s->flags = req->flags;
 
         s->msg.msg_flags = MSG_NOSIGNAL;
 
@@ -611,11 +649,15 @@ failed:
 
 int bnep_del_connection(struct bnep_conndel_req *req)
 {
+        u32 valid_flags = 0;
         struct bnep_session *s;
         int  err = 0;
 
         BT_DBG("");
 
+        if (req->flags & ~valid_flags)
+                return -EINVAL;
+
         down_read(&bnep_session_sem);
 
         s = __bnep_get_session(req->dst);
@@ -631,10 +673,12 @@ int bnep_del_connection(struct bnep_conndel_req *req)
 
 static void __bnep_copy_ci(struct bnep_conninfo *ci, struct bnep_session *s)
 {
+        u32 valid_flags = BIT(BNEP_SETUP_RESPONSE);
+
         memset(ci, 0, sizeof(*ci));
         memcpy(ci->dst, s->eh.h_source, ETH_ALEN);
         strcpy(ci->device, s->dev->name);
-        ci->flags = s->flags;
+        ci->flags = s->flags & valid_flags;
         ci->state = s->state;
         ci->role  = s->role;
 }
diff --git a/net/bluetooth/bnep/sock.c b/net/bluetooth/bnep/sock.c
index 5f051290daba..bde2bdd9e929 100644
--- a/net/bluetooth/bnep/sock.c
+++ b/net/bluetooth/bnep/sock.c
@@ -57,6 +57,7 @@ static int bnep_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long
         struct bnep_conninfo ci;
         struct socket *nsock;
         void __user *argp = (void __user *)arg;
+        __u32 supp_feat = BIT(BNEP_SETUP_RESPONSE);
         int err;
 
         BT_DBG("cmd %x arg %lx", cmd, arg);
@@ -120,6 +121,12 @@ static int bnep_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long
 
                 return err;
 
+        case BNEPGETSUPPFEAT:
+                if (copy_to_user(argp, &supp_feat, sizeof(supp_feat)))
+                        return -EFAULT;
+
+                return 0;
+
         default:
                 return -EINVAL;
         }
diff --git a/net/bluetooth/cmtp/capi.c b/net/bluetooth/cmtp/capi.c
index 75bd2c42e3e7..b0c6c6af76ef 100644
--- a/net/bluetooth/cmtp/capi.c
+++ b/net/bluetooth/cmtp/capi.c
@@ -333,7 +333,7 @@ void cmtp_recv_capimsg(struct cmtp_session *session, struct sk_buff *skb)
                 return;
         }
 
-        if (session->flags & (1 << CMTP_LOOPBACK)) {
+        if (session->flags & BIT(CMTP_LOOPBACK)) {
                 kfree_skb(skb);
                 return;
         }
diff --git a/net/bluetooth/cmtp/core.c b/net/bluetooth/cmtp/core.c
index 278a194e6af4..298ed37010e6 100644
--- a/net/bluetooth/cmtp/core.c
+++ b/net/bluetooth/cmtp/core.c
@@ -75,10 +75,11 @@ static void __cmtp_unlink_session(struct cmtp_session *session)
 
 static void __cmtp_copy_session(struct cmtp_session *session, struct cmtp_conninfo *ci)
 {
+        u32 valid_flags = BIT(CMTP_LOOPBACK);
         memset(ci, 0, sizeof(*ci));
         bacpy(&ci->bdaddr, &session->bdaddr);
 
-        ci->flags = session->flags;
+        ci->flags = session->flags & valid_flags;
         ci->state = session->state;
 
         ci->num = session->num;
@@ -313,7 +314,7 @@ static int cmtp_session(void *arg)
 
         down_write(&cmtp_session_sem);
 
-        if (!(session->flags & (1 << CMTP_LOOPBACK)))
+        if (!(session->flags & BIT(CMTP_LOOPBACK)))
                 cmtp_detach_device(session);
 
         fput(session->sock->file);
@@ -329,6 +330,7 @@ static int cmtp_session(void *arg)
 
 int cmtp_add_connection(struct cmtp_connadd_req *req, struct socket *sock)
 {
+        u32 valid_flags = BIT(CMTP_LOOPBACK);
         struct cmtp_session *session, *s;
         int i, err;
 
@@ -337,6 +339,9 @@ int cmtp_add_connection(struct cmtp_connadd_req *req, struct socket *sock)
         if (!l2cap_is_socket(sock))
                 return -EBADFD;
 
+        if (req->flags & ~valid_flags)
+                return -EINVAL;
+
         session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
         if (!session)
                 return -ENOMEM;
@@ -385,7 +390,7 @@ int cmtp_add_connection(struct cmtp_connadd_req *req, struct socket *sock)
                 goto unlink;
         }
 
-        if (!(session->flags & (1 << CMTP_LOOPBACK))) {
+        if (!(session->flags & BIT(CMTP_LOOPBACK))) {
                 err = cmtp_attach_device(session);
                 if (err < 0) {
                         atomic_inc(&session->terminate);
@@ -409,11 +414,15 @@ failed:
 
 int cmtp_del_connection(struct cmtp_conndel_req *req)
 {
+        u32 valid_flags = 0;
         struct cmtp_session *session;
         int err = 0;
 
         BT_DBG("");
 
+        if (req->flags & ~valid_flags)
+                return -EINVAL;
+
         down_read(&cmtp_session_sem);
 
         session = __cmtp_get_session(&req->bdaddr);
diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
index e6bfeb7b4415..46b114c0140b 100644
--- a/net/bluetooth/hci_core.c
+++ b/net/bluetooth/hci_core.c
@@ -141,13 +141,16 @@ static const struct file_operations dut_mode_fops = {
 
 /* ---- HCI requests ---- */
 
-static void hci_req_sync_complete(struct hci_dev *hdev, u8 result, u16 opcode)
+static void hci_req_sync_complete(struct hci_dev *hdev, u8 result, u16 opcode,
+                                  struct sk_buff *skb)
 {
         BT_DBG("%s result 0x%2.2x", hdev->name, result);
 
         if (hdev->req_status == HCI_REQ_PEND) {
                 hdev->req_result = result;
                 hdev->req_status = HCI_REQ_DONE;
+                if (skb)
+                        hdev->req_skb = skb_get(skb);
                 wake_up_interruptible(&hdev->req_wait_q);
         }
 }
@@ -163,66 +166,12 @@ static void hci_req_cancel(struct hci_dev *hdev, int err)
         }
 }
 
-static struct sk_buff *hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode,
-                                            u8 event)
-{
-        struct hci_ev_cmd_complete *ev;
-        struct hci_event_hdr *hdr;
-        struct sk_buff *skb;
-
-        hci_dev_lock(hdev);
-
-        skb = hdev->recv_evt;
-        hdev->recv_evt = NULL;
-
-        hci_dev_unlock(hdev);
-
-        if (!skb)
-                return ERR_PTR(-ENODATA);
-
-        if (skb->len < sizeof(*hdr)) {
-                BT_ERR("Too short HCI event");
-                goto failed;
-        }
-
-        hdr = (void *) skb->data;
-        skb_pull(skb, HCI_EVENT_HDR_SIZE);
-
-        if (event) {
-                if (hdr->evt != event)
-                        goto failed;
-                return skb;
-        }
-
-        if (hdr->evt != HCI_EV_CMD_COMPLETE) {
-                BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt);
-                goto failed;
-        }
-
-        if (skb->len < sizeof(*ev)) {
-                BT_ERR("Too short cmd_complete event");
-                goto failed;
-        }
-
-        ev = (void *) skb->data;
-        skb_pull(skb, sizeof(*ev));
-
-        if (opcode == __le16_to_cpu(ev->opcode))
-                return skb;
-
-        BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode,
-               __le16_to_cpu(ev->opcode));
-
-failed:
-        kfree_skb(skb);
-        return ERR_PTR(-ENODATA);
-}
-
 struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen,
                                   const void *param, u8 event, u32 timeout)
 {
         DECLARE_WAITQUEUE(wait, current);
         struct hci_request req;
+        struct sk_buff *skb;
         int err = 0;
 
         BT_DBG("%s", hdev->name);
@@ -236,7 +185,7 @@ struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen,
         add_wait_queue(&hdev->req_wait_q, &wait);
         set_current_state(TASK_INTERRUPTIBLE);
 
-        err = hci_req_run(&req, hci_req_sync_complete);
+        err = hci_req_run_skb(&req, hci_req_sync_complete);
         if (err < 0) {
                 remove_wait_queue(&hdev->req_wait_q, &wait);
                 set_current_state(TASK_RUNNING);
@@ -265,13 +214,20 @@ struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen,
         }
 
         hdev->req_status = hdev->req_result = 0;
+        skb = hdev->req_skb;
+        hdev->req_skb = NULL;
 
         BT_DBG("%s end: err %d", hdev->name, err);
 
-        if (err < 0)
+        if (err < 0) {
+                kfree_skb(skb);
                 return ERR_PTR(err);
+        }
+
+        if (!skb)
+                return ERR_PTR(-ENODATA);
 
-        return hci_get_cmd_complete(hdev, opcode, event);
+        return skb;
 }
 EXPORT_SYMBOL(__hci_cmd_sync_ev);
 
@@ -303,7 +259,7 @@ static int __hci_req_sync(struct hci_dev *hdev,
         add_wait_queue(&hdev->req_wait_q, &wait);
         set_current_state(TASK_INTERRUPTIBLE);
 
-        err = hci_req_run(&req, hci_req_sync_complete);
+        err = hci_req_run_skb(&req, hci_req_sync_complete);
         if (err < 0) {
                 hdev->req_status = 0;
 
@@ -1690,9 +1646,6 @@ static int hci_dev_do_close(struct hci_dev *hdev)
                 hdev->sent_cmd = NULL;
         }
 
-        kfree_skb(hdev->recv_evt);
-        hdev->recv_evt = NULL;
-
         /* After this point our queues are empty
          * and no tasks are scheduled. */
         hdev->close(hdev);
@@ -3563,11 +3516,6 @@ static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
         }
 }
 
-bool hci_req_pending(struct hci_dev *hdev)
-{
-        return (hdev->req_status == HCI_REQ_PEND);
-}
-
 /* Send HCI command */
 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
                  const void *param)
@@ -3585,7 +3533,7 @@ int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
         /* Stand-alone HCI commands must be flagged as
          * single-command requests.
          */
-        bt_cb(skb)->req_start = 1;
+        bt_cb(skb)->req.start = true;
 
         skb_queue_tail(&hdev->cmd_q, skb);
         queue_work(hdev->workqueue, &hdev->cmd_work);
@@ -4263,7 +4211,7 @@ static bool hci_req_is_complete(struct hci_dev *hdev)
         if (!skb)
                 return true;
 
-        return bt_cb(skb)->req_start;
+        return bt_cb(skb)->req.start;
 }
 
 static void hci_resend_last(struct hci_dev *hdev)
@@ -4288,9 +4236,10 @@ static void hci_resend_last(struct hci_dev *hdev)
         queue_work(hdev->workqueue, &hdev->cmd_work);
 }
 
-void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status)
+void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status,
+                          hci_req_complete_t *req_complete,
+                          hci_req_complete_skb_t *req_complete_skb)
 {
-        hci_req_complete_t req_complete = NULL;
         struct sk_buff *skb;
         unsigned long flags;
 
@@ -4322,36 +4271,29 @@ void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status)
          * callback would be found in hdev->sent_cmd instead of the
          * command queue (hdev->cmd_q).
          */
-        if (hdev->sent_cmd) {
-                req_complete = bt_cb(hdev->sent_cmd)->req_complete;
-
-                if (req_complete) {
-                        /* We must set the complete callback to NULL to
-                         * avoid calling the callback more than once if
-                         * this function gets called again.
-                         */
-                        bt_cb(hdev->sent_cmd)->req_complete = NULL;
+        if (bt_cb(hdev->sent_cmd)->req.complete) {
+                *req_complete = bt_cb(hdev->sent_cmd)->req.complete;
+                return;
+        }
 
-                        goto call_complete;
-                }
+        if (bt_cb(hdev->sent_cmd)->req.complete_skb) {
+                *req_complete_skb = bt_cb(hdev->sent_cmd)->req.complete_skb;
+                return;
         }
 
         /* Remove all pending commands belonging to this request */
         spin_lock_irqsave(&hdev->cmd_q.lock, flags);
         while ((skb = __skb_dequeue(&hdev->cmd_q))) {
-                if (bt_cb(skb)->req_start) {
+                if (bt_cb(skb)->req.start) {
                         __skb_queue_head(&hdev->cmd_q, skb);
                         break;
                 }
 
-                req_complete = bt_cb(skb)->req_complete;
+                *req_complete = bt_cb(skb)->req.complete;
+                *req_complete_skb = bt_cb(skb)->req.complete_skb;
                 kfree_skb(skb);
         }
         spin_unlock_irqrestore(&hdev->cmd_q.lock, flags);
-
-call_complete:
-        if (req_complete)
-                req_complete(hdev, status, status ? opcode : HCI_OP_NOP);
 }
 
 static void hci_rx_work(struct work_struct *work)
diff --git a/net/bluetooth/hci_debugfs.c b/net/bluetooth/hci_debugfs.c
index e6255833a258..7db4220941cc 100644
--- a/net/bluetooth/hci_debugfs.c
+++ b/net/bluetooth/hci_debugfs.c
@@ -114,6 +114,30 @@ static const struct file_operations features_fops = {
         .release        = single_release,
 };
 
+static int device_id_show(struct seq_file *f, void *ptr)
+{
+        struct hci_dev *hdev = f->private;
+
+        hci_dev_lock(hdev);
+        seq_printf(f, "%4.4x:%4.4x:%4.4x:%4.4x\n", hdev->devid_source,
+                  hdev->devid_vendor, hdev->devid_product, hdev->devid_version);
+        hci_dev_unlock(hdev);
+
+        return 0;
+}
+
+static int device_id_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, device_id_show, inode->i_private);
+}
+
+static const struct file_operations device_id_fops = {
+        .open           = device_id_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 static int device_list_show(struct seq_file *f, void *ptr)
 {
         struct hci_dev *hdev = f->private;
@@ -335,6 +359,8 @@ void hci_debugfs_create_common(struct hci_dev *hdev)
         debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev);
         debugfs_create_u8("hardware_error", 0444, hdev->debugfs,
                           &hdev->hw_error_code);
+        debugfs_create_file("device_id", 0444, hdev->debugfs, hdev,
+                            &device_id_fops);
 
         debugfs_create_file("device_list", 0444, hdev->debugfs, hdev,
                             &device_list_fops);
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 62f92a508961..01031038eb0e 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -1045,11 +1045,6 @@ static void hci_cc_read_local_oob_data(struct hci_dev *hdev,
         struct hci_rp_read_local_oob_data *rp = (void *) skb->data;
 
         BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
-
-        hci_dev_lock(hdev);
-        mgmt_read_local_oob_data_complete(hdev, rp->hash, rp->rand, NULL, NULL,
-                                          rp->status);
-        hci_dev_unlock(hdev);
 }
 
 static void hci_cc_read_local_oob_ext_data(struct hci_dev *hdev,
@@ -1058,15 +1053,8 @@ static void hci_cc_read_local_oob_ext_data(struct hci_dev *hdev,
         struct hci_rp_read_local_oob_ext_data *rp = (void *) skb->data;
 
         BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
-
-        hci_dev_lock(hdev);
-        mgmt_read_local_oob_data_complete(hdev, rp->hash192, rp->rand192,
-                                          rp->hash256, rp->rand256,
-                                          rp->status);
-        hci_dev_unlock(hdev);
 }
 
-
 static void hci_cc_le_set_random_addr(struct hci_dev *hdev, struct sk_buff *skb)
 {
         __u8 status = *((__u8 *) skb->data);
@@ -2732,17 +2720,19 @@ unlock:
         hci_dev_unlock(hdev);
 }
 
-static void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
+static void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb,
+                                 u16 *opcode, u8 *status,
+                                 hci_req_complete_t *req_complete,
+                                 hci_req_complete_skb_t *req_complete_skb)
 {
         struct hci_ev_cmd_complete *ev = (void *) skb->data;
-        u8 status = skb->data[sizeof(*ev)];
-        __u16 opcode;
 
-        skb_pull(skb, sizeof(*ev));
+        *opcode = __le16_to_cpu(ev->opcode);
+        *status = skb->data[sizeof(*ev)];
 
-        opcode = __le16_to_cpu(ev->opcode);
+        skb_pull(skb, sizeof(*ev));
 
-        switch (opcode) {
+        switch (*opcode) {
         case HCI_OP_INQUIRY_CANCEL:
                 hci_cc_inquiry_cancel(hdev, skb);
                 break;
@@ -3020,32 +3010,36 @@ static void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
                 break;
 
         default:
-                BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode);
+                BT_DBG("%s opcode 0x%4.4x", hdev->name, *opcode);
                 break;
         }
 
-        if (opcode != HCI_OP_NOP)
+        if (*opcode != HCI_OP_NOP)
                 cancel_delayed_work(&hdev->cmd_timer);
 
-        hci_req_cmd_complete(hdev, opcode, status);
-
-        if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags)) {
+        if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags))
                 atomic_set(&hdev->cmd_cnt, 1);
-                if (!skb_queue_empty(&hdev->cmd_q))
-                        queue_work(hdev->workqueue, &hdev->cmd_work);
-        }
+
+        hci_req_cmd_complete(hdev, *opcode, *status, req_complete,
+                             req_complete_skb);
+
+        if (atomic_read(&hdev->cmd_cnt) && !skb_queue_empty(&hdev->cmd_q))
+                queue_work(hdev->workqueue, &hdev->cmd_work);
 }
 
-static void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
+static void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb,
+                               u16 *opcode, u8 *status,
+                               hci_req_complete_t *req_complete,
+                               hci_req_complete_skb_t *req_complete_skb)
 {
         struct hci_ev_cmd_status *ev = (void *) skb->data;
-        __u16 opcode;
 
         skb_pull(skb, sizeof(*ev));
 
-        opcode = __le16_to_cpu(ev->opcode);
+        *opcode = __le16_to_cpu(ev->opcode);
+        *status = ev->status;
 
-        switch (opcode) {
+        switch (*opcode) {
         case HCI_OP_INQUIRY:
                 hci_cs_inquiry(hdev, ev->status);
                 break;
@@ -3115,22 +3109,29 @@ static void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
                 break;
 
         default:
-                BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode);
+                BT_DBG("%s opcode 0x%4.4x", hdev->name, *opcode);
                 break;
         }
 
-        if (opcode != HCI_OP_NOP)
+        if (*opcode != HCI_OP_NOP)
                 cancel_delayed_work(&hdev->cmd_timer);
 
+        if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags))
+                atomic_set(&hdev->cmd_cnt, 1);
+
+        /* Indicate request completion if the command failed. Also, if
+         * we're not waiting for a special event and we get a success
+         * command status we should try to flag the request as completed
+         * (since for this kind of commands there will not be a command
+         * complete event).
+         */
         if (ev->status ||
-            (hdev->sent_cmd && !bt_cb(hdev->sent_cmd)->req_event))
-                hci_req_cmd_complete(hdev, opcode, ev->status);
+            (hdev->sent_cmd && !bt_cb(hdev->sent_cmd)->req.event))
+                hci_req_cmd_complete(hdev, *opcode, ev->status, req_complete,
+                                     req_complete_skb);
 
-        if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags)) {
-                atomic_set(&hdev->cmd_cnt, 1);
-                if (!skb_queue_empty(&hdev->cmd_q))
-                        queue_work(hdev->workqueue, &hdev->cmd_work);
-        }
+        if (atomic_read(&hdev->cmd_cnt) && !skb_queue_empty(&hdev->cmd_q))
+                queue_work(hdev->workqueue, &hdev->cmd_work);
 }
 
 static void hci_hardware_error_evt(struct hci_dev *hdev, struct sk_buff *skb)
@@ -5031,32 +5032,79 @@ static void hci_chan_selected_evt(struct hci_dev *hdev, struct sk_buff *skb)
         amp_read_loc_assoc_final_data(hdev, hcon);
 }
 
-void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
+static bool hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode,
+                                 u8 event, struct sk_buff *skb)
 {
-        struct hci_event_hdr *hdr = (void *) skb->data;
-        __u8 event = hdr->evt;
+        struct hci_ev_cmd_complete *ev;
+        struct hci_event_hdr *hdr;
 
-        hci_dev_lock(hdev);
+        if (!skb)
+                return false;
 
-        /* Received events are (currently) only needed when a request is
-         * ongoing so avoid unnecessary memory allocation.
-         */
-        if (hci_req_pending(hdev)) {
-                kfree_skb(hdev->recv_evt);
-                hdev->recv_evt = skb_clone(skb, GFP_KERNEL);
+        if (skb->len < sizeof(*hdr)) {
+                BT_ERR("Too short HCI event");
+                return false;
         }
 
-        hci_dev_unlock(hdev);
-
+        hdr = (void *) skb->data;
         skb_pull(skb, HCI_EVENT_HDR_SIZE);
 
-        if (hdev->sent_cmd && bt_cb(hdev->sent_cmd)->req_event == event) {
-                struct hci_command_hdr *cmd_hdr = (void *) hdev->sent_cmd->data;
-                u16 opcode = __le16_to_cpu(cmd_hdr->opcode);
+        if (event) {
+                if (hdr->evt != event)
+                        return false;
+                return true;
+        }
+
+        if (hdr->evt != HCI_EV_CMD_COMPLETE) {
+                BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt);
+                return false;
+        }
+
+        if (skb->len < sizeof(*ev)) {
+                BT_ERR("Too short cmd_complete event");
+                return false;
+        }
+
+        ev = (void *) skb->data;
+        skb_pull(skb, sizeof(*ev));
 
-                hci_req_cmd_complete(hdev, opcode, 0);
+        if (opcode != __le16_to_cpu(ev->opcode)) {
+                BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode,
+                       __le16_to_cpu(ev->opcode));
+                return false;
         }
 
+        return true;
+}
+
+void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
+{
+        struct hci_event_hdr *hdr = (void *) skb->data;
+        hci_req_complete_t req_complete = NULL;
+        hci_req_complete_skb_t req_complete_skb = NULL;
+        struct sk_buff *orig_skb = NULL;
+        u8 status = 0, event = hdr->evt, req_evt = 0;
+        u16 opcode = HCI_OP_NOP;
+
+        if (hdev->sent_cmd && bt_cb(hdev->sent_cmd)->req.event == event) {
+                struct hci_command_hdr *cmd_hdr = (void *) hdev->sent_cmd->data;
+                opcode = __le16_to_cpu(cmd_hdr->opcode);
+                hci_req_cmd_complete(hdev, opcode, status, &req_complete,
+                                     &req_complete_skb);
+                req_evt = event;
+        }
+
+        /* If it looks like we might end up having to call
+         * req_complete_skb, store a pristine copy of the skb since the
+         * various handlers may modify the original one through
+         * skb_pull() calls, etc.
+         */
+        if (req_complete_skb || event == HCI_EV_CMD_STATUS ||
+            event == HCI_EV_CMD_COMPLETE)
+                orig_skb = skb_clone(skb, GFP_KERNEL);
+
+        skb_pull(skb, HCI_EVENT_HDR_SIZE);
+
         switch (event) {
         case HCI_EV_INQUIRY_COMPLETE:
                 hci_inquiry_complete_evt(hdev, skb);
@@ -5099,11 +5147,13 @@ void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
                 break;
 
         case HCI_EV_CMD_COMPLETE:
-                hci_cmd_complete_evt(hdev, skb);
+                hci_cmd_complete_evt(hdev, skb, &opcode, &status,
+                                     &req_complete, &req_complete_skb);
                 break;
 
         case HCI_EV_CMD_STATUS:
-                hci_cmd_status_evt(hdev, skb);
+                hci_cmd_status_evt(hdev, skb, &opcode, &status, &req_complete,
+                                   &req_complete_skb);
                 break;
 
         case HCI_EV_HARDWARE_ERROR:
@@ -5235,6 +5285,17 @@ void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
                 break;
         }
 
+        if (req_complete) {
+                req_complete(hdev, status, opcode);
+        } else if (req_complete_skb) {
+                if (!hci_get_cmd_complete(hdev, opcode, req_evt, orig_skb)) {
+                        kfree_skb(orig_skb);
+                        orig_skb = NULL;
+                }
+                req_complete_skb(hdev, status, opcode, orig_skb);
+        }
+
+        kfree_skb(orig_skb);
         kfree_skb(skb);
         hdev->stat.evt_rx++;
 }
diff --git a/net/bluetooth/hci_request.c b/net/bluetooth/hci_request.c
index 55e096d20a0f..d6025d6e6d59 100644
--- a/net/bluetooth/hci_request.c
+++ b/net/bluetooth/hci_request.c
@@ -34,7 +34,8 @@ void hci_req_init(struct hci_request *req, struct hci_dev *hdev)
         req->err = 0;
 }
 
-int hci_req_run(struct hci_request *req, hci_req_complete_t complete)
+static int req_run(struct hci_request *req, hci_req_complete_t complete,
+                   hci_req_complete_skb_t complete_skb)
 {
         struct hci_dev *hdev = req->hdev;
         struct sk_buff *skb;
@@ -55,7 +56,8 @@ int hci_req_run(struct hci_request *req, hci_req_complete_t complete)
                 return -ENODATA;
 
         skb = skb_peek_tail(&req->cmd_q);
-        bt_cb(skb)->req_complete = complete;
+        bt_cb(skb)->req.complete = complete;
+        bt_cb(skb)->req.complete_skb = complete_skb;
 
         spin_lock_irqsave(&hdev->cmd_q.lock, flags);
         skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q);
@@ -66,6 +68,16 @@ int hci_req_run(struct hci_request *req, hci_req_complete_t complete)
         return 0;
 }
 
+int hci_req_run(struct hci_request *req, hci_req_complete_t complete)
+{
+        return req_run(req, complete, NULL);
+}
+
+int hci_req_run_skb(struct hci_request *req, hci_req_complete_skb_t complete)
+{
+        return req_run(req, NULL, complete);
+}
+
 struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, u32 plen,
                                 const void *param)
 {
@@ -116,9 +128,9 @@ void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen,
         }
 
         if (skb_queue_empty(&req->cmd_q))
-                bt_cb(skb)->req_start = 1;
+                bt_cb(skb)->req.start = true;
 
-        bt_cb(skb)->req_event = event;
+        bt_cb(skb)->req.event = event;
 
         skb_queue_tail(&req->cmd_q, skb);
 }
diff --git a/net/bluetooth/hci_request.h b/net/bluetooth/hci_request.h
index adf074d33544..bf6df92f42db 100644
--- a/net/bluetooth/hci_request.h
+++ b/net/bluetooth/hci_request.h
@@ -32,11 +32,14 @@ struct hci_request {
 
 void hci_req_init(struct hci_request *req, struct hci_dev *hdev);
 int hci_req_run(struct hci_request *req, hci_req_complete_t complete);
+int hci_req_run_skb(struct hci_request *req, hci_req_complete_skb_t complete);
 void hci_req_add(struct hci_request *req, u16 opcode, u32 plen,
                  const void *param);
 void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen,
                     const void *param, u8 event);
-void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status);
+void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status,
+                          hci_req_complete_t *req_complete,
+                          hci_req_complete_skb_t *req_complete_skb);
 
 struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, u32 plen,
                                 const void *param);
diff --git a/net/bluetooth/hci_sock.c b/net/bluetooth/hci_sock.c
index 85a44a7dc150..56f9edbf3d05 100644
--- a/net/bluetooth/hci_sock.c
+++ b/net/bluetooth/hci_sock.c
@@ -1164,7 +1164,7 @@ static int hci_sock_sendmsg(struct socket *sock, struct msghdr *msg,
                         /* Stand-alone HCI commands must be flagged as
                          * single-command requests.
                          */
-                        bt_cb(skb)->req_start = 1;
+                        bt_cb(skb)->req.start = true;
 
                         skb_queue_tail(&hdev->cmd_q, skb);
                         queue_work(hdev->workqueue, &hdev->cmd_work);
diff --git a/net/bluetooth/hidp/core.c b/net/bluetooth/hidp/core.c
index 07348e142f16..a05b9dbf14c9 100644
--- a/net/bluetooth/hidp/core.c
+++ b/net/bluetooth/hidp/core.c
@@ -70,10 +70,11 @@ static void hidp_session_terminate(struct hidp_session *s);
 
 static void hidp_copy_session(struct hidp_session *session, struct hidp_conninfo *ci)
 {
+        u32 valid_flags = 0;
         memset(ci, 0, sizeof(*ci));
         bacpy(&ci->bdaddr, &session->bdaddr);
 
-        ci->flags = session->flags;
+        ci->flags = session->flags & valid_flags;
         ci->state = BT_CONNECTED;
 
         if (session->input) {
@@ -907,7 +908,7 @@ static int hidp_session_new(struct hidp_session **out, const bdaddr_t *bdaddr,
         kref_init(&session->ref);
         atomic_set(&session->state, HIDP_SESSION_IDLING);
         init_waitqueue_head(&session->state_queue);
-        session->flags = req->flags & (1 << HIDP_BLUETOOTH_VENDOR_ID);
+        session->flags = req->flags & BIT(HIDP_BLUETOOTH_VENDOR_ID);
 
         /* connection management */
         bacpy(&session->bdaddr, bdaddr);
@@ -1312,6 +1313,7 @@ int hidp_connection_add(struct hidp_connadd_req *req,
                         struct socket *ctrl_sock,
                         struct socket *intr_sock)
 {
+        u32 valid_flags = 0;
         struct hidp_session *session;
         struct l2cap_conn *conn;
         struct l2cap_chan *chan;
@@ -1321,6 +1323,9 @@ int hidp_connection_add(struct hidp_connadd_req *req,
         if (ret)
                 return ret;
 
+        if (req->flags & ~valid_flags)
+                return -EINVAL;
+
         chan = l2cap_pi(ctrl_sock->sk)->chan;
         conn = NULL;
         l2cap_chan_lock(chan);
@@ -1351,13 +1356,17 @@ out_conn:
 
 int hidp_connection_del(struct hidp_conndel_req *req)
 {
+        u32 valid_flags = BIT(HIDP_VIRTUAL_CABLE_UNPLUG);
         struct hidp_session *session;
 
+        if (req->flags & ~valid_flags)
+                return -EINVAL;
+
         session = hidp_session_find(&req->bdaddr);
         if (!session)
                 return -ENOENT;
 
-        if (req->flags & (1 << HIDP_VIRTUAL_CABLE_UNPLUG))
+        if (req->flags & BIT(HIDP_VIRTUAL_CABLE_UNPLUG))
                 hidp_send_ctrl_message(session,
                                        HIDP_TRANS_HID_CONTROL |
                                          HIDP_CTRL_VIRTUAL_CABLE_UNPLUG,
diff --git a/net/bluetooth/l2cap_core.c b/net/bluetooth/l2cap_core.c
index d69861c89bb5..dad419782a12 100644
--- a/net/bluetooth/l2cap_core.c
+++ b/net/bluetooth/l2cap_core.c
@@ -292,7 +292,7 @@ static struct sk_buff *l2cap_ertm_seq_in_queue(struct sk_buff_head *head,
         struct sk_buff *skb;
 
         skb_queue_walk(head, skb) {
-                if (bt_cb(skb)->control.txseq == seq)
+                if (bt_cb(skb)->l2cap.txseq == seq)
                         return skb;
         }
 
@@ -954,11 +954,11 @@ static inline void __unpack_control(struct l2cap_chan *chan,
 {
         if (test_bit(FLAG_EXT_CTRL, &chan->flags)) {
                 __unpack_extended_control(get_unaligned_le32(skb->data),
-                                          &bt_cb(skb)->control);
+                                          &bt_cb(skb)->l2cap);
                 skb_pull(skb, L2CAP_EXT_CTRL_SIZE);
         } else {
                 __unpack_enhanced_control(get_unaligned_le16(skb->data),
-                                          &bt_cb(skb)->control);
+                                          &bt_cb(skb)->l2cap);
                 skb_pull(skb, L2CAP_ENH_CTRL_SIZE);
         }
 }
@@ -1200,8 +1200,8 @@ static void l2cap_move_setup(struct l2cap_chan *chan)
 
         chan->retry_count = 0;
         skb_queue_walk(&chan->tx_q, skb) {
-                if (bt_cb(skb)->control.retries)
-                        bt_cb(skb)->control.retries = 1;
+                if (bt_cb(skb)->l2cap.retries)
+                        bt_cb(skb)->l2cap.retries = 1;
                 else
                         break;
         }
@@ -1846,8 +1846,8 @@ static void l2cap_streaming_send(struct l2cap_chan *chan,
 
                 skb = skb_dequeue(&chan->tx_q);
 
-                bt_cb(skb)->control.retries = 1;
-                control = &bt_cb(skb)->control;
+                bt_cb(skb)->l2cap.retries = 1;
+                control = &bt_cb(skb)->l2cap;
 
                 control->reqseq = 0;
                 control->txseq = chan->next_tx_seq;
@@ -1891,8 +1891,8 @@ static int l2cap_ertm_send(struct l2cap_chan *chan)
 
                 skb = chan->tx_send_head;
 
-                bt_cb(skb)->control.retries = 1;
-                control = &bt_cb(skb)->control;
+                bt_cb(skb)->l2cap.retries = 1;
+                control = &bt_cb(skb)->l2cap;
 
                 if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))
                         control->final = 1;
@@ -1963,11 +1963,11 @@ static void l2cap_ertm_resend(struct l2cap_chan *chan)
                         continue;
                 }
 
-                bt_cb(skb)->control.retries++;
-                control = bt_cb(skb)->control;
+                bt_cb(skb)->l2cap.retries++;
+                control = bt_cb(skb)->l2cap;
 
                 if (chan->max_tx != 0 &&
-                    bt_cb(skb)->control.retries > chan->max_tx) {
+                    bt_cb(skb)->l2cap.retries > chan->max_tx) {
                         BT_DBG("Retry limit exceeded (%d)", chan->max_tx);
                         l2cap_send_disconn_req(chan, ECONNRESET);
                         l2cap_seq_list_clear(&chan->retrans_list);
@@ -2045,7 +2045,7 @@ static void l2cap_retransmit_all(struct l2cap_chan *chan,
 
         if (chan->unacked_frames) {
                 skb_queue_walk(&chan->tx_q, skb) {
-                        if (bt_cb(skb)->control.txseq == control->reqseq ||
+                        if (bt_cb(skb)->l2cap.txseq == control->reqseq ||
                             skb == chan->tx_send_head)
                                 break;
                 }
@@ -2055,7 +2055,7 @@ static void l2cap_retransmit_all(struct l2cap_chan *chan,
                                 break;
 
                         l2cap_seq_list_append(&chan->retrans_list,
-                                              bt_cb(skb)->control.txseq);
+                                              bt_cb(skb)->l2cap.txseq);
                 }
 
                 l2cap_ertm_resend(chan);
@@ -2267,8 +2267,8 @@ static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan,
                 return ERR_PTR(err);
         }
 
-        bt_cb(skb)->control.fcs = chan->fcs;
-        bt_cb(skb)->control.retries = 0;
+        bt_cb(skb)->l2cap.fcs = chan->fcs;
+        bt_cb(skb)->l2cap.retries = 0;
         return skb;
 }
 
@@ -2321,7 +2321,7 @@ static int l2cap_segment_sdu(struct l2cap_chan *chan,
                         return PTR_ERR(skb);
                 }
 
-                bt_cb(skb)->control.sar = sar;
+                bt_cb(skb)->l2cap.sar = sar;
                 __skb_queue_tail(seg_queue, skb);
 
                 len -= pdu_len;
@@ -2856,7 +2856,7 @@ static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
                         continue;
 
                 /* Don't send frame to the channel it came from */
-                if (bt_cb(skb)->chan == chan)
+                if (bt_cb(skb)->l2cap.chan == chan)
                         continue;
 
                 nskb = skb_clone(skb, GFP_KERNEL);
@@ -5918,7 +5918,7 @@ static int l2cap_rx_queued_iframes(struct l2cap_chan *chan)
 
                 skb_unlink(skb, &chan->srej_q);
                 chan->buffer_seq = __next_seq(chan, chan->buffer_seq);
-                err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->control);
+                err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->l2cap);
                 if (err)
                         break;
         }
@@ -5952,7 +5952,7 @@ static void l2cap_handle_srej(struct l2cap_chan *chan,
                 return;
         }
 
-        if (chan->max_tx != 0 && bt_cb(skb)->control.retries >= chan->max_tx) {
+        if (chan->max_tx != 0 && bt_cb(skb)->l2cap.retries >= chan->max_tx) {
                 BT_DBG("Retry limit exceeded (%d)", chan->max_tx);
                 l2cap_send_disconn_req(chan, ECONNRESET);
                 return;
@@ -6005,7 +6005,7 @@ static void l2cap_handle_rej(struct l2cap_chan *chan,
         skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq);
 
         if (chan->max_tx && skb &&
-            bt_cb(skb)->control.retries >= chan->max_tx) {
+            bt_cb(skb)->l2cap.retries >= chan->max_tx) {
                 BT_DBG("Retry limit exceeded (%d)", chan->max_tx);
                 l2cap_send_disconn_req(chan, ECONNRESET);
                 return;
@@ -6565,7 +6565,7 @@ static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control,
 
 static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb)
 {
-        struct l2cap_ctrl *control = &bt_cb(skb)->control;
+        struct l2cap_ctrl *control = &bt_cb(skb)->l2cap;
         u16 len;
         u8 event;
 
@@ -6864,8 +6864,8 @@ static void l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm,
                 goto drop;
 
         /* Store remote BD_ADDR and PSM for msg_name */
-        bacpy(&bt_cb(skb)->bdaddr, &hcon->dst);
-        bt_cb(skb)->psm = psm;
+        bacpy(&bt_cb(skb)->l2cap.bdaddr, &hcon->dst);
+        bt_cb(skb)->l2cap.psm = psm;
 
         if (!chan->ops->recv(chan, skb)) {
                 l2cap_chan_put(chan);
diff --git a/net/bluetooth/l2cap_sock.c b/net/bluetooth/l2cap_sock.c
index 9070720eedc8..a7278f05eafb 100644
--- a/net/bluetooth/l2cap_sock.c
+++ b/net/bluetooth/l2cap_sock.c
@@ -1330,7 +1330,7 @@ static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
 
         skb->priority = sk->sk_priority;
 
-        bt_cb(skb)->chan = chan;
+        bt_cb(skb)->l2cap.chan = chan;
 
         return skb;
 }
@@ -1444,8 +1444,8 @@ static void l2cap_skb_msg_name(struct sk_buff *skb, void *msg_name,
 
         memset(la, 0, sizeof(struct sockaddr_l2));
         la->l2_family = AF_BLUETOOTH;
-        la->l2_psm = bt_cb(skb)->psm;
-        bacpy(&la->l2_bdaddr, &bt_cb(skb)->bdaddr);
+        la->l2_psm = bt_cb(skb)->l2cap.psm;
+        bacpy(&la->l2_bdaddr, &bt_cb(skb)->l2cap.bdaddr);
 
         *msg_namelen = sizeof(struct sockaddr_l2);
 }
diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index fb2e764c6211..845dfcc43a20 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -985,14 +985,27 @@ static u32 get_adv_instance_flags(struct hci_dev *hdev, u8 instance)
         /* Instance 0 always manages the "Tx Power" and "Flags" fields */
         flags = MGMT_ADV_FLAG_TX_POWER | MGMT_ADV_FLAG_MANAGED_FLAGS;
 
-        /* For instance 0, assemble the flags from global settings */
-        if (hci_dev_test_flag(hdev, HCI_ADVERTISING_CONNECTABLE) ||
-            get_connectable(hdev))
+        /* For instance 0, the HCI_ADVERTISING_CONNECTABLE setting corresponds
+         * to the "connectable" instance flag.
+         */
+        if (hci_dev_test_flag(hdev, HCI_ADVERTISING_CONNECTABLE))
                 flags |= MGMT_ADV_FLAG_CONNECTABLE;
 
         return flags;
 }
 
+static u8 get_adv_instance_scan_rsp_len(struct hci_dev *hdev, u8 instance)
+{
+        /* Ignore instance 0 and other unsupported instances */
+        if (instance != 0x01)
+                return 0;
+
+        /* TODO: Take into account the "appearance" and "local-name" flags here.
+         * These are currently being ignored as they are not supported.
+         */
+        return hdev->adv_instance.scan_rsp_len;
+}
+
 static u8 create_instance_adv_data(struct hci_dev *hdev, u8 instance, u8 *ptr)
 {
         u8 ad_len = 0, flags = 0;
@@ -1030,6 +1043,14 @@ static u8 create_instance_adv_data(struct hci_dev *hdev, u8 instance, u8 *ptr)
                 }
         }
 
+        if (instance) {
+                memcpy(ptr, hdev->adv_instance.adv_data,
+                       hdev->adv_instance.adv_data_len);
+
+                ad_len += hdev->adv_instance.adv_data_len;
+                ptr += hdev->adv_instance.adv_data_len;
+        }
+
         /* Provide Tx Power only if we can provide a valid value for it */
         if (hdev->adv_tx_power != HCI_TX_POWER_INVALID &&
             (instance_flags & MGMT_ADV_FLAG_TX_POWER)) {
@@ -1041,12 +1062,6 @@ static u8 create_instance_adv_data(struct hci_dev *hdev, u8 instance, u8 *ptr)
                 ptr += 3;
         }
 
-        if (instance) {
-                memcpy(ptr, hdev->adv_instance.adv_data,
-                       hdev->adv_instance.adv_data_len);
-                ad_len += hdev->adv_instance.adv_data_len;
-        }
-
         return ad_len;
 }
 
@@ -1242,7 +1257,12 @@ static void enable_advertising(struct hci_request *req)
 
         instance = get_current_adv_instance(hdev);
         flags = get_adv_instance_flags(hdev, instance);
-        connectable = (flags & MGMT_ADV_FLAG_CONNECTABLE);
+
+        /* If the "connectable" instance flag was not set, then choose between
+         * ADV_IND and ADV_NONCONN_IND based on the global connectable setting.
+         */
+        connectable = (flags & MGMT_ADV_FLAG_CONNECTABLE) ||
+                      get_connectable(hdev);
 
         /* Set require_privacy to true only when non-connectable
          * advertising is used. In that case it is fine to use a
@@ -1254,7 +1274,14 @@ static void enable_advertising(struct hci_request *req)
         memset(&cp, 0, sizeof(cp));
         cp.min_interval = cpu_to_le16(hdev->le_adv_min_interval);
         cp.max_interval = cpu_to_le16(hdev->le_adv_max_interval);
-        cp.type = connectable ? LE_ADV_IND : LE_ADV_NONCONN_IND;
+
+        if (connectable)
+                cp.type = LE_ADV_IND;
+        else if (get_adv_instance_scan_rsp_len(hdev, instance))
+                cp.type = LE_ADV_SCAN_IND;
+        else
+                cp.type = LE_ADV_NONCONN_IND;
+
         cp.own_address_type = own_addr_type;
         cp.channel_map = hdev->le_adv_channel_map;
 
@@ -2088,7 +2115,8 @@ static int set_connectable(struct sock *sk, struct hci_dev *hdev, void *data,
 
 no_scan_update:
         /* Update the advertising parameters if necessary */
-        if (hci_dev_test_flag(hdev, HCI_ADVERTISING))
+        if (hci_dev_test_flag(hdev, HCI_ADVERTISING) ||
+            hci_dev_test_flag(hdev, HCI_ADVERTISING_INSTANCE))
                 enable_advertising(&req);
 
         err = hci_req_run(&req, set_connectable_complete);
@@ -3757,10 +3785,70 @@ failed:
         return err;
 }
 
+static void read_local_oob_data_complete(struct hci_dev *hdev, u8 status,
+                                         u16 opcode, struct sk_buff *skb)
+{
+        struct mgmt_rp_read_local_oob_data mgmt_rp;
+        size_t rp_size = sizeof(mgmt_rp);
+        struct mgmt_pending_cmd *cmd;
+
+        BT_DBG("%s status %u", hdev->name, status);
+
+        cmd = pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev);
+        if (!cmd)
+                return;
+
+        if (status || !skb) {
+                mgmt_cmd_status(cmd->sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
+                                status ? mgmt_status(status) : MGMT_STATUS_FAILED);
+                goto remove;
+        }
+
+        memset(&mgmt_rp, 0, sizeof(mgmt_rp));
+
+        if (opcode == HCI_OP_READ_LOCAL_OOB_DATA) {
+                struct hci_rp_read_local_oob_data *rp = (void *) skb->data;
+
+                if (skb->len < sizeof(*rp)) {
+                        mgmt_cmd_status(cmd->sk, hdev->id,
+                                        MGMT_OP_READ_LOCAL_OOB_DATA,
+                                        MGMT_STATUS_FAILED);
+                        goto remove;
+                }
+
+                memcpy(mgmt_rp.hash192, rp->hash, sizeof(rp->hash));
+                memcpy(mgmt_rp.rand192, rp->rand, sizeof(rp->rand));
+
+                rp_size -= sizeof(mgmt_rp.hash256) + sizeof(mgmt_rp.rand256);
+        } else {
+                struct hci_rp_read_local_oob_ext_data *rp = (void *) skb->data;
+
+                if (skb->len < sizeof(*rp)) {
+                        mgmt_cmd_status(cmd->sk, hdev->id,
+                                        MGMT_OP_READ_LOCAL_OOB_DATA,
+                                        MGMT_STATUS_FAILED);
+                        goto remove;
+                }
+
+                memcpy(mgmt_rp.hash192, rp->hash192, sizeof(rp->hash192));
+                memcpy(mgmt_rp.rand192, rp->rand192, sizeof(rp->rand192));
+
+                memcpy(mgmt_rp.hash256, rp->hash256, sizeof(rp->hash256));
+                memcpy(mgmt_rp.rand256, rp->rand256, sizeof(rp->rand256));
+        }
+
+        mgmt_cmd_complete(cmd->sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
+                          MGMT_STATUS_SUCCESS, &mgmt_rp, rp_size);
+
+remove:
+        mgmt_pending_remove(cmd);
+}
+
 static int read_local_oob_data(struct sock *sk, struct hci_dev *hdev,
                                void *data, u16 data_len)
 {
         struct mgmt_pending_cmd *cmd;
+        struct hci_request req;
         int err;
 
         BT_DBG("%s", hdev->name);
@@ -3791,12 +3879,14 @@ static int read_local_oob_data(struct sock *sk, struct hci_dev *hdev,
                 goto unlock;
         }
 
+        hci_req_init(&req, hdev);
+
         if (bredr_sc_enabled(hdev))
-                err = hci_send_cmd(hdev, HCI_OP_READ_LOCAL_OOB_EXT_DATA,
-                                   0, NULL);
+                hci_req_add(&req, HCI_OP_READ_LOCAL_OOB_EXT_DATA, 0, NULL);
         else
-                err = hci_send_cmd(hdev, HCI_OP_READ_LOCAL_OOB_DATA, 0, NULL);
+                hci_req_add(&req, HCI_OP_READ_LOCAL_OOB_DATA, 0, NULL);
 
+        err = hci_req_run_skb(&req, read_local_oob_data_complete);
         if (err < 0)
                 mgmt_pending_remove(cmd);
 
@@ -6388,46 +6478,41 @@ static int read_local_oob_ext_data(struct sock *sk, struct hci_dev *hdev,
 
         BT_DBG("%s", hdev->name);
 
-        if (!hdev_is_powered(hdev))
-                return mgmt_cmd_complete(sk, hdev->id,
-                                         MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
-                                         MGMT_STATUS_NOT_POWERED,
-                                         &cp->type, sizeof(cp->type));
-
-        switch (cp->type) {
-        case BIT(BDADDR_BREDR):
-                status = mgmt_bredr_support(hdev);
-                if (status)
-                        return mgmt_cmd_complete(sk, hdev->id,
-                                                 MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
-                                                 status, &cp->type,
-                                                 sizeof(cp->type));
-                eir_len = 5;
-                break;
-        case (BIT(BDADDR_LE_PUBLIC) | BIT(BDADDR_LE_RANDOM)):
-                status = mgmt_le_support(hdev);
-                if (status)
-                        return mgmt_cmd_complete(sk, hdev->id,
-                                                 MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
-                                                 status, &cp->type,
-                                                 sizeof(cp->type));
-                eir_len = 9 + 3 + 18 + 18 + 3;
-                break;
-        default:
-                return mgmt_cmd_complete(sk, hdev->id,
-                                         MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
-                                         MGMT_STATUS_INVALID_PARAMS,
-                                         &cp->type, sizeof(cp->type));
+        if (hdev_is_powered(hdev)) {
+                switch (cp->type) {
+                case BIT(BDADDR_BREDR):
+                        status = mgmt_bredr_support(hdev);
+                        if (status)
+                                eir_len = 0;
+                        else
+                                eir_len = 5;
+                        break;
+                case (BIT(BDADDR_LE_PUBLIC) | BIT(BDADDR_LE_RANDOM)):
+                        status = mgmt_le_support(hdev);
+                        if (status)
+                                eir_len = 0;
+                        else
+                                eir_len = 9 + 3 + 18 + 18 + 3;
+                        break;
+                default:
+                        status = MGMT_STATUS_INVALID_PARAMS;
+                        eir_len = 0;
+                        break;
+                }
+        } else {
+                status = MGMT_STATUS_NOT_POWERED;
+                eir_len = 0;
         }
 
-        hci_dev_lock(hdev);
-
         rp_len = sizeof(*rp) + eir_len;
         rp = kmalloc(rp_len, GFP_ATOMIC);
-        if (!rp) {
-                hci_dev_unlock(hdev);
+        if (!rp)
                 return -ENOMEM;
-        }
+
+        if (status)
+                goto complete;
+
+        hci_dev_lock(hdev);
 
         eir_len = 0;
         switch (cp->type) {
@@ -6439,20 +6524,30 @@ static int read_local_oob_ext_data(struct sock *sk, struct hci_dev *hdev,
                 if (hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
                     smp_generate_oob(hdev, hash, rand) < 0) {
                         hci_dev_unlock(hdev);
-                        err = mgmt_cmd_complete(sk, hdev->id,
-                                                MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
-                                                MGMT_STATUS_FAILED,
-                                                &cp->type, sizeof(cp->type));
-                        goto done;
+                        status = MGMT_STATUS_FAILED;
+                        goto complete;
                 }
 
+                /* This should return the active RPA, but since the RPA
+                 * is only programmed on demand, it is really hard to fill
+                 * this in at the moment. For now disallow retrieving
+                 * local out-of-band data when privacy is in use.
+                 *
+                 * Returning the identity address will not help here since
+                 * pairing happens before the identity resolving key is
+                 * known and thus the connection establishment happens
+                 * based on the RPA and not the identity address.
+                 */
                 if (hci_dev_test_flag(hdev, HCI_PRIVACY)) {
-                        memcpy(addr, &hdev->rpa, 6);
-                        addr[6] = 0x01;
-                } else if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ||
-                           !bacmp(&hdev->bdaddr, BDADDR_ANY) ||
-                           (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) &&
-                            bacmp(&hdev->static_addr, BDADDR_ANY))) {
+                        hci_dev_unlock(hdev);
+                        status = MGMT_STATUS_REJECTED;
+                        goto complete;
+                }
+
+                if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ||
+                   !bacmp(&hdev->bdaddr, BDADDR_ANY) ||
+                   (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) &&
+                    bacmp(&hdev->static_addr, BDADDR_ANY))) {
                         memcpy(addr, &hdev->static_addr, 6);
                         addr[6] = 0x01;
                 } else {
@@ -6491,16 +6586,19 @@ static int read_local_oob_ext_data(struct sock *sk, struct hci_dev *hdev,
                 break;
         }
 
-        rp->type = cp->type;
-        rp->eir_len = cpu_to_le16(eir_len);
-
         hci_dev_unlock(hdev);
 
         hci_sock_set_flag(sk, HCI_MGMT_OOB_DATA_EVENTS);
 
+        status = MGMT_STATUS_SUCCESS;
+
+complete:
+        rp->type = cp->type;
+        rp->eir_len = cpu_to_le16(eir_len);
+
         err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
-                                MGMT_STATUS_SUCCESS, rp, sizeof(*rp) + eir_len);
-        if (err < 0)
+                                status, rp, sizeof(*rp) + eir_len);
+        if (err < 0 || status)
                 goto done;
 
         err = mgmt_limited_event(MGMT_EV_LOCAL_OOB_DATA_UPDATED, hdev,
@@ -7899,43 +7997,6 @@ void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status)
                            cmd ? cmd->sk : NULL);
 }
 
-void mgmt_read_local_oob_data_complete(struct hci_dev *hdev, u8 *hash192,
-                                       u8 *rand192, u8 *hash256, u8 *rand256,
-                                       u8 status)
-{
-        struct mgmt_pending_cmd *cmd;
-
-        BT_DBG("%s status %u", hdev->name, status);
-
-        cmd = pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev);
-        if (!cmd)
-                return;
-
-        if (status) {
-                mgmt_cmd_status(cmd->sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
-                                mgmt_status(status));
-        } else {
-                struct mgmt_rp_read_local_oob_data rp;
-                size_t rp_size = sizeof(rp);
-
-                memcpy(rp.hash192, hash192, sizeof(rp.hash192));
-                memcpy(rp.rand192, rand192, sizeof(rp.rand192));
-
-                if (bredr_sc_enabled(hdev) && hash256 && rand256) {
-                        memcpy(rp.hash256, hash256, sizeof(rp.hash256));
-                        memcpy(rp.rand256, rand256, sizeof(rp.rand256));
-                } else {
-                        rp_size -= sizeof(rp.hash256) + sizeof(rp.rand256);
-                }
-
-                mgmt_cmd_complete(cmd->sk, hdev->id,
-                                  MGMT_OP_READ_LOCAL_OOB_DATA, 0,
-                                  &rp, rp_size);
-        }
-
-        mgmt_pending_remove(cmd);
-}
-
 static inline bool has_uuid(u8 *uuid, u16 uuid_count, u8 (*uuids)[16])
 {
         int i;
diff --git a/net/bluetooth/selftest.c b/net/bluetooth/selftest.c
index 378f4064952c..dc688f13e496 100644
--- a/net/bluetooth/selftest.c
+++ b/net/bluetooth/selftest.c
@@ -21,6 +21,8 @@
    SOFTWARE IS DISCLAIMED.
 */
 
+#include <linux/debugfs.h>
+
 #include <net/bluetooth/bluetooth.h>
 #include <net/bluetooth/hci_core.h>
 
@@ -154,6 +156,21 @@ static int __init test_ecdh_sample(const u8 priv_a[32], const u8 priv_b[32],
         return 0;
 }
 
+static char test_ecdh_buffer[32];
+
+static ssize_t test_ecdh_read(struct file *file, char __user *user_buf,
+                              size_t count, loff_t *ppos)
+{
+        return simple_read_from_buffer(user_buf, count, ppos, test_ecdh_buffer,
+                                       strlen(test_ecdh_buffer));
+}
+
+static const struct file_operations test_ecdh_fops = {
+        .open           = simple_open,
+        .read           = test_ecdh_read,
+        .llseek         = default_llseek,
+};
+
 static int __init test_ecdh(void)
 {
         ktime_t calltime, delta, rettime;
@@ -165,19 +182,19 @@ static int __init test_ecdh(void)
         err = test_ecdh_sample(priv_a_1, priv_b_1, pub_a_1, pub_b_1, dhkey_1);
         if (err) {
                 BT_ERR("ECDH sample 1 failed");
-                return err;
+                goto done;
         }
 
         err = test_ecdh_sample(priv_a_2, priv_b_2, pub_a_2, pub_b_2, dhkey_2);
         if (err) {
                 BT_ERR("ECDH sample 2 failed");
-                return err;
+                goto done;
         }
 
         err = test_ecdh_sample(priv_a_3, priv_a_3, pub_a_3, pub_a_3, dhkey_3);
         if (err) {
                 BT_ERR("ECDH sample 3 failed");
-                return err;
+                goto done;
         }
 
         rettime = ktime_get();
@@ -186,7 +203,17 @@ static int __init test_ecdh(void)
 
         BT_INFO("ECDH test passed in %llu usecs", duration);
 
-        return 0;
+done:
+        if (!err)
+                snprintf(test_ecdh_buffer, sizeof(test_ecdh_buffer),
+                         "PASS (%llu usecs)\n", duration);
+        else
+                snprintf(test_ecdh_buffer, sizeof(test_ecdh_buffer), "FAIL\n");
+
+        debugfs_create_file("selftest_ecdh", 0444, bt_debugfs, NULL,
+                            &test_ecdh_fops);
+
+        return err;
 }
 
 #else
diff --git a/net/bluetooth/smp.c b/net/bluetooth/smp.c
index 1ec3f66b5a74..1ab3dc9c8f99 100644
--- a/net/bluetooth/smp.c
+++ b/net/bluetooth/smp.c
@@ -3017,7 +3017,7 @@ static struct sk_buff *smp_alloc_skb_cb(struct l2cap_chan *chan,
                 return ERR_PTR(-ENOMEM);
 
         skb->priority = HCI_PRIO_MAX;
-        bt_cb(skb)->chan = chan;
+        bt_cb(skb)->l2cap.chan = chan;
 
         return skb;
 }
@@ -3549,6 +3549,21 @@ static int __init test_h6(struct crypto_hash *tfm_cmac)
         return 0;
 }
 
+static char test_smp_buffer[32];
+
+static ssize_t test_smp_read(struct file *file, char __user *user_buf,
+                             size_t count, loff_t *ppos)
+{
+        return simple_read_from_buffer(user_buf, count, ppos, test_smp_buffer,
+                                       strlen(test_smp_buffer));
+}
+
+static const struct file_operations test_smp_fops = {
+        .open           = simple_open,
+        .read           = test_smp_read,
+        .llseek         = default_llseek,
+};
+
 static int __init run_selftests(struct crypto_blkcipher *tfm_aes,
                                 struct crypto_hash *tfm_cmac)
 {
@@ -3561,49 +3576,49 @@ static int __init run_selftests(struct crypto_blkcipher *tfm_aes,
         err = test_ah(tfm_aes);
         if (err) {
                 BT_ERR("smp_ah test failed");
-                return err;
+                goto done;
         }
 
         err = test_c1(tfm_aes);
         if (err) {
                 BT_ERR("smp_c1 test failed");
-                return err;
+                goto done;
         }
 
         err = test_s1(tfm_aes);
         if (err) {
                 BT_ERR("smp_s1 test failed");
-                return err;
+                goto done;
         }
 
         err = test_f4(tfm_cmac);
         if (err) {
                 BT_ERR("smp_f4 test failed");
-                return err;
+                goto done;
         }
 
         err = test_f5(tfm_cmac);
         if (err) {
                 BT_ERR("smp_f5 test failed");
-                return err;
+                goto done;
         }
 
         err = test_f6(tfm_cmac);
         if (err) {
                 BT_ERR("smp_f6 test failed");
-                return err;
+                goto done;
         }
 
         err = test_g2(tfm_cmac);
         if (err) {
                 BT_ERR("smp_g2 test failed");
-                return err;
+                goto done;
         }
 
         err = test_h6(tfm_cmac);
         if (err) {
                 BT_ERR("smp_h6 test failed");
-                return err;
+                goto done;
         }
 
         rettime = ktime_get();
@@ -3612,7 +3627,17 @@ static int __init run_selftests(struct crypto_blkcipher *tfm_aes,
 
         BT_INFO("SMP test passed in %llu usecs", duration);
 
-        return 0;
+done:
+        if (!err)
+                snprintf(test_smp_buffer, sizeof(test_smp_buffer),
+                         "PASS (%llu usecs)\n", duration);
+        else
+                snprintf(test_smp_buffer, sizeof(test_smp_buffer), "FAIL\n");
+
+        debugfs_create_file("selftest_smp", 0444, bt_debugfs, NULL,
+                            &test_smp_fops);
+
+        return err;
 }
 
 int __init bt_selftest_smp(void)
diff --git a/net/bridge/br_forward.c b/net/bridge/br_forward.c
index 3304a5442331..e97572b5d2cc 100644
--- a/net/bridge/br_forward.c
+++ b/net/bridge/br_forward.c
@@ -35,7 +35,7 @@ static inline int should_deliver(const struct net_bridge_port *p,
                 p->state == BR_STATE_FORWARDING;
 }
 
-int br_dev_queue_push_xmit(struct sk_buff *skb)
+int br_dev_queue_push_xmit(struct sock *sk, struct sk_buff *skb)
 {
         if (!is_skb_forwardable(skb->dev, skb)) {
                 kfree_skb(skb);
@@ -49,9 +49,10 @@ int br_dev_queue_push_xmit(struct sk_buff *skb)
 }
 EXPORT_SYMBOL_GPL(br_dev_queue_push_xmit);
 
-int br_forward_finish(struct sk_buff *skb)
+int br_forward_finish(struct sock *sk, struct sk_buff *skb)
 {
-        return NF_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING, skb, NULL, skb->dev,
+        return NF_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING, sk, skb,
+                       NULL, skb->dev,
                        br_dev_queue_push_xmit);
 
 }
@@ -75,7 +76,8 @@ static void __br_deliver(const struct net_bridge_port *to, struct sk_buff *skb)
                 return;
         }
 
-        NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
+        NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, NULL, skb,
+                NULL, skb->dev,
                 br_forward_finish);
 }
 
@@ -96,7 +98,8 @@ static void __br_forward(const struct net_bridge_port *to, struct sk_buff *skb)
         skb->dev = to->dev;
         skb_forward_csum(skb);
 
-        NF_HOOK(NFPROTO_BRIDGE, NF_BR_FORWARD, skb, indev, skb->dev,
+        NF_HOOK(NFPROTO_BRIDGE, NF_BR_FORWARD, NULL, skb,
+                indev, skb->dev,
                 br_forward_finish);
 }
 
diff --git a/net/bridge/br_input.c b/net/bridge/br_input.c
index 052c5ebbc947..f921a5dce22d 100644
--- a/net/bridge/br_input.c
+++ b/net/bridge/br_input.c
@@ -55,8 +55,9 @@ static int br_pass_frame_up(struct sk_buff *skb)
         if (!skb)
                 return NET_RX_DROP;
 
-        return NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, skb, indev, NULL,
-                       netif_receive_skb);
+        return NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, NULL, skb,
+                       indev, NULL,
+                       netif_receive_skb_sk);
 }
 
 static void br_do_proxy_arp(struct sk_buff *skb, struct net_bridge *br,
@@ -119,7 +120,7 @@ static void br_do_proxy_arp(struct sk_buff *skb, struct net_bridge *br,
 }
 
 /* note: already called with rcu_read_lock */
-int br_handle_frame_finish(struct sk_buff *skb)
+int br_handle_frame_finish(struct sock *sk, struct sk_buff *skb)
 {
         const unsigned char *dest = eth_hdr(skb)->h_dest;
         struct net_bridge_port *p = br_port_get_rcu(skb->dev);
@@ -207,7 +208,7 @@ drop:
 EXPORT_SYMBOL_GPL(br_handle_frame_finish);
 
 /* note: already called with rcu_read_lock */
-static int br_handle_local_finish(struct sk_buff *skb)
+static int br_handle_local_finish(struct sock *sk, struct sk_buff *skb)
 {
         struct net_bridge_port *p = br_port_get_rcu(skb->dev);
         u16 vid = 0;
@@ -277,8 +278,8 @@ rx_handler_result_t br_handle_frame(struct sk_buff **pskb)
                 }
 
                 /* Deliver packet to local host only */
-                if (NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, skb, skb->dev,
-                            NULL, br_handle_local_finish)) {
+                if (NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, NULL, skb,
+                            skb->dev, NULL, br_handle_local_finish)) {
                         return RX_HANDLER_CONSUMED; /* consumed by filter */
                 } else {
                         *pskb = skb;
@@ -302,7 +303,8 @@ forward:
                 if (ether_addr_equal(p->br->dev->dev_addr, dest))
                         skb->pkt_type = PACKET_HOST;
 
-                NF_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
+                NF_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, NULL, skb,
+                        skb->dev, NULL,
                         br_handle_frame_finish);
                 break;
         default:
diff --git a/net/bridge/br_multicast.c b/net/bridge/br_multicast.c
index c465876c7861..4b6722f8f179 100644
--- a/net/bridge/br_multicast.c
+++ b/net/bridge/br_multicast.c
@@ -814,7 +814,8 @@ static void __br_multicast_send_query(struct net_bridge *br,
 
         if (port) {
                 skb->dev = port->dev;
-                NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
+                NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, NULL, skb,
+                        NULL, skb->dev,
                         br_dev_queue_push_xmit);
         } else {
                 br_multicast_select_own_querier(br, ip, skb);
diff --git a/net/bridge/br_netfilter.c b/net/bridge/br_netfilter.c
index e8ac7432acb6..ab55e2472beb 100644
--- a/net/bridge/br_netfilter.c
+++ b/net/bridge/br_netfilter.c
@@ -277,7 +277,7 @@ static void nf_bridge_update_protocol(struct sk_buff *skb)
 /* PF_BRIDGE/PRE_ROUTING *********************************************/
 /* Undo the changes made for ip6tables PREROUTING and continue the
  * bridge PRE_ROUTING hook. */
-static int br_nf_pre_routing_finish_ipv6(struct sk_buff *skb)
+static int br_nf_pre_routing_finish_ipv6(struct sock *sk, struct sk_buff *skb)
 {
         struct nf_bridge_info *nf_bridge = nf_bridge_info_get(skb);
         struct rtable *rt;
@@ -298,7 +298,8 @@ static int br_nf_pre_routing_finish_ipv6(struct sk_buff *skb)
         skb->dev = nf_bridge->physindev;
         nf_bridge_update_protocol(skb);
         nf_bridge_push_encap_header(skb);
-        NF_HOOK_THRESH(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
+        NF_HOOK_THRESH(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, sk, skb,
+                       skb->dev, NULL,
                        br_handle_frame_finish, 1);
 
         return 0;
@@ -309,7 +310,7 @@ static int br_nf_pre_routing_finish_ipv6(struct sk_buff *skb)
  * don't, we use the neighbour framework to find out. In both cases, we make
  * sure that br_handle_frame_finish() is called afterwards.
  */
-static int br_nf_pre_routing_finish_bridge(struct sk_buff *skb)
+static int br_nf_pre_routing_finish_bridge(struct sock *sk, struct sk_buff *skb)
 {
         struct neighbour *neigh;
         struct dst_entry *dst;
@@ -326,7 +327,7 @@ static int br_nf_pre_routing_finish_bridge(struct sk_buff *skb)
                 if (neigh->hh.hh_len) {
                         neigh_hh_bridge(&neigh->hh, skb);
                         skb->dev = nf_bridge->physindev;
-                        ret = br_handle_frame_finish(skb);
+                        ret = br_handle_frame_finish(sk, skb);
                 } else {
                         /* the neighbour function below overwrites the complete
                          * MAC header, so we save the Ethernet source address and
@@ -403,7 +404,7 @@ static bool dnat_took_place(const struct sk_buff *skb)
  * device, we proceed as if ip_route_input() succeeded. If it differs from the
  * logical bridge port or if ip_route_output_key() fails we drop the packet.
  */
-static int br_nf_pre_routing_finish(struct sk_buff *skb)
+static int br_nf_pre_routing_finish(struct sock *sk, struct sk_buff *skb)
 {
         struct net_device *dev = skb->dev;
         struct iphdr *iph = ip_hdr(skb);
@@ -456,7 +457,7 @@ bridged_dnat:
                                 nf_bridge_push_encap_header(skb);
                                 NF_HOOK_THRESH(NFPROTO_BRIDGE,
                                                NF_BR_PRE_ROUTING,
-                                               skb, skb->dev, NULL,
+                                               sk, skb, skb->dev, NULL,
                                                br_nf_pre_routing_finish_bridge,
                                                1);
                                 return 0;
@@ -476,7 +477,8 @@ bridged_dnat:
         skb->dev = nf_bridge->physindev;
         nf_bridge_update_protocol(skb);
         nf_bridge_push_encap_header(skb);
-        NF_HOOK_THRESH(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
+        NF_HOOK_THRESH(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, sk, skb,
+                       skb->dev, NULL,
                        br_handle_frame_finish, 1);
 
         return 0;
@@ -579,9 +581,7 @@ bad:
  * to ip6tables, which doesn't support NAT, so things are fairly simple. */
 static unsigned int br_nf_pre_routing_ipv6(const struct nf_hook_ops *ops,
                                            struct sk_buff *skb,
-                                           const struct net_device *in,
-                                           const struct net_device *out,
-                                           int (*okfn)(struct sk_buff *))
+                                           const struct nf_hook_state *state)
 {
         const struct ipv6hdr *hdr;
         u32 pkt_len;
@@ -615,7 +615,8 @@ static unsigned int br_nf_pre_routing_ipv6(const struct nf_hook_ops *ops,
                 return NF_DROP;
 
         skb->protocol = htons(ETH_P_IPV6);
-        NF_HOOK(NFPROTO_IPV6, NF_INET_PRE_ROUTING, skb, skb->dev, NULL,
+        NF_HOOK(NFPROTO_IPV6, NF_INET_PRE_ROUTING, state->sk, skb,
+                skb->dev, NULL,
                 br_nf_pre_routing_finish_ipv6);
 
         return NF_STOLEN;
@@ -629,9 +630,7 @@ static unsigned int br_nf_pre_routing_ipv6(const struct nf_hook_ops *ops,
  * address to be able to detect DNAT afterwards. */
 static unsigned int br_nf_pre_routing(const struct nf_hook_ops *ops,
                                       struct sk_buff *skb,
-                                      const struct net_device *in,
-                                      const struct net_device *out,
-                                      int (*okfn)(struct sk_buff *))
+                                      const struct nf_hook_state *state)
 {
         struct net_bridge_port *p;
         struct net_bridge *br;
@@ -640,7 +639,7 @@ static unsigned int br_nf_pre_routing(const struct nf_hook_ops *ops,
         if (unlikely(!pskb_may_pull(skb, len)))
                 return NF_DROP;
 
-        p = br_port_get_rcu(in);
+        p = br_port_get_rcu(state->in);
         if (p == NULL)
                 return NF_DROP;
         br = p->br;
@@ -650,7 +649,7 @@ static unsigned int br_nf_pre_routing(const struct nf_hook_ops *ops,
                         return NF_ACCEPT;
 
                 nf_bridge_pull_encap_header_rcsum(skb);
-                return br_nf_pre_routing_ipv6(ops, skb, in, out, okfn);
+                return br_nf_pre_routing_ipv6(ops, skb, state);
         }
 
         if (!brnf_call_iptables && !br->nf_call_iptables)
@@ -672,7 +671,8 @@ static unsigned int br_nf_pre_routing(const struct nf_hook_ops *ops,
 
         skb->protocol = htons(ETH_P_IP);
 
-        NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, skb, skb->dev, NULL,
+        NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, state->sk, skb,
+                skb->dev, NULL,
                 br_nf_pre_routing_finish);
 
         return NF_STOLEN;
@@ -688,16 +688,14 @@ static unsigned int br_nf_pre_routing(const struct nf_hook_ops *ops,
  * prevent this from happening. */
 static unsigned int br_nf_local_in(const struct nf_hook_ops *ops,
                                    struct sk_buff *skb,
-                                   const struct net_device *in,
-                                   const struct net_device *out,
-                                   int (*okfn)(struct sk_buff *))
+                                   const struct nf_hook_state *state)
 {
         br_drop_fake_rtable(skb);
         return NF_ACCEPT;
 }
 
 /* PF_BRIDGE/FORWARD *************************************************/
-static int br_nf_forward_finish(struct sk_buff *skb)
+static int br_nf_forward_finish(struct sock *sk, struct sk_buff *skb)
 {
         struct nf_bridge_info *nf_bridge = nf_bridge_info_get(skb);
         struct net_device *in;
@@ -721,8 +719,8 @@ static int br_nf_forward_finish(struct sk_buff *skb)
         }
         nf_bridge_push_encap_header(skb);
 
-        NF_HOOK_THRESH(NFPROTO_BRIDGE, NF_BR_FORWARD, skb, in,
-                       skb->dev, br_forward_finish, 1);
+        NF_HOOK_THRESH(NFPROTO_BRIDGE, NF_BR_FORWARD, sk, skb,
+                       in, skb->dev, br_forward_finish, 1);
         return 0;
 }
 
@@ -734,9 +732,7 @@ static int br_nf_forward_finish(struct sk_buff *skb)
  * bridge ports. */
 static unsigned int br_nf_forward_ip(const struct nf_hook_ops *ops,
                                      struct sk_buff *skb,
-                                     const struct net_device *in,
-                                     const struct net_device *out,
-                                     int (*okfn)(struct sk_buff *))
+                                     const struct nf_hook_state *state)
 {
         struct nf_bridge_info *nf_bridge;
         struct net_device *parent;
@@ -754,7 +750,7 @@ static unsigned int br_nf_forward_ip(const struct nf_hook_ops *ops,
         if (!nf_bridge)
                 return NF_DROP;
 
-        parent = bridge_parent(out);
+        parent = bridge_parent(state->out);
         if (!parent)
                 return NF_DROP;
 
@@ -787,23 +783,22 @@ static unsigned int br_nf_forward_ip(const struct nf_hook_ops *ops,
         else
                 skb->protocol = htons(ETH_P_IPV6);
 
-        NF_HOOK(pf, NF_INET_FORWARD, skb, brnf_get_logical_dev(skb, in), parent,
-                br_nf_forward_finish);
+        NF_HOOK(pf, NF_INET_FORWARD, NULL, skb,
+                brnf_get_logical_dev(skb, state->in),
+                parent, br_nf_forward_finish);
 
         return NF_STOLEN;
 }
 
 static unsigned int br_nf_forward_arp(const struct nf_hook_ops *ops,
                                       struct sk_buff *skb,
-                                      const struct net_device *in,
-                                      const struct net_device *out,
-                                      int (*okfn)(struct sk_buff *))
+                                      const struct nf_hook_state *state)
 {
         struct net_bridge_port *p;
         struct net_bridge *br;
         struct net_device **d = (struct net_device **)(skb->cb);
 
-        p = br_port_get_rcu(out);
+        p = br_port_get_rcu(state->out);
         if (p == NULL)
                 return NF_ACCEPT;
         br = p->br;
@@ -822,15 +817,15 @@ static unsigned int br_nf_forward_arp(const struct nf_hook_ops *ops,
                         nf_bridge_push_encap_header(skb);
                 return NF_ACCEPT;
         }
-        *d = (struct net_device *)in;
-        NF_HOOK(NFPROTO_ARP, NF_ARP_FORWARD, skb, (struct net_device *)in,
-                (struct net_device *)out, br_nf_forward_finish);
+        *d = state->in;
+        NF_HOOK(NFPROTO_ARP, NF_ARP_FORWARD, state->sk, skb,
+                state->in, state->out, br_nf_forward_finish);
 
         return NF_STOLEN;
 }
 
 #if IS_ENABLED(CONFIG_NF_DEFRAG_IPV4)
-static int br_nf_push_frag_xmit(struct sk_buff *skb)
+static int br_nf_push_frag_xmit(struct sock *sk, struct sk_buff *skb)
 {
         struct brnf_frag_data *data;
         int err;
@@ -846,17 +841,17 @@ static int br_nf_push_frag_xmit(struct sk_buff *skb)
         skb_copy_to_linear_data_offset(skb, -data->size, data->mac, data->size);
         __skb_push(skb, data->encap_size);
 
-        return br_dev_queue_push_xmit(skb);
+        return br_dev_queue_push_xmit(sk, skb);
 }
 
-static int br_nf_dev_queue_xmit(struct sk_buff *skb)
+static int br_nf_dev_queue_xmit(struct sock *sk, struct sk_buff *skb)
 {
         int ret;
         int frag_max_size;
         unsigned int mtu_reserved;
 
         if (skb_is_gso(skb) || skb->protocol != htons(ETH_P_IP))
-                return br_dev_queue_push_xmit(skb);
+                return br_dev_queue_push_xmit(sk, skb);
 
         mtu_reserved = nf_bridge_mtu_reduction(skb);
         /* This is wrong! We should preserve the original fragment
@@ -880,26 +875,24 @@ static int br_nf_dev_queue_xmit(struct sk_buff *skb)
                 skb_copy_from_linear_data_offset(skb, -data->size, data->mac,
                                                  data->size);
 
-                ret = ip_fragment(skb, br_nf_push_frag_xmit);
+                ret = ip_fragment(sk, skb, br_nf_push_frag_xmit);
         } else {
-                ret = br_dev_queue_push_xmit(skb);
+                ret = br_dev_queue_push_xmit(sk, skb);
         }
 
         return ret;
 }
 #else
-static int br_nf_dev_queue_xmit(struct sk_buff *skb)
+static int br_nf_dev_queue_xmit(struct sock *sk, struct sk_buff *skb)
 {
-        return br_dev_queue_push_xmit(skb);
+        return br_dev_queue_push_xmit(sk, skb);
 }
 #endif
 
 /* PF_BRIDGE/POST_ROUTING ********************************************/
 static unsigned int br_nf_post_routing(const struct nf_hook_ops *ops,
                                        struct sk_buff *skb,
-                                       const struct net_device *in,
-                                       const struct net_device *out,
-                                       int (*okfn)(struct sk_buff *))
+                                       const struct nf_hook_state *state)
 {
         struct nf_bridge_info *nf_bridge = nf_bridge_info_get(skb);
         struct net_device *realoutdev = bridge_parent(skb->dev);
@@ -936,7 +929,8 @@ static unsigned int br_nf_post_routing(const struct nf_hook_ops *ops,
         else
                 skb->protocol = htons(ETH_P_IPV6);
 
-        NF_HOOK(pf, NF_INET_POST_ROUTING, skb, NULL, realoutdev,
+        NF_HOOK(pf, NF_INET_POST_ROUTING, state->sk, skb,
+                NULL, realoutdev,
                 br_nf_dev_queue_xmit);
 
         return NF_STOLEN;
@@ -947,9 +941,7 @@ static unsigned int br_nf_post_routing(const struct nf_hook_ops *ops,
  * for the second time. */
 static unsigned int ip_sabotage_in(const struct nf_hook_ops *ops,
                                    struct sk_buff *skb,
-                                   const struct net_device *in,
-                                   const struct net_device *out,
-                                   int (*okfn)(struct sk_buff *))
+                                   const struct nf_hook_state *state)
 {
         if (skb->nf_bridge &&
             !(skb->nf_bridge->mask & BRNF_NF_BRIDGE_PREROUTING)) {
@@ -981,7 +973,7 @@ static void br_nf_pre_routing_finish_bridge_slow(struct sk_buff *skb)
                                        nf_bridge->neigh_header,
                                        ETH_HLEN - ETH_ALEN);
         skb->dev = nf_bridge->physindev;
-        br_handle_frame_finish(skb);
+        br_handle_frame_finish(NULL, skb);
 }
 
 static int br_nf_dev_xmit(struct sk_buff *skb)
diff --git a/net/bridge/br_netlink.c b/net/bridge/br_netlink.c
index e1115a224a95..0e4ddb81610d 100644
--- a/net/bridge/br_netlink.c
+++ b/net/bridge/br_netlink.c
@@ -305,8 +305,8 @@ static int br_fill_ifinfo(struct sk_buff *skb,
             nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
             (dev->addr_len &&
              nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
-            (dev->ifindex != dev->iflink &&
-             nla_put_u32(skb, IFLA_LINK, dev->iflink)))
+            (dev->ifindex != dev_get_iflink(dev) &&
+             nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
                 goto nla_put_failure;
 
         if (event == RTM_NEWLINK && port) {
diff --git a/net/bridge/br_private.h b/net/bridge/br_private.h
index b46fa0c5b8ec..6ca0251cb478 100644
--- a/net/bridge/br_private.h
+++ b/net/bridge/br_private.h
@@ -410,10 +410,10 @@ int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p,
 
 /* br_forward.c */
 void br_deliver(const struct net_bridge_port *to, struct sk_buff *skb);
-int br_dev_queue_push_xmit(struct sk_buff *skb);
+int br_dev_queue_push_xmit(struct sock *sk, struct sk_buff *skb);
 void br_forward(const struct net_bridge_port *to,
                 struct sk_buff *skb, struct sk_buff *skb0);
-int br_forward_finish(struct sk_buff *skb);
+int br_forward_finish(struct sock *sk, struct sk_buff *skb);
 void br_flood_deliver(struct net_bridge *br, struct sk_buff *skb, bool unicast);
 void br_flood_forward(struct net_bridge *br, struct sk_buff *skb,
                       struct sk_buff *skb2, bool unicast);
@@ -431,7 +431,7 @@ void br_port_flags_change(struct net_bridge_port *port, unsigned long mask);
 void br_manage_promisc(struct net_bridge *br);
 
 /* br_input.c */
-int br_handle_frame_finish(struct sk_buff *skb);
+int br_handle_frame_finish(struct sock *sk, struct sk_buff *skb);
 rx_handler_result_t br_handle_frame(struct sk_buff **pskb);
 
 static inline bool br_rx_handler_check_rcu(const struct net_device *dev)
diff --git a/net/bridge/br_stp_bpdu.c b/net/bridge/br_stp_bpdu.c
index bdb459d21ad8..534fc4cd263e 100644
--- a/net/bridge/br_stp_bpdu.c
+++ b/net/bridge/br_stp_bpdu.c
@@ -54,8 +54,9 @@ static void br_send_bpdu(struct net_bridge_port *p,
 
         skb_reset_mac_header(skb);
 
-        NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
-                dev_queue_xmit);
+        NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, NULL, skb,
+                NULL, skb->dev,
+                dev_queue_xmit_sk);
 }
 
 static inline void br_set_ticks(unsigned char *dest, int j)
diff --git a/net/bridge/netfilter/ebtable_filter.c b/net/bridge/netfilter/ebtable_filter.c
index ce205aabf9c5..8a3f63b2e807 100644
--- a/net/bridge/netfilter/ebtable_filter.c
+++ b/net/bridge/netfilter/ebtable_filter.c
@@ -58,20 +58,18 @@ static const struct ebt_table frame_filter = {
 
 static unsigned int
 ebt_in_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
-            const struct net_device *in, const struct net_device *out,
-            int (*okfn)(struct sk_buff *))
+            const struct nf_hook_state *state)
 {
-        return ebt_do_table(ops->hooknum, skb, in, out,
-                            dev_net(in)->xt.frame_filter);
+        return ebt_do_table(ops->hooknum, skb, state->in, state->out,
+                            dev_net(state->in)->xt.frame_filter);
 }
 
 static unsigned int
 ebt_out_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
-             const struct net_device *in, const struct net_device *out,
-             int (*okfn)(struct sk_buff *))
+             const struct nf_hook_state *state)
 {
-        return ebt_do_table(ops->hooknum, skb, in, out,
-                            dev_net(out)->xt.frame_filter);
+        return ebt_do_table(ops->hooknum, skb, state->in, state->out,
+                            dev_net(state->out)->xt.frame_filter);
 }
 
 static struct nf_hook_ops ebt_ops_filter[] __read_mostly = {
diff --git a/net/bridge/netfilter/ebtable_nat.c b/net/bridge/netfilter/ebtable_nat.c
index a0ac2984fb6c..c5ef5b1ab678 100644
--- a/net/bridge/netfilter/ebtable_nat.c
+++ b/net/bridge/netfilter/ebtable_nat.c
@@ -58,20 +58,18 @@ static struct ebt_table frame_nat = {
 
 static unsigned int
 ebt_nat_in(const struct nf_hook_ops *ops, struct sk_buff *skb,
-           const struct net_device *in, const struct net_device *out,
-           int (*okfn)(struct sk_buff *))
+           const struct nf_hook_state *state)
 {
-        return ebt_do_table(ops->hooknum, skb, in, out,
-                            dev_net(in)->xt.frame_nat);
+        return ebt_do_table(ops->hooknum, skb, state->in, state->out,
+                            dev_net(state->in)->xt.frame_nat);
 }
 
 static unsigned int
 ebt_nat_out(const struct nf_hook_ops *ops, struct sk_buff *skb,
-            const struct net_device *in, const struct net_device *out,
-            int (*okfn)(struct sk_buff *))
+            const struct nf_hook_state *state)
 {
-        return ebt_do_table(ops->hooknum, skb, in, out,
-                            dev_net(out)->xt.frame_nat);
+        return ebt_do_table(ops->hooknum, skb, state->in, state->out,
+                            dev_net(state->out)->xt.frame_nat);
 }
 
 static struct nf_hook_ops ebt_ops_nat[] __read_mostly = {
diff --git a/net/bridge/netfilter/nf_tables_bridge.c b/net/bridge/netfilter/nf_tables_bridge.c
index 19473a9371b8..a343e62442b1 100644
--- a/net/bridge/netfilter/nf_tables_bridge.c
+++ b/net/bridge/netfilter/nf_tables_bridge.c
@@ -67,47 +67,43 @@ EXPORT_SYMBOL_GPL(nft_bridge_ip6hdr_validate);
 static inline void nft_bridge_set_pktinfo_ipv4(struct nft_pktinfo *pkt,
                                                const struct nf_hook_ops *ops,
                                                struct sk_buff *skb,
-                                               const struct net_device *in,
-                                               const struct net_device *out)
+                                               const struct nf_hook_state *state)
 {
         if (nft_bridge_iphdr_validate(skb))
-                nft_set_pktinfo_ipv4(pkt, ops, skb, in, out);
+                nft_set_pktinfo_ipv4(pkt, ops, skb, state);
         else
-                nft_set_pktinfo(pkt, ops, skb, in, out);
+                nft_set_pktinfo(pkt, ops, skb, state);
 }
 
 static inline void nft_bridge_set_pktinfo_ipv6(struct nft_pktinfo *pkt,
-                                              const struct nf_hook_ops *ops,
-                                              struct sk_buff *skb,
-                                              const struct net_device *in,
-                                              const struct net_device *out)
+                                               const struct nf_hook_ops *ops,
+                                               struct sk_buff *skb,
+                                               const struct nf_hook_state *state)
 {
 #if IS_ENABLED(CONFIG_IPV6)
         if (nft_bridge_ip6hdr_validate(skb) &&
-            nft_set_pktinfo_ipv6(pkt, ops, skb, in, out) == 0)
+            nft_set_pktinfo_ipv6(pkt, ops, skb, state) == 0)
                 return;
 #endif
-        nft_set_pktinfo(pkt, ops, skb, in, out);
+        nft_set_pktinfo(pkt, ops, skb, state);
 }
 
 static unsigned int
 nft_do_chain_bridge(const struct nf_hook_ops *ops,
                     struct sk_buff *skb,
-                    const struct net_device *in,
-                    const struct net_device *out,
-                    int (*okfn)(struct sk_buff *))
+                    const struct nf_hook_state *state)
 {
         struct nft_pktinfo pkt;
 
         switch (eth_hdr(skb)->h_proto) {
         case htons(ETH_P_IP):
-                nft_bridge_set_pktinfo_ipv4(&pkt, ops, skb, in, out);
+                nft_bridge_set_pktinfo_ipv4(&pkt, ops, skb, state);
                 break;
         case htons(ETH_P_IPV6):
-                nft_bridge_set_pktinfo_ipv6(&pkt, ops, skb, in, out);
+                nft_bridge_set_pktinfo_ipv6(&pkt, ops, skb, state);
                 break;
         default:
-                nft_set_pktinfo(&pkt, ops, skb, in, out);
+                nft_set_pktinfo(&pkt, ops, skb, state);
                 break;
         }
 
diff --git a/net/can/raw.c b/net/can/raw.c
index 63ffdb0f3a23..31b9748cbb4e 100644
--- a/net/can/raw.c
+++ b/net/can/raw.c
@@ -74,6 +74,12 @@ MODULE_ALIAS("can-proto-1");
  * storing the single filter in dfilter, to avoid using dynamic memory.
  */
 
+struct uniqframe {
+        ktime_t tstamp;
+        const struct sk_buff *skb;
+        unsigned int join_rx_count;
+};
+
 struct raw_sock {
         struct sock sk;
         int bound;
@@ -82,10 +88,12 @@ struct raw_sock {
         int loopback;
         int recv_own_msgs;
         int fd_frames;
+        int join_filters;
         int count;                 /* number of active filters */
         struct can_filter dfilter; /* default/single filter */
         struct can_filter *filter; /* pointer to filter(s) */
         can_err_mask_t err_mask;
+        struct uniqframe __percpu *uniq;
 };
 
 /*
@@ -123,6 +131,26 @@ static void raw_rcv(struct sk_buff *oskb, void *data)
         if (!ro->fd_frames && oskb->len != CAN_MTU)
                 return;
 
+        /* eliminate multiple filter matches for the same skb */
+        if (this_cpu_ptr(ro->uniq)->skb == oskb &&
+            ktime_equal(this_cpu_ptr(ro->uniq)->tstamp, oskb->tstamp)) {
+                if (ro->join_filters) {
+                        this_cpu_inc(ro->uniq->join_rx_count);
+                        /* drop frame until all enabled filters matched */
+                        if (this_cpu_ptr(ro->uniq)->join_rx_count < ro->count)
+                                return;
+                } else {
+                        return;
+                }
+        } else {
+                this_cpu_ptr(ro->uniq)->skb = oskb;
+                this_cpu_ptr(ro->uniq)->tstamp = oskb->tstamp;
+                this_cpu_ptr(ro->uniq)->join_rx_count = 1;
+                /* drop first frame to check all enabled filters? */
+                if (ro->join_filters && ro->count > 1)
+                        return;
+        }
+
         /* clone the given skb to be able to enqueue it into the rcv queue */
         skb = skb_clone(oskb, GFP_ATOMIC);
         if (!skb)
@@ -296,6 +324,12 @@ static int raw_init(struct sock *sk)
         ro->loopback         = 1;
         ro->recv_own_msgs    = 0;
         ro->fd_frames        = 0;
+        ro->join_filters     = 0;
+
+        /* alloc_percpu provides zero'ed memory */
+        ro->uniq = alloc_percpu(struct uniqframe);
+        if (unlikely(!ro->uniq))
+                return -ENOMEM;
 
         /* set notifier */
         ro->notifier.notifier_call = raw_notifier;
@@ -339,6 +373,7 @@ static int raw_release(struct socket *sock)
         ro->ifindex = 0;
         ro->bound   = 0;
         ro->count   = 0;
+        free_percpu(ro->uniq);
 
         sock_orphan(sk);
         sock->sk = NULL;
@@ -583,6 +618,15 @@ static int raw_setsockopt(struct socket *sock, int level, int optname,
 
                 break;
 
+        case CAN_RAW_JOIN_FILTERS:
+                if (optlen != sizeof(ro->join_filters))
+                        return -EINVAL;
+
+                if (copy_from_user(&ro->join_filters, optval, optlen))
+                        return -EFAULT;
+
+                break;
+
         default:
                 return -ENOPROTOOPT;
         }
@@ -647,6 +691,12 @@ static int raw_getsockopt(struct socket *sock, int level, int optname,
                 val = &ro->fd_frames;
                 break;
 
+        case CAN_RAW_JOIN_FILTERS:
+                if (len > sizeof(int))
+                        len = sizeof(int);
+                val = &ro->join_filters;
+                break;
+
         default:
                 return -ENOPROTOOPT;
         }
diff --git a/net/core/dev.c b/net/core/dev.c
index 65492b0354c0..b2775f06c710 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -660,6 +660,27 @@ __setup("netdev=", netdev_boot_setup);
 *******************************************************************************/
 
 /**
+ *      dev_get_iflink  - get 'iflink' value of a interface
+ *      @dev: targeted interface
+ *
+ *      Indicates the ifindex the interface is linked to.
+ *      Physical interfaces have the same 'ifindex' and 'iflink' values.
+ */
+
+int dev_get_iflink(const struct net_device *dev)
+{
+        if (dev->netdev_ops && dev->netdev_ops->ndo_get_iflink)
+                return dev->netdev_ops->ndo_get_iflink(dev);
+
+        /* If dev->rtnl_link_ops is set, it's a virtual interface. */
+        if (dev->rtnl_link_ops)
+                return 0;
+
+        return dev->ifindex;
+}
+EXPORT_SYMBOL(dev_get_iflink);
+
+/**
  *      __dev_get_by_name       - find a device by its name
  *      @net: the applicable net namespace
  *      @name: name to find
@@ -2849,14 +2870,16 @@ static void skb_update_prio(struct sk_buff *skb)
 #define skb_update_prio(skb)
 #endif
 
-static DEFINE_PER_CPU(int, xmit_recursion);
+DEFINE_PER_CPU(int, xmit_recursion);
+EXPORT_SYMBOL(xmit_recursion);
+
 #define RECURSION_LIMIT 10
 
 /**
  *      dev_loopback_xmit - loop back @skb
  *      @skb: buffer to transmit
  */
-int dev_loopback_xmit(struct sk_buff *skb)
+int dev_loopback_xmit(struct sock *sk, struct sk_buff *skb)
 {
         skb_reset_mac_header(skb);
         __skb_pull(skb, skb_network_offset(skb));
@@ -2994,11 +3017,11 @@ out:
         return rc;
 }
 
-int dev_queue_xmit(struct sk_buff *skb)
+int dev_queue_xmit_sk(struct sock *sk, struct sk_buff *skb)
 {
         return __dev_queue_xmit(skb, NULL);
 }
-EXPORT_SYMBOL(dev_queue_xmit);
+EXPORT_SYMBOL(dev_queue_xmit_sk);
 
 int dev_queue_xmit_accel(struct sk_buff *skb, void *accel_priv)
 {
@@ -3830,13 +3853,13 @@ static int netif_receive_skb_internal(struct sk_buff *skb)
  *      NET_RX_SUCCESS: no congestion
  *      NET_RX_DROP: packet was dropped
  */
-int netif_receive_skb(struct sk_buff *skb)
+int netif_receive_skb_sk(struct sock *sk, struct sk_buff *skb)
 {
         trace_netif_receive_skb_entry(skb);
 
         return netif_receive_skb_internal(skb);
 }
-EXPORT_SYMBOL(netif_receive_skb);
+EXPORT_SYMBOL(netif_receive_skb_sk);
 
 /* Network device is going away, flush any packets still pending
  * Called with irqs disabled.
@@ -6314,8 +6337,6 @@ int register_netdevice(struct net_device *dev)
         spin_lock_init(&dev->addr_list_lock);
         netdev_set_addr_lockdep_class(dev);
 
-        dev->iflink = -1;
-
         ret = dev_get_valid_name(net, dev, dev->name);
         if (ret < 0)
                 goto out;
@@ -6345,9 +6366,6 @@ int register_netdevice(struct net_device *dev)
         else if (__dev_get_by_index(net, dev->ifindex))
                 goto err_uninit;
 
-        if (dev->iflink == -1)
-                dev->iflink = dev->ifindex;
-
         /* Transfer changeable features to wanted_features and enable
          * software offloads (GSO and GRO).
          */
@@ -7060,12 +7078,8 @@ int dev_change_net_namespace(struct net_device *dev, struct net *net, const char
         dev_net_set(dev, net);
 
         /* If there is an ifindex conflict assign a new one */
-        if (__dev_get_by_index(net, dev->ifindex)) {
-                int iflink = (dev->iflink == dev->ifindex);
+        if (__dev_get_by_index(net, dev->ifindex))
                 dev->ifindex = dev_new_index(net);
-                if (iflink)
-                        dev->iflink = dev->ifindex;
-        }
 
         /* Send a netdev-add uevent to the new namespace */
         kobject_uevent(&dev->dev.kobj, KOBJ_ADD);
diff --git a/net/core/fib_rules.c b/net/core/fib_rules.c
index 68ea6950cad1..9a12668f7d62 100644
--- a/net/core/fib_rules.c
+++ b/net/core/fib_rules.c
@@ -165,9 +165,9 @@ void fib_rules_unregister(struct fib_rules_ops *ops)
 
         spin_lock(&net->rules_mod_lock);
         list_del_rcu(&ops->list);
-        fib_rules_cleanup_ops(ops);
         spin_unlock(&net->rules_mod_lock);
 
+        fib_rules_cleanup_ops(ops);
         kfree_rcu(ops, rcu);
 }
 EXPORT_SYMBOL_GPL(fib_rules_unregister);
diff --git a/net/core/filter.c b/net/core/filter.c
index 444a07e4f68d..b669e75d2b36 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -1175,7 +1175,9 @@ int sk_attach_bpf(u32 ufd, struct sock *sk)
         return 0;
 }
 
-static u64 bpf_skb_store_bytes(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5)
+#define BPF_RECOMPUTE_CSUM(flags)       ((flags) & 1)
+
+static u64 bpf_skb_store_bytes(u64 r1, u64 r2, u64 r3, u64 r4, u64 flags)
 {
         struct sk_buff *skb = (struct sk_buff *) (long) r1;
         unsigned int offset = (unsigned int) r2;
@@ -1192,7 +1194,7 @@ static u64 bpf_skb_store_bytes(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5)
          *
          * so check for invalid 'offset' and too large 'len'
          */
-        if (offset > 0xffff || len > sizeof(buf))
+        if (unlikely(offset > 0xffff || len > sizeof(buf)))
                 return -EFAULT;
 
         if (skb_cloned(skb) && !skb_clone_writable(skb, offset + len))
@@ -1202,7 +1204,8 @@ static u64 bpf_skb_store_bytes(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5)
         if (unlikely(!ptr))
                 return -EFAULT;
 
-        skb_postpull_rcsum(skb, ptr, len);
+        if (BPF_RECOMPUTE_CSUM(flags))
+                skb_postpull_rcsum(skb, ptr, len);
 
         memcpy(ptr, from, len);
 
@@ -1210,7 +1213,7 @@ static u64 bpf_skb_store_bytes(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5)
                 /* skb_store_bits cannot return -EFAULT here */
                 skb_store_bits(skb, offset, ptr, len);
 
-        if (skb->ip_summed == CHECKSUM_COMPLETE)
+        if (BPF_RECOMPUTE_CSUM(flags) && skb->ip_summed == CHECKSUM_COMPLETE)
                 skb->csum = csum_add(skb->csum, csum_partial(ptr, len, 0));
         return 0;
 }
@@ -1223,6 +1226,99 @@ const struct bpf_func_proto bpf_skb_store_bytes_proto = {
         .arg2_type      = ARG_ANYTHING,
         .arg3_type      = ARG_PTR_TO_STACK,
         .arg4_type      = ARG_CONST_STACK_SIZE,
+        .arg5_type      = ARG_ANYTHING,
+};
+
+#define BPF_HEADER_FIELD_SIZE(flags)    ((flags) & 0x0f)
+#define BPF_IS_PSEUDO_HEADER(flags)     ((flags) & 0x10)
+
+static u64 bpf_l3_csum_replace(u64 r1, u64 offset, u64 from, u64 to, u64 flags)
+{
+        struct sk_buff *skb = (struct sk_buff *) (long) r1;
+        __sum16 sum, *ptr;
+
+        if (unlikely(offset > 0xffff))
+                return -EFAULT;
+
+        if (skb_cloned(skb) && !skb_clone_writable(skb, offset + sizeof(sum)))
+                return -EFAULT;
+
+        ptr = skb_header_pointer(skb, offset, sizeof(sum), &sum);
+        if (unlikely(!ptr))
+                return -EFAULT;
+
+        switch (BPF_HEADER_FIELD_SIZE(flags)) {
+        case 2:
+                csum_replace2(ptr, from, to);
+                break;
+        case 4:
+                csum_replace4(ptr, from, to);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (ptr == &sum)
+                /* skb_store_bits guaranteed to not return -EFAULT here */
+                skb_store_bits(skb, offset, ptr, sizeof(sum));
+
+        return 0;
+}
+
+const struct bpf_func_proto bpf_l3_csum_replace_proto = {
+        .func           = bpf_l3_csum_replace,
+        .gpl_only       = false,
+        .ret_type       = RET_INTEGER,
+        .arg1_type      = ARG_PTR_TO_CTX,
+        .arg2_type      = ARG_ANYTHING,
+        .arg3_type      = ARG_ANYTHING,
+        .arg4_type      = ARG_ANYTHING,
+        .arg5_type      = ARG_ANYTHING,
+};
+
+static u64 bpf_l4_csum_replace(u64 r1, u64 offset, u64 from, u64 to, u64 flags)
+{
+        struct sk_buff *skb = (struct sk_buff *) (long) r1;
+        u32 is_pseudo = BPF_IS_PSEUDO_HEADER(flags);
+        __sum16 sum, *ptr;
+
+        if (unlikely(offset > 0xffff))
+                return -EFAULT;
+
+        if (skb_cloned(skb) && !skb_clone_writable(skb, offset + sizeof(sum)))
+                return -EFAULT;
+
+        ptr = skb_header_pointer(skb, offset, sizeof(sum), &sum);
+        if (unlikely(!ptr))
+                return -EFAULT;
+
+        switch (BPF_HEADER_FIELD_SIZE(flags)) {
+        case 2:
+                inet_proto_csum_replace2(ptr, skb, from, to, is_pseudo);
+                break;
+        case 4:
+                inet_proto_csum_replace4(ptr, skb, from, to, is_pseudo);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (ptr == &sum)
+                /* skb_store_bits guaranteed to not return -EFAULT here */
+                skb_store_bits(skb, offset, ptr, sizeof(sum));
+
+        return 0;
+}
+
+const struct bpf_func_proto bpf_l4_csum_replace_proto = {
+        .func           = bpf_l4_csum_replace,
+        .gpl_only       = false,
+        .ret_type       = RET_INTEGER,
+        .arg1_type      = ARG_PTR_TO_CTX,
+        .arg2_type      = ARG_ANYTHING,
+        .arg3_type      = ARG_ANYTHING,
+        .arg4_type      = ARG_ANYTHING,
+        .arg5_type      = ARG_ANYTHING,
 };
 
 static const struct bpf_func_proto *
@@ -1250,6 +1346,10 @@ tc_cls_act_func_proto(enum bpf_func_id func_id)
         switch (func_id) {
         case BPF_FUNC_skb_store_bytes:
                 return &bpf_skb_store_bytes_proto;
+        case BPF_FUNC_l3_csum_replace:
+                return &bpf_l3_csum_replace_proto;
+        case BPF_FUNC_l4_csum_replace:
+                return &bpf_l4_csum_replace_proto;
         default:
                 return sk_filter_func_proto(func_id);
         }
@@ -1304,6 +1404,13 @@ static u32 sk_filter_convert_ctx_access(int dst_reg, int src_reg, int ctx_off,
                                       offsetof(struct sk_buff, vlan_proto));
                 break;
 
+        case offsetof(struct __sk_buff, priority):
+                BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, priority) != 4);
+
+                *insn++ = BPF_LDX_MEM(BPF_W, dst_reg, src_reg,
+                                      offsetof(struct sk_buff, priority));
+                break;
+
         case offsetof(struct __sk_buff, mark):
                 return convert_skb_access(SKF_AD_MARK, dst_reg, src_reg, insn);
 
diff --git a/net/core/link_watch.c b/net/core/link_watch.c
index 49a9e3e06c08..982861607f88 100644
--- a/net/core/link_watch.c
+++ b/net/core/link_watch.c
@@ -40,7 +40,7 @@ static DEFINE_SPINLOCK(lweventlist_lock);
 static unsigned char default_operstate(const struct net_device *dev)
 {
         if (!netif_carrier_ok(dev))
-                return (dev->ifindex != dev->iflink ?
+                return (dev->ifindex != dev_get_iflink(dev) ?
                         IF_OPER_LOWERLAYERDOWN : IF_OPER_DOWN);
 
         if (netif_dormant(dev))
@@ -89,7 +89,7 @@ static bool linkwatch_urgent_event(struct net_device *dev)
         if (!netif_running(dev))
                 return false;
 
-        if (dev->ifindex != dev->iflink)
+        if (dev->ifindex != dev_get_iflink(dev))
                 return true;
 
         if (dev->priv_flags & IFF_TEAM_PORT)
diff --git a/net/core/net-sysfs.c b/net/core/net-sysfs.c
index cc5cf689809c..4238d6da5c60 100644
--- a/net/core/net-sysfs.c
+++ b/net/core/net-sysfs.c
@@ -109,11 +109,19 @@ NETDEVICE_SHOW_RO(dev_id, fmt_hex);
 NETDEVICE_SHOW_RO(dev_port, fmt_dec);
 NETDEVICE_SHOW_RO(addr_assign_type, fmt_dec);
 NETDEVICE_SHOW_RO(addr_len, fmt_dec);
-NETDEVICE_SHOW_RO(iflink, fmt_dec);
 NETDEVICE_SHOW_RO(ifindex, fmt_dec);
 NETDEVICE_SHOW_RO(type, fmt_dec);
 NETDEVICE_SHOW_RO(link_mode, fmt_dec);
 
+static ssize_t iflink_show(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct net_device *ndev = to_net_dev(dev);
+
+        return sprintf(buf, fmt_dec, dev_get_iflink(ndev));
+}
+static DEVICE_ATTR_RO(iflink);
+
 static ssize_t format_name_assign_type(const struct net_device *dev, char *buf)
 {
         return sprintf(buf, fmt_dec, dev->name_assign_type);
diff --git a/net/core/net_namespace.c b/net/core/net_namespace.c
index e5e96b0f6717..a3abb719221f 100644
--- a/net/core/net_namespace.c
+++ b/net/core/net_namespace.c
@@ -148,9 +148,11 @@ static void ops_free_list(const struct pernet_operations *ops,
         }
 }
 
+static void rtnl_net_notifyid(struct net *net, struct net *peer, int cmd,
+                              int id);
 static int alloc_netid(struct net *net, struct net *peer, int reqid)
 {
-        int min = 0, max = 0;
+        int min = 0, max = 0, id;
 
         ASSERT_RTNL();
 
@@ -159,7 +161,11 @@ static int alloc_netid(struct net *net, struct net *peer, int reqid)
                 max = reqid + 1;
         }
 
-        return idr_alloc(&net->netns_ids, peer, min, max, GFP_KERNEL);
+        id = idr_alloc(&net->netns_ids, peer, min, max, GFP_KERNEL);
+        if (id >= 0)
+                rtnl_net_notifyid(net, peer, RTM_NEWNSID, id);
+
+        return id;
 }
 
 /* This function is used by idr_for_each(). If net is equal to peer, the
@@ -198,8 +204,10 @@ static int __peernet2id(struct net *net, struct net *peer, bool alloc)
  */
 int peernet2id(struct net *net, struct net *peer)
 {
-        int id = __peernet2id(net, peer, true);
+        bool alloc = atomic_read(&peer->count) == 0 ? false : true;
+        int id;
 
+        id = __peernet2id(net, peer, alloc);
         return id >= 0 ? id : NETNSA_NSID_NOT_ASSIGNED;
 }
 EXPORT_SYMBOL(peernet2id);
@@ -357,8 +365,10 @@ static void cleanup_net(struct work_struct *work)
                 for_each_net(tmp) {
                         int id = __peernet2id(tmp, net, false);
 
-                        if (id >= 0)
+                        if (id >= 0) {
+                                rtnl_net_notifyid(tmp, net, RTM_DELNSID, id);
                                 idr_remove(&tmp->netns_ids, id);
+                        }
                 }
                 idr_destroy(&net->netns_ids);
 
@@ -529,7 +539,8 @@ static int rtnl_net_get_size(void)
 }
 
 static int rtnl_net_fill(struct sk_buff *skb, u32 portid, u32 seq, int flags,
-                         int cmd, struct net *net, struct net *peer)
+                         int cmd, struct net *net, struct net *peer,
+                         int nsid)
 {
         struct nlmsghdr *nlh;
         struct rtgenmsg *rth;
@@ -544,9 +555,13 @@ static int rtnl_net_fill(struct sk_buff *skb, u32 portid, u32 seq, int flags,
         rth = nlmsg_data(nlh);
         rth->rtgen_family = AF_UNSPEC;
 
-        id = __peernet2id(net, peer, false);
-        if  (id < 0)
-                id = NETNSA_NSID_NOT_ASSIGNED;
+        if (nsid >= 0) {
+                id = nsid;
+        } else {
+                id = __peernet2id(net, peer, false);
+                if  (id < 0)
+                        id = NETNSA_NSID_NOT_ASSIGNED;
+        }
         if (nla_put_s32(skb, NETNSA_NSID, id))
                 goto nla_put_failure;
 
@@ -563,8 +578,8 @@ static int rtnl_net_getid(struct sk_buff *skb, struct nlmsghdr *nlh)
         struct net *net = sock_net(skb->sk);
         struct nlattr *tb[NETNSA_MAX + 1];
         struct sk_buff *msg;
-        int err = -ENOBUFS;
         struct net *peer;
+        int err;
 
         err = nlmsg_parse(nlh, sizeof(struct rtgenmsg), tb, NETNSA_MAX,
                           rtnl_net_policy);
@@ -587,7 +602,7 @@ static int rtnl_net_getid(struct sk_buff *skb, struct nlmsghdr *nlh)
         }
 
         err = rtnl_net_fill(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0,
-                            RTM_GETNSID, net, peer);
+                            RTM_GETNSID, net, peer, -1);
         if (err < 0)
                 goto err_out;
 
@@ -601,6 +616,75 @@ out:
         return err;
 }
 
+struct rtnl_net_dump_cb {
+        struct net *net;
+        struct sk_buff *skb;
+        struct netlink_callback *cb;
+        int idx;
+        int s_idx;
+};
+
+static int rtnl_net_dumpid_one(int id, void *peer, void *data)
+{
+        struct rtnl_net_dump_cb *net_cb = (struct rtnl_net_dump_cb *)data;
+        int ret;
+
+        if (net_cb->idx < net_cb->s_idx)
+                goto cont;
+
+        ret = rtnl_net_fill(net_cb->skb, NETLINK_CB(net_cb->cb->skb).portid,
+                            net_cb->cb->nlh->nlmsg_seq, NLM_F_MULTI,
+                            RTM_NEWNSID, net_cb->net, peer, id);
+        if (ret < 0)
+                return ret;
+
+cont:
+        net_cb->idx++;
+        return 0;
+}
+
+static int rtnl_net_dumpid(struct sk_buff *skb, struct netlink_callback *cb)
+{
+        struct net *net = sock_net(skb->sk);
+        struct rtnl_net_dump_cb net_cb = {
+                .net = net,
+                .skb = skb,
+                .cb = cb,
+                .idx = 0,
+                .s_idx = cb->args[0],
+        };
+
+        ASSERT_RTNL();
+
+        idr_for_each(&net->netns_ids, rtnl_net_dumpid_one, &net_cb);
+
+        cb->args[0] = net_cb.idx;
+        return skb->len;
+}
+
+static void rtnl_net_notifyid(struct net *net, struct net *peer, int cmd,
+                              int id)
+{
+        struct sk_buff *msg;
+        int err = -ENOMEM;
+
+        msg = nlmsg_new(rtnl_net_get_size(), GFP_KERNEL);
+        if (!msg)
+                goto out;
+
+        err = rtnl_net_fill(msg, 0, 0, 0, cmd, net, peer, id);
+        if (err < 0)
+                goto err_out;
+
+        rtnl_notify(msg, net, 0, RTNLGRP_NSID, NULL, 0);
+        return;
+
+err_out:
+        nlmsg_free(msg);
+out:
+        rtnl_set_sk_err(net, RTNLGRP_NSID, err);
+}
+
 static int __init net_ns_init(void)
 {
         struct net_generic *ng;
@@ -635,7 +719,8 @@ static int __init net_ns_init(void)
         register_pernet_subsys(&net_ns_ops);
 
         rtnl_register(PF_UNSPEC, RTM_NEWNSID, rtnl_net_newid, NULL, NULL);
-        rtnl_register(PF_UNSPEC, RTM_GETNSID, rtnl_net_getid, NULL, NULL);
+        rtnl_register(PF_UNSPEC, RTM_GETNSID, rtnl_net_getid, rtnl_net_dumpid,
+                      NULL);
 
         return 0;
 }
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index b96ac2109c82..5e02260b087f 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -1055,8 +1055,8 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
 #ifdef CONFIG_RPS
             nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||
 #endif
-            (dev->ifindex != dev->iflink &&
-             nla_put_u32(skb, IFLA_LINK, dev->iflink)) ||
+            (dev->ifindex != dev_get_iflink(dev) &&
+             nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))) ||
             (upper_dev &&
              nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex)) ||
             nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||
@@ -1991,10 +1991,10 @@ static int rtnl_group_changelink(const struct sk_buff *skb,
                 struct ifinfomsg *ifm,
                 struct nlattr **tb)
 {
-        struct net_device *dev;
+        struct net_device *dev, *aux;
         int err;
 
-        for_each_netdev(net, dev) {
+        for_each_netdev_safe(net, dev, aux) {
                 if (dev->group == group) {
                         err = do_setlink(skb, dev, ifm, tb, NULL, 0);
                         if (err < 0)
@@ -2863,8 +2863,8 @@ int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
              nla_put_u32(skb, IFLA_MASTER, br_dev->ifindex)) ||
             (dev->addr_len &&
              nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
-            (dev->ifindex != dev->iflink &&
-             nla_put_u32(skb, IFLA_LINK, dev->iflink)))
+            (dev->ifindex != dev_get_iflink(dev) &&
+             nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
                 goto nla_put_failure;
 
         br_afspec = nla_nest_start(skb, IFLA_AF_SPEC);
diff --git a/net/core/sock.c b/net/core/sock.c
index 119ae464b44a..654e38a99759 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -653,6 +653,25 @@ static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
                 sock_reset_flag(sk, bit);
 }
 
+bool sk_mc_loop(struct sock *sk)
+{
+        if (dev_recursion_level())
+                return false;
+        if (!sk)
+                return true;
+        switch (sk->sk_family) {
+        case AF_INET:
+                return inet_sk(sk)->mc_loop;
+#if IS_ENABLED(CONFIG_IPV6)
+        case AF_INET6:
+                return inet6_sk(sk)->mc_loop;
+#endif
+        }
+        WARN_ON(1);
+        return true;
+}
+EXPORT_SYMBOL(sk_mc_loop);
+
 /*
  *      This is meant for all protocols to use and covers goings on
  *      at the socket level. Everything here is generic.
diff --git a/net/decnet/dn_neigh.c b/net/decnet/dn_neigh.c
index be1f08cdad29..4507b188fc51 100644
--- a/net/decnet/dn_neigh.c
+++ b/net/decnet/dn_neigh.c
@@ -194,7 +194,7 @@ static int dn_neigh_output(struct neighbour *neigh, struct sk_buff *skb)
         return err;
 }
 
-static int dn_neigh_output_packet(struct sk_buff *skb)
+static int dn_neigh_output_packet(struct sock *sk, struct sk_buff *skb)
 {
         struct dst_entry *dst = skb_dst(skb);
         struct dn_route *rt = (struct dn_route *)dst;
@@ -206,7 +206,8 @@ static int dn_neigh_output_packet(struct sk_buff *skb)
 /*
  * For talking to broadcast devices: Ethernet & PPP
  */
-static int dn_long_output(struct neighbour *neigh, struct sk_buff *skb)
+static int dn_long_output(struct neighbour *neigh, struct sock *sk,
+                          struct sk_buff *skb)
 {
         struct net_device *dev = neigh->dev;
         int headroom = dev->hard_header_len + sizeof(struct dn_long_packet) + 3;
@@ -245,14 +246,15 @@ static int dn_long_output(struct neighbour *neigh, struct sk_buff *skb)
 
         skb_reset_network_header(skb);
 
-        return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, skb, NULL,
-                       neigh->dev, dn_neigh_output_packet);
+        return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, sk, skb,
+                       NULL, neigh->dev, dn_neigh_output_packet);
 }
 
 /*
  * For talking to pointopoint and multidrop devices: DDCMP and X.25
  */
-static int dn_short_output(struct neighbour *neigh, struct sk_buff *skb)
+static int dn_short_output(struct neighbour *neigh, struct sock *sk,
+                           struct sk_buff *skb)
 {
         struct net_device *dev = neigh->dev;
         int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2;
@@ -284,8 +286,8 @@ static int dn_short_output(struct neighbour *neigh, struct sk_buff *skb)
 
         skb_reset_network_header(skb);
 
-        return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, skb, NULL,
-                       neigh->dev, dn_neigh_output_packet);
+        return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, sk, skb,
+                       NULL, neigh->dev, dn_neigh_output_packet);
 }
 
 /*
@@ -293,7 +295,8 @@ static int dn_short_output(struct neighbour *neigh, struct sk_buff *skb)
  * Phase 3 output is the same as short output, execpt that
  * it clears the area bits before transmission.
  */
-static int dn_phase3_output(struct neighbour *neigh, struct sk_buff *skb)
+static int dn_phase3_output(struct neighbour *neigh, struct sock *sk,
+                            struct sk_buff *skb)
 {
         struct net_device *dev = neigh->dev;
         int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2;
@@ -324,11 +327,11 @@ static int dn_phase3_output(struct neighbour *neigh, struct sk_buff *skb)
 
         skb_reset_network_header(skb);
 
-        return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, skb, NULL,
-                       neigh->dev, dn_neigh_output_packet);
+        return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, sk, skb,
+                       NULL, neigh->dev, dn_neigh_output_packet);
 }
 
-int dn_to_neigh_output(struct sk_buff *skb)
+int dn_to_neigh_output(struct sock *sk, struct sk_buff *skb)
 {
         struct dst_entry *dst = skb_dst(skb);
         struct dn_route *rt = (struct dn_route *) dst;
@@ -347,11 +350,11 @@ int dn_to_neigh_output(struct sk_buff *skb)
         rcu_read_unlock();
 
         if (dn->flags & DN_NDFLAG_P3)
-                return dn_phase3_output(neigh, skb);
+                return dn_phase3_output(neigh, sk, skb);
         if (use_long)
-                return dn_long_output(neigh, skb);
+                return dn_long_output(neigh, sk, skb);
         else
-                return dn_short_output(neigh, skb);
+                return dn_short_output(neigh, sk, skb);
 }
 
 /*
@@ -372,7 +375,7 @@ void dn_neigh_pointopoint_hello(struct sk_buff *skb)
 /*
  * Ethernet router hello message received
  */
-int dn_neigh_router_hello(struct sk_buff *skb)
+int dn_neigh_router_hello(struct sock *sk, struct sk_buff *skb)
 {
         struct rtnode_hello_message *msg = (struct rtnode_hello_message *)skb->data;
 
@@ -434,7 +437,7 @@ int dn_neigh_router_hello(struct sk_buff *skb)
 /*
  * Endnode hello message received
  */
-int dn_neigh_endnode_hello(struct sk_buff *skb)
+int dn_neigh_endnode_hello(struct sock *sk, struct sk_buff *skb)
 {
         struct endnode_hello_message *msg = (struct endnode_hello_message *)skb->data;
         struct neighbour *neigh;
diff --git a/net/decnet/dn_nsp_in.c b/net/decnet/dn_nsp_in.c
index fe5f01485d33..a321eac9fd0c 100644
--- a/net/decnet/dn_nsp_in.c
+++ b/net/decnet/dn_nsp_in.c
@@ -714,7 +714,7 @@ out:
         return ret;
 }
 
-static int dn_nsp_rx_packet(struct sk_buff *skb)
+static int dn_nsp_rx_packet(struct sock *sk2, struct sk_buff *skb)
 {
         struct dn_skb_cb *cb = DN_SKB_CB(skb);
         struct sock *sk = NULL;
@@ -814,7 +814,8 @@ free_out:
 
 int dn_nsp_rx(struct sk_buff *skb)
 {
-        return NF_HOOK(NFPROTO_DECNET, NF_DN_LOCAL_IN, skb, skb->dev, NULL,
+        return NF_HOOK(NFPROTO_DECNET, NF_DN_LOCAL_IN, NULL, skb,
+                       skb->dev, NULL,
                        dn_nsp_rx_packet);
 }
 
diff --git a/net/decnet/dn_route.c b/net/decnet/dn_route.c
index 9ab0c4ba297f..03227ffd19ce 100644
--- a/net/decnet/dn_route.c
+++ b/net/decnet/dn_route.c
@@ -512,7 +512,7 @@ static int dn_return_long(struct sk_buff *skb)
  *
  * Returns: result of input function if route is found, error code otherwise
  */
-static int dn_route_rx_packet(struct sk_buff *skb)
+static int dn_route_rx_packet(struct sock *sk, struct sk_buff *skb)
 {
         struct dn_skb_cb *cb;
         int err;
@@ -573,7 +573,8 @@ static int dn_route_rx_long(struct sk_buff *skb)
         ptr++;
         cb->hops = *ptr++; /* Visit Count */
 
-        return NF_HOOK(NFPROTO_DECNET, NF_DN_PRE_ROUTING, skb, skb->dev, NULL,
+        return NF_HOOK(NFPROTO_DECNET, NF_DN_PRE_ROUTING, NULL, skb,
+                       skb->dev, NULL,
                        dn_route_rx_packet);
 
 drop_it:
@@ -600,7 +601,8 @@ static int dn_route_rx_short(struct sk_buff *skb)
         ptr += 2;
         cb->hops = *ptr & 0x3f;
 
-        return NF_HOOK(NFPROTO_DECNET, NF_DN_PRE_ROUTING, skb, skb->dev, NULL,
+        return NF_HOOK(NFPROTO_DECNET, NF_DN_PRE_ROUTING, NULL, skb,
+                       skb->dev, NULL,
                        dn_route_rx_packet);
 
 drop_it:
@@ -608,7 +610,7 @@ drop_it:
         return NET_RX_DROP;
 }
 
-static int dn_route_discard(struct sk_buff *skb)
+static int dn_route_discard(struct sock *sk, struct sk_buff *skb)
 {
         /*
          * I know we drop the packet here, but thats considered success in
@@ -618,7 +620,7 @@ static int dn_route_discard(struct sk_buff *skb)
         return NET_RX_SUCCESS;
 }
 
-static int dn_route_ptp_hello(struct sk_buff *skb)
+static int dn_route_ptp_hello(struct sock *sk, struct sk_buff *skb)
 {
         dn_dev_hello(skb);
         dn_neigh_pointopoint_hello(skb);
@@ -704,22 +706,22 @@ int dn_route_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type
                 switch (flags & DN_RT_CNTL_MSK) {
                 case DN_RT_PKT_HELO:
                         return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
-                                       skb, skb->dev, NULL,
+                                       NULL, skb, skb->dev, NULL,
                                        dn_route_ptp_hello);
 
                 case DN_RT_PKT_L1RT:
                 case DN_RT_PKT_L2RT:
                         return NF_HOOK(NFPROTO_DECNET, NF_DN_ROUTE,
-                                       skb, skb->dev, NULL,
+                                       NULL, skb, skb->dev, NULL,
                                        dn_route_discard);
                 case DN_RT_PKT_ERTH:
                         return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
-                                       skb, skb->dev, NULL,
+                                       NULL, skb, skb->dev, NULL,
                                        dn_neigh_router_hello);
 
                 case DN_RT_PKT_EEDH:
                         return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
-                                       skb, skb->dev, NULL,
+                                       NULL, skb, skb->dev, NULL,
                                        dn_neigh_endnode_hello);
                 }
         } else {
@@ -768,7 +770,8 @@ static int dn_output(struct sock *sk, struct sk_buff *skb)
         cb->rt_flags |= DN_RT_F_IE;
         cb->hops = 0;
 
-        return NF_HOOK(NFPROTO_DECNET, NF_DN_LOCAL_OUT, skb, NULL, dev,
+        return NF_HOOK(NFPROTO_DECNET, NF_DN_LOCAL_OUT, sk, skb,
+                       NULL, dev,
                        dn_to_neigh_output);
 
 error:
@@ -816,7 +819,8 @@ static int dn_forward(struct sk_buff *skb)
         if (rt->rt_flags & RTCF_DOREDIRECT)
                 cb->rt_flags |= DN_RT_F_IE;
 
-        return NF_HOOK(NFPROTO_DECNET, NF_DN_FORWARD, skb, dev, skb->dev,
+        return NF_HOOK(NFPROTO_DECNET, NF_DN_FORWARD, NULL, skb,
+                       dev, skb->dev,
                        dn_to_neigh_output);
 
 drop:
diff --git a/net/decnet/dn_rules.c b/net/decnet/dn_rules.c
index faf7cc3483fe..9d66a0f72f90 100644
--- a/net/decnet/dn_rules.c
+++ b/net/decnet/dn_rules.c
@@ -248,7 +248,9 @@ void __init dn_fib_rules_init(void)
 
 void __exit dn_fib_rules_cleanup(void)
 {
+        rtnl_lock();
         fib_rules_unregister(dn_fib_rules_ops);
+        rtnl_unlock();
         rcu_barrier();
 }
 
diff --git a/net/decnet/netfilter/dn_rtmsg.c b/net/decnet/netfilter/dn_rtmsg.c
index e4d9560a910b..af34fc9bdf69 100644
--- a/net/decnet/netfilter/dn_rtmsg.c
+++ b/net/decnet/netfilter/dn_rtmsg.c
@@ -89,9 +89,7 @@ static void dnrmg_send_peer(struct sk_buff *skb)
 
 static unsigned int dnrmg_hook(const struct nf_hook_ops *ops,
                         struct sk_buff *skb,
-                        const struct net_device *in,
-                        const struct net_device *out,
-                        int (*okfn)(struct sk_buff *))
+                        const struct nf_hook_state *state)
 {
         dnrmg_send_peer(skb);
         return NF_ACCEPT;
diff --git a/net/dsa/dsa.c b/net/dsa/dsa.c
index 899772108ee3..5eaadabe23a1 100644
--- a/net/dsa/dsa.c
+++ b/net/dsa/dsa.c
@@ -513,12 +513,10 @@ static struct net_device *dev_to_net_device(struct device *dev)
 #ifdef CONFIG_OF
 static int dsa_of_setup_routing_table(struct dsa_platform_data *pd,
                                         struct dsa_chip_data *cd,
-                                        int chip_index,
+                                        int chip_index, int port_index,
                                         struct device_node *link)
 {
-        int ret;
         const __be32 *reg;
-        int link_port_addr;
         int link_sw_addr;
         struct device_node *parent_sw;
         int len;
@@ -531,6 +529,10 @@ static int dsa_of_setup_routing_table(struct dsa_platform_data *pd,
         if (!reg || (len != sizeof(*reg) * 2))
                 return -EINVAL;
 
+        /*
+         * Get the destination switch number from the second field of its 'reg'
+         * property, i.e. for "reg = <0x19 1>" sw_addr is '1'.
+         */
         link_sw_addr = be32_to_cpup(reg + 1);
 
         if (link_sw_addr >= pd->nr_chips)
@@ -547,20 +549,9 @@ static int dsa_of_setup_routing_table(struct dsa_platform_data *pd,
                 memset(cd->rtable, -1, pd->nr_chips * sizeof(s8));
         }
 
-        reg = of_get_property(link, "reg", NULL);
-        if (!reg) {
-                ret = -EINVAL;
-                goto out;
-        }
-
-        link_port_addr = be32_to_cpup(reg);
-
-        cd->rtable[link_sw_addr] = link_port_addr;
+        cd->rtable[link_sw_addr] = port_index;
 
         return 0;
-out:
-        kfree(cd->rtable);
-        return ret;
 }
 
 static void dsa_of_free_platform_data(struct dsa_platform_data *pd)
@@ -670,7 +661,7 @@ static int dsa_of_probe(struct device *dev)
                         if (!strcmp(port_name, "dsa") && link &&
                                         pd->nr_chips > 1) {
                                 ret = dsa_of_setup_routing_table(pd, cd,
-                                                chip_index, link);
+                                                chip_index, port_index, link);
                                 if (ret)
                                         goto out_free_chip;
                         }
diff --git a/net/dsa/slave.c b/net/dsa/slave.c
index 3597724ec3d8..827cda560a55 100644
--- a/net/dsa/slave.c
+++ b/net/dsa/slave.c
@@ -55,13 +55,11 @@ void dsa_slave_mii_bus_init(struct dsa_switch *ds)
 
 
 /* slave device handling ****************************************************/
-static int dsa_slave_init(struct net_device *dev)
+static int dsa_slave_get_iflink(const struct net_device *dev)
 {
         struct dsa_slave_priv *p = netdev_priv(dev);
 
-        dev->iflink = p->parent->dst->master_netdev->ifindex;
-
-        return 0;
+        return p->parent->dst->master_netdev->ifindex;
 }
 
 static inline bool dsa_port_is_bridged(struct dsa_slave_priv *p)
@@ -664,7 +662,6 @@ static const struct ethtool_ops dsa_slave_ethtool_ops = {
 };
 
 static const struct net_device_ops dsa_slave_netdev_ops = {
-        .ndo_init               = dsa_slave_init,
         .ndo_open               = dsa_slave_open,
         .ndo_stop               = dsa_slave_close,
         .ndo_start_xmit         = dsa_slave_xmit,
@@ -675,6 +672,7 @@ static const struct net_device_ops dsa_slave_netdev_ops = {
         .ndo_fdb_del            = dsa_slave_fdb_del,
         .ndo_fdb_dump           = dsa_slave_fdb_dump,
         .ndo_do_ioctl           = dsa_slave_ioctl,
+        .ndo_get_iflink         = dsa_slave_get_iflink,
 };
 
 static const struct swdev_ops dsa_slave_swdev_ops = {
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index 64a9c0fdc4aa..8b47a4d79d04 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -217,7 +217,7 @@ int inet_listen(struct socket *sock, int backlog)
                  * shutdown() (rather than close()).
                  */
                 if ((sysctl_tcp_fastopen & TFO_SERVER_ENABLE) != 0 &&
-                    inet_csk(sk)->icsk_accept_queue.fastopenq == NULL) {
+                    !inet_csk(sk)->icsk_accept_queue.fastopenq) {
                         if ((sysctl_tcp_fastopen & TFO_SERVER_WO_SOCKOPT1) != 0)
                                 err = fastopen_init_queue(sk, backlog);
                         else if ((sysctl_tcp_fastopen &
@@ -314,11 +314,11 @@ lookup_protocol:
         answer_flags = answer->flags;
         rcu_read_unlock();
 
-        WARN_ON(answer_prot->slab == NULL);
+        WARN_ON(!answer_prot->slab);
 
         err = -ENOBUFS;
         sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot);
-        if (sk == NULL)
+        if (!sk)
                 goto out;
 
         err = 0;
@@ -1269,7 +1269,7 @@ static struct sk_buff *inet_gso_segment(struct sk_buff *skb,
                 if (udpfrag) {
                         iph->id = htons(id);
                         iph->frag_off = htons(offset >> 3);
-                        if (skb->next != NULL)
+                        if (skb->next)
                                 iph->frag_off |= htons(IP_MF);
                         offset += skb->len - nhoff - ihl;
                 } else {
diff --git a/net/ipv4/arp.c b/net/ipv4/arp.c
index 5f5c674e130a..933a92820d26 100644
--- a/net/ipv4/arp.c
+++ b/net/ipv4/arp.c
@@ -228,7 +228,7 @@ static int arp_constructor(struct neighbour *neigh)
 
         rcu_read_lock();
         in_dev = __in_dev_get_rcu(dev);
-        if (in_dev == NULL) {
+        if (!in_dev) {
                 rcu_read_unlock();
                 return -EINVAL;
         }
@@ -475,7 +475,7 @@ static inline int arp_fwd_pvlan(struct in_device *in_dev,
  */
 
 /*
- *      Create an arp packet. If (dest_hw == NULL), we create a broadcast
+ *      Create an arp packet. If dest_hw is not set, we create a broadcast
  *      message.
  */
 struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
@@ -495,7 +495,7 @@ struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
          */
 
         skb = alloc_skb(arp_hdr_len(dev) + hlen + tlen, GFP_ATOMIC);
-        if (skb == NULL)
+        if (!skb)
                 return NULL;
 
         skb_reserve(skb, hlen);
@@ -503,9 +503,9 @@ struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
         arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
         skb->dev = dev;
         skb->protocol = htons(ETH_P_ARP);
-        if (src_hw == NULL)
+        if (!src_hw)
                 src_hw = dev->dev_addr;
-        if (dest_hw == NULL)
+        if (!dest_hw)
                 dest_hw = dev->broadcast;
 
         /*
@@ -569,7 +569,7 @@ struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
                 break;
 #endif
         default:
-                if (target_hw != NULL)
+                if (target_hw)
                         memcpy(arp_ptr, target_hw, dev->addr_len);
                 else
                         memset(arp_ptr, 0, dev->addr_len);
@@ -591,7 +591,8 @@ EXPORT_SYMBOL(arp_create);
 void arp_xmit(struct sk_buff *skb)
 {
         /* Send it off, maybe filter it using firewalling first.  */
-        NF_HOOK(NFPROTO_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
+        NF_HOOK(NFPROTO_ARP, NF_ARP_OUT, NULL, skb,
+                NULL, skb->dev, dev_queue_xmit_sk);
 }
 EXPORT_SYMBOL(arp_xmit);
 
@@ -614,7 +615,7 @@ void arp_send(int type, int ptype, __be32 dest_ip,
 
         skb = arp_create(type, ptype, dest_ip, dev, src_ip,
                          dest_hw, src_hw, target_hw);
-        if (skb == NULL)
+        if (!skb)
                 return;
 
         arp_xmit(skb);
@@ -625,7 +626,7 @@ EXPORT_SYMBOL(arp_send);
  *      Process an arp request.
  */
 
-static int arp_process(struct sk_buff *skb)
+static int arp_process(struct sock *sk, struct sk_buff *skb)
 {
         struct net_device *dev = skb->dev;
         struct in_device *in_dev = __in_dev_get_rcu(dev);
@@ -644,7 +645,7 @@ static int arp_process(struct sk_buff *skb)
          * is ARP'able.
          */
 
-        if (in_dev == NULL)
+        if (!in_dev)
                 goto out;
 
         arp = arp_hdr(skb);
@@ -808,7 +809,7 @@ static int arp_process(struct sk_buff *skb)
                 is_garp = arp->ar_op == htons(ARPOP_REQUEST) && tip == sip &&
                           inet_addr_type(net, sip) == RTN_UNICAST;
 
-                if (n == NULL &&
+                if (!n &&
                     ((arp->ar_op == htons(ARPOP_REPLY)  &&
                       inet_addr_type(net, sip) == RTN_UNICAST) || is_garp))
                         n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
@@ -846,7 +847,7 @@ out:
 
 static void parp_redo(struct sk_buff *skb)
 {
-        arp_process(skb);
+        arp_process(NULL, skb);
 }
 
 
@@ -879,7 +880,8 @@ static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
 
         memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
 
-        return NF_HOOK(NFPROTO_ARP, NF_ARP_IN, skb, dev, NULL, arp_process);
+        return NF_HOOK(NFPROTO_ARP, NF_ARP_IN, NULL, skb,
+                       dev, NULL, arp_process);
 
 consumeskb:
         consume_skb(skb);
@@ -900,7 +902,7 @@ out_of_mem:
 
 static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
 {
-        if (dev == NULL) {
+        if (!dev) {
                 IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
                 return 0;
         }
@@ -926,7 +928,7 @@ static int arp_req_set_public(struct net *net, struct arpreq *r,
                         return -ENODEV;
         }
         if (mask) {
-                if (pneigh_lookup(&arp_tbl, net, &ip, dev, 1) == NULL)
+                if (!pneigh_lookup(&arp_tbl, net, &ip, dev, 1))
                         return -ENOBUFS;
                 return 0;
         }
@@ -947,7 +949,7 @@ static int arp_req_set(struct net *net, struct arpreq *r,
         ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
         if (r->arp_flags & ATF_PERM)
                 r->arp_flags |= ATF_COM;
-        if (dev == NULL) {
+        if (!dev) {
                 struct rtable *rt = ip_route_output(net, ip, 0, RTO_ONLINK, 0);
 
                 if (IS_ERR(rt))
@@ -1067,7 +1069,7 @@ static int arp_req_delete(struct net *net, struct arpreq *r,
                 return arp_req_delete_public(net, r, dev);
 
         ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
-        if (dev == NULL) {
+        if (!dev) {
                 struct rtable *rt = ip_route_output(net, ip, 0, RTO_ONLINK, 0);
                 if (IS_ERR(rt))
                         return PTR_ERR(rt);
@@ -1116,7 +1118,7 @@ int arp_ioctl(struct net *net, unsigned int cmd, void __user *arg)
         if (r.arp_dev[0]) {
                 err = -ENODEV;
                 dev = __dev_get_by_name(net, r.arp_dev);
-                if (dev == NULL)
+                if (!dev)
                         goto out;
 
                 /* Mmmm... It is wrong... ARPHRD_NETROM==0 */
diff --git a/net/ipv4/cipso_ipv4.c b/net/ipv4/cipso_ipv4.c
index e361ea6f3fc8..bdb2a07ec363 100644
--- a/net/ipv4/cipso_ipv4.c
+++ b/net/ipv4/cipso_ipv4.c
@@ -255,7 +255,7 @@ static int __init cipso_v4_cache_init(void)
         cipso_v4_cache = kcalloc(CIPSO_V4_CACHE_BUCKETS,
                                  sizeof(struct cipso_v4_map_cache_bkt),
                                  GFP_KERNEL);
-        if (cipso_v4_cache == NULL)
+        if (!cipso_v4_cache)
                 return -ENOMEM;
 
         for (iter = 0; iter < CIPSO_V4_CACHE_BUCKETS; iter++) {
@@ -339,7 +339,7 @@ static int cipso_v4_cache_check(const unsigned char *key,
                         secattr->cache = entry->lsm_data;
                         secattr->flags |= NETLBL_SECATTR_CACHE;
                         secattr->type = NETLBL_NLTYPE_CIPSOV4;
-                        if (prev_entry == NULL) {
+                        if (!prev_entry) {
                                 spin_unlock_bh(&cipso_v4_cache[bkt].lock);
                                 return 0;
                         }
@@ -393,10 +393,10 @@ int cipso_v4_cache_add(const unsigned char *cipso_ptr,
         cipso_ptr_len = cipso_ptr[1];
 
         entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
-        if (entry == NULL)
+        if (!entry)
                 return -ENOMEM;
         entry->key = kmemdup(cipso_ptr, cipso_ptr_len, GFP_ATOMIC);
-        if (entry->key == NULL) {
+        if (!entry->key) {
                 ret_val = -ENOMEM;
                 goto cache_add_failure;
         }
@@ -502,7 +502,7 @@ int cipso_v4_doi_add(struct cipso_v4_doi *doi_def,
         atomic_set(&doi_def->refcount, 1);
 
         spin_lock(&cipso_v4_doi_list_lock);
-        if (cipso_v4_doi_search(doi_def->doi) != NULL) {
+        if (cipso_v4_doi_search(doi_def->doi)) {
                 spin_unlock(&cipso_v4_doi_list_lock);
                 ret_val = -EEXIST;
                 goto doi_add_return;
@@ -513,7 +513,7 @@ int cipso_v4_doi_add(struct cipso_v4_doi *doi_def,
 
 doi_add_return:
         audit_buf = netlbl_audit_start(AUDIT_MAC_CIPSOV4_ADD, audit_info);
-        if (audit_buf != NULL) {
+        if (audit_buf) {
                 const char *type_str;
                 switch (doi_type) {
                 case CIPSO_V4_MAP_TRANS:
@@ -547,7 +547,7 @@ doi_add_return:
  */
 void cipso_v4_doi_free(struct cipso_v4_doi *doi_def)
 {
-        if (doi_def == NULL)
+        if (!doi_def)
                 return;
 
         switch (doi_def->type) {
@@ -598,7 +598,7 @@ int cipso_v4_doi_remove(u32 doi, struct netlbl_audit *audit_info)
 
         spin_lock(&cipso_v4_doi_list_lock);
         doi_def = cipso_v4_doi_search(doi);
-        if (doi_def == NULL) {
+        if (!doi_def) {
                 spin_unlock(&cipso_v4_doi_list_lock);
                 ret_val = -ENOENT;
                 goto doi_remove_return;
@@ -617,7 +617,7 @@ int cipso_v4_doi_remove(u32 doi, struct netlbl_audit *audit_info)
 
 doi_remove_return:
         audit_buf = netlbl_audit_start(AUDIT_MAC_CIPSOV4_DEL, audit_info);
-        if (audit_buf != NULL) {
+        if (audit_buf) {
                 audit_log_format(audit_buf,
                                  " cipso_doi=%u res=%u",
                                  doi, ret_val == 0 ? 1 : 0);
@@ -644,7 +644,7 @@ struct cipso_v4_doi *cipso_v4_doi_getdef(u32 doi)
 
         rcu_read_lock();
         doi_def = cipso_v4_doi_search(doi);
-        if (doi_def == NULL)
+        if (!doi_def)
                 goto doi_getdef_return;
         if (!atomic_inc_not_zero(&doi_def->refcount))
                 doi_def = NULL;
@@ -664,7 +664,7 @@ doi_getdef_return:
  */
 void cipso_v4_doi_putdef(struct cipso_v4_doi *doi_def)
 {
-        if (doi_def == NULL)
+        if (!doi_def)
                 return;
 
         if (!atomic_dec_and_test(&doi_def->refcount))
@@ -1642,7 +1642,7 @@ int cipso_v4_validate(const struct sk_buff *skb, unsigned char **option)
 
         rcu_read_lock();
         doi_def = cipso_v4_doi_search(get_unaligned_be32(&opt[2]));
-        if (doi_def == NULL) {
+        if (!doi_def) {
                 err_offset = 2;
                 goto validate_return_locked;
         }
@@ -1736,7 +1736,7 @@ int cipso_v4_validate(const struct sk_buff *skb, unsigned char **option)
                          * not the loopback device drop the packet. Further,
                          * there is no legitimate reason for setting this from
                          * userspace so reject it if skb is NULL. */
-                        if (skb == NULL || !(skb->dev->flags & IFF_LOOPBACK)) {
+                        if (!skb || !(skb->dev->flags & IFF_LOOPBACK)) {
                                 err_offset = opt_iter;
                                 goto validate_return_locked;
                         }
@@ -1897,7 +1897,7 @@ int cipso_v4_sock_setattr(struct sock *sk,
          * defined yet but it is not a problem as the only users of these
          * "lite" PF_INET sockets are functions which do an accept() call
          * afterwards so we will label the socket as part of the accept(). */
-        if (sk == NULL)
+        if (!sk)
                 return 0;
 
         /* We allocate the maximum CIPSO option size here so we are probably
@@ -1905,7 +1905,7 @@ int cipso_v4_sock_setattr(struct sock *sk,
          * on and after all we are only talking about 40 bytes. */
         buf_len = CIPSO_V4_OPT_LEN_MAX;
         buf = kmalloc(buf_len, GFP_ATOMIC);
-        if (buf == NULL) {
+        if (!buf) {
                 ret_val = -ENOMEM;
                 goto socket_setattr_failure;
         }
@@ -1921,7 +1921,7 @@ int cipso_v4_sock_setattr(struct sock *sk,
          * set the IPOPT_CIPSO option. */
         opt_len = (buf_len + 3) & ~3;
         opt = kzalloc(sizeof(*opt) + opt_len, GFP_ATOMIC);
-        if (opt == NULL) {
+        if (!opt) {
                 ret_val = -ENOMEM;
                 goto socket_setattr_failure;
         }
@@ -1981,7 +1981,7 @@ int cipso_v4_req_setattr(struct request_sock *req,
          * on and after all we are only talking about 40 bytes. */
         buf_len = CIPSO_V4_OPT_LEN_MAX;
         buf = kmalloc(buf_len, GFP_ATOMIC);
-        if (buf == NULL) {
+        if (!buf) {
                 ret_val = -ENOMEM;
                 goto req_setattr_failure;
         }
@@ -1997,7 +1997,7 @@ int cipso_v4_req_setattr(struct request_sock *req,
          * set the IPOPT_CIPSO option. */
         opt_len = (buf_len + 3) & ~3;
         opt = kzalloc(sizeof(*opt) + opt_len, GFP_ATOMIC);
-        if (opt == NULL) {
+        if (!opt) {
                 ret_val = -ENOMEM;
                 goto req_setattr_failure;
         }
@@ -2102,7 +2102,7 @@ void cipso_v4_sock_delattr(struct sock *sk)
 
         sk_inet = inet_sk(sk);
         opt = rcu_dereference_protected(sk_inet->inet_opt, 1);
-        if (opt == NULL || opt->opt.cipso == 0)
+        if (!opt || opt->opt.cipso == 0)
                 return;
 
         hdr_delta = cipso_v4_delopt(&sk_inet->inet_opt);
@@ -2128,7 +2128,7 @@ void cipso_v4_req_delattr(struct request_sock *req)
 
         req_inet = inet_rsk(req);
         opt = req_inet->opt;
-        if (opt == NULL || opt->opt.cipso == 0)
+        if (!opt || opt->opt.cipso == 0)
                 return;
 
         cipso_v4_delopt(&req_inet->opt);
@@ -2157,7 +2157,7 @@ int cipso_v4_getattr(const unsigned char *cipso,
         doi = get_unaligned_be32(&cipso[2]);
         rcu_read_lock();
         doi_def = cipso_v4_doi_search(doi);
-        if (doi_def == NULL)
+        if (!doi_def)
                 goto getattr_return;
         /* XXX - This code assumes only one tag per CIPSO option which isn't
          * really a good assumption to make but since we only support the MAC
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index c6473f365ad1..419d23c53ec7 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -585,7 +585,7 @@ static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
 
         ifm = nlmsg_data(nlh);
         in_dev = inetdev_by_index(net, ifm->ifa_index);
-        if (in_dev == NULL) {
+        if (!in_dev) {
                 err = -ENODEV;
                 goto errout;
         }
@@ -755,21 +755,21 @@ static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
 
         ifm = nlmsg_data(nlh);
         err = -EINVAL;
-        if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
+        if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL])
                 goto errout;
 
         dev = __dev_get_by_index(net, ifm->ifa_index);
         err = -ENODEV;
-        if (dev == NULL)
+        if (!dev)
                 goto errout;
 
         in_dev = __in_dev_get_rtnl(dev);
         err = -ENOBUFS;
-        if (in_dev == NULL)
+        if (!in_dev)
                 goto errout;
 
         ifa = inet_alloc_ifa();
-        if (ifa == NULL)
+        if (!ifa)
                 /*
                  * A potential indev allocation can be left alive, it stays
                  * assigned to its device and is destroy with it.
@@ -780,7 +780,7 @@ static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
         neigh_parms_data_state_setall(in_dev->arp_parms);
         in_dev_hold(in_dev);
 
-        if (tb[IFA_ADDRESS] == NULL)
+        if (!tb[IFA_ADDRESS])
                 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
 
         INIT_HLIST_NODE(&ifa->hash);
@@ -1290,7 +1290,7 @@ __be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
         __be32 addr = 0;
         struct net_device *dev;
 
-        if (in_dev != NULL)
+        if (in_dev)
                 return confirm_addr_indev(in_dev, dst, local, scope);
 
         rcu_read_lock();
@@ -1340,7 +1340,7 @@ static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
                 if (named++ == 0)
                         goto skip;
                 dot = strchr(old, ':');
-                if (dot == NULL) {
+                if (!dot) {
                         sprintf(old, ":%d", named);
                         dot = old;
                 }
@@ -1509,7 +1509,7 @@ static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
         u32 preferred, valid;
 
         nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
-        if (nlh == NULL)
+        if (!nlh)
                 return -EMSGSIZE;
 
         ifm = nlmsg_data(nlh);
@@ -1628,7 +1628,7 @@ static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
 
         net = dev_net(ifa->ifa_dev->dev);
         skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
-        if (skb == NULL)
+        if (!skb)
                 goto errout;
 
         err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
@@ -1665,7 +1665,7 @@ static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
                 return -ENODATA;
 
         nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
-        if (nla == NULL)
+        if (!nla)
                 return -EMSGSIZE;
 
         for (i = 0; i < IPV4_DEVCONF_MAX; i++)
@@ -1754,7 +1754,7 @@ static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
 
         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
                         flags);
-        if (nlh == NULL)
+        if (!nlh)
                 return -EMSGSIZE;
 
         ncm = nlmsg_data(nlh);
@@ -1796,7 +1796,7 @@ void inet_netconf_notify_devconf(struct net *net, int type, int ifindex,
         int err = -ENOBUFS;
 
         skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_ATOMIC);
-        if (skb == NULL)
+        if (!skb)
                 goto errout;
 
         err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
@@ -1853,10 +1853,10 @@ static int inet_netconf_get_devconf(struct sk_buff *in_skb,
                 break;
         default:
                 dev = __dev_get_by_index(net, ifindex);
-                if (dev == NULL)
+                if (!dev)
                         goto errout;
                 in_dev = __in_dev_get_rtnl(dev);
-                if (in_dev == NULL)
+                if (!in_dev)
                         goto errout;
                 devconf = &in_dev->cnf;
                 break;
@@ -1864,7 +1864,7 @@ static int inet_netconf_get_devconf(struct sk_buff *in_skb,
 
         err = -ENOBUFS;
         skb = nlmsg_new(inet_netconf_msgsize_devconf(-1), GFP_ATOMIC);
-        if (skb == NULL)
+        if (!skb)
                 goto errout;
 
         err = inet_netconf_fill_devconf(skb, ifindex, devconf,
@@ -2215,7 +2215,7 @@ static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
 {
         struct devinet_sysctl_table *t = cnf->sysctl;
 
-        if (t == NULL)
+        if (!t)
                 return;
 
         cnf->sysctl = NULL;
@@ -2276,16 +2276,16 @@ static __net_init int devinet_init_net(struct net *net)
 
         if (!net_eq(net, &init_net)) {
                 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
-                if (all == NULL)
+                if (!all)
                         goto err_alloc_all;
 
                 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
-                if (dflt == NULL)
+                if (!dflt)
                         goto err_alloc_dflt;
 
 #ifdef CONFIG_SYSCTL
                 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
-                if (tbl == NULL)
+                if (!tbl)
                         goto err_alloc_ctl;
 
                 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
@@ -2305,7 +2305,7 @@ static __net_init int devinet_init_net(struct net *net)
 
         err = -ENOMEM;
         forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
-        if (forw_hdr == NULL)
+        if (!forw_hdr)
                 goto err_reg_ctl;
         net->ipv4.forw_hdr = forw_hdr;
 #endif
diff --git a/net/ipv4/esp4.c b/net/ipv4/esp4.c
index 60173d4d3a0e..421a80b09b62 100644
--- a/net/ipv4/esp4.c
+++ b/net/ipv4/esp4.c
@@ -553,7 +553,7 @@ static int esp_init_authenc(struct xfrm_state *x)
         int err;
 
         err = -EINVAL;
-        if (x->ealg == NULL)
+        if (!x->ealg)
                 goto error;
 
         err = -ENAMETOOLONG;
diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c
index 718b0a16ea40..872494e6e6eb 100644
--- a/net/ipv4/fib_frontend.c
+++ b/net/ipv4/fib_frontend.c
@@ -53,11 +53,11 @@ static int __net_init fib4_rules_init(struct net *net)
         struct fib_table *local_table, *main_table;
 
         main_table  = fib_trie_table(RT_TABLE_MAIN, NULL);
-        if (main_table == NULL)
+        if (!main_table)
                 return -ENOMEM;
 
         local_table = fib_trie_table(RT_TABLE_LOCAL, main_table);
-        if (local_table == NULL)
+        if (!local_table)
                 goto fail;
 
         hlist_add_head_rcu(&local_table->tb_hlist,
@@ -486,7 +486,7 @@ static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
                         for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
                                 if (strcmp(ifa->ifa_label, devname) == 0)
                                         break;
-                        if (ifa == NULL)
+                        if (!ifa)
                                 return -ENODEV;
                         cfg->fc_prefsrc = ifa->ifa_local;
                 }
@@ -514,7 +514,7 @@ static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
                 int len = 0;
 
                 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
-                if (mx == NULL)
+                if (!mx)
                         return -ENOMEM;
 
                 if (rt->rt_flags & RTF_MTU)
@@ -676,7 +676,7 @@ static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
                 goto errout;
 
         tb = fib_get_table(net, cfg.fc_table);
-        if (tb == NULL) {
+        if (!tb) {
                 err = -ESRCH;
                 goto errout;
         }
@@ -698,7 +698,7 @@ static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
                 goto errout;
 
         tb = fib_new_table(net, cfg.fc_table);
-        if (tb == NULL) {
+        if (!tb) {
                 err = -ENOBUFS;
                 goto errout;
         }
@@ -779,7 +779,7 @@ static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifad
         else
                 tb = fib_new_table(net, RT_TABLE_LOCAL);
 
-        if (tb == NULL)
+        if (!tb)
                 return;
 
         cfg.fc_table = tb->tb_id;
@@ -806,7 +806,7 @@ void fib_add_ifaddr(struct in_ifaddr *ifa)
 
         if (ifa->ifa_flags & IFA_F_SECONDARY) {
                 prim = inet_ifa_byprefix(in_dev, prefix, mask);
-                if (prim == NULL) {
+                if (!prim) {
                         pr_warn("%s: bug: prim == NULL\n", __func__);
                         return;
                 }
@@ -860,7 +860,7 @@ void fib_del_ifaddr(struct in_ifaddr *ifa, struct in_ifaddr *iprim)
 
         if (ifa->ifa_flags & IFA_F_SECONDARY) {
                 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
-                if (prim == NULL) {
+                if (!prim) {
                         pr_warn("%s: bug: prim == NULL\n", __func__);
                         return;
                 }
@@ -1030,7 +1030,7 @@ static void nl_fib_input(struct sk_buff *skb)
                 return;
 
         skb = netlink_skb_clone(skb, GFP_KERNEL);
-        if (skb == NULL)
+        if (!skb)
                 return;
         nlh = nlmsg_hdr(skb);
 
@@ -1051,7 +1051,7 @@ static int __net_init nl_fib_lookup_init(struct net *net)
         };
 
         sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, &cfg);
-        if (sk == NULL)
+        if (!sk)
                 return -EAFNOSUPPORT;
         net->ipv4.fibnl = sk;
         return 0;
@@ -1089,7 +1089,7 @@ static int fib_inetaddr_event(struct notifier_block *this, unsigned long event,
         case NETDEV_DOWN:
                 fib_del_ifaddr(ifa, NULL);
                 atomic_inc(&net->ipv4.dev_addr_genid);
-                if (ifa->ifa_dev->ifa_list == NULL) {
+                if (!ifa->ifa_dev->ifa_list) {
                         /* Last address was deleted from this interface.
                          * Disable IP.
                          */
@@ -1157,7 +1157,7 @@ static int __net_init ip_fib_net_init(struct net *net)
         size = max_t(size_t, size, L1_CACHE_BYTES);
 
         net->ipv4.fib_table_hash = kzalloc(size, GFP_KERNEL);
-        if (net->ipv4.fib_table_hash == NULL)
+        if (!net->ipv4.fib_table_hash)
                 return -ENOMEM;
 
         err = fib4_rules_init(net);
@@ -1175,13 +1175,11 @@ static void ip_fib_net_exit(struct net *net)
         unsigned int i;
 
         rtnl_lock();
-
 #ifdef CONFIG_IP_MULTIPLE_TABLES
         RCU_INIT_POINTER(net->ipv4.fib_local, NULL);
         RCU_INIT_POINTER(net->ipv4.fib_main, NULL);
         RCU_INIT_POINTER(net->ipv4.fib_default, NULL);
 #endif
-
         for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
                 struct hlist_head *head = &net->ipv4.fib_table_hash[i];
                 struct hlist_node *tmp;
diff --git a/net/ipv4/fib_rules.c b/net/ipv4/fib_rules.c
index 8162dd8e86d7..56151982f74e 100644
--- a/net/ipv4/fib_rules.c
+++ b/net/ipv4/fib_rules.c
@@ -153,7 +153,7 @@ static struct fib_table *fib_empty_table(struct net *net)
         u32 id;
 
         for (id = 1; id <= RT_TABLE_MAX; id++)
-                if (fib_get_table(net, id) == NULL)
+                if (!fib_get_table(net, id))
                         return fib_new_table(net, id);
         return NULL;
 }
@@ -184,7 +184,7 @@ static int fib4_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
                         struct fib_table *table;
 
                         table = fib_empty_table(net);
-                        if (table == NULL) {
+                        if (!table) {
                                 err = -ENOBUFS;
                                 goto errout;
                         }
diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c
index eac5aec7772a..8d695b6659c7 100644
--- a/net/ipv4/fib_semantics.c
+++ b/net/ipv4/fib_semantics.c
@@ -390,7 +390,7 @@ void rtmsg_fib(int event, __be32 key, struct fib_alias *fa,
         int err = -ENOBUFS;
 
         skb = nlmsg_new(fib_nlmsg_size(fa->fa_info), GFP_KERNEL);
-        if (skb == NULL)
+        if (!skb)
                 goto errout;
 
         err = fib_dump_info(skb, info->portid, seq, event, tb_id,
@@ -503,7 +503,7 @@ int fib_nh_match(struct fib_config *cfg, struct fib_info *fi)
         }
 
 #ifdef CONFIG_IP_ROUTE_MULTIPATH
-        if (cfg->fc_mp == NULL)
+        if (!cfg->fc_mp)
                 return 0;
 
         rtnh = cfg->fc_mp;
@@ -646,7 +646,7 @@ static int fib_check_nh(struct fib_config *cfg, struct fib_info *fi,
                 rcu_read_lock();
                 err = -ENODEV;
                 in_dev = inetdev_by_index(net, nh->nh_oif);
-                if (in_dev == NULL)
+                if (!in_dev)
                         goto out;
                 err = -ENETDOWN;
                 if (!(in_dev->dev->flags & IFF_UP))
@@ -803,7 +803,7 @@ struct fib_info *fib_create_info(struct fib_config *cfg)
         }
 
         fi = kzalloc(sizeof(*fi)+nhs*sizeof(struct fib_nh), GFP_KERNEL);
-        if (fi == NULL)
+        if (!fi)
                 goto failure;
         fib_info_cnt++;
         if (cfg->fc_mx) {
@@ -921,7 +921,7 @@ struct fib_info *fib_create_info(struct fib_config *cfg)
                 nh->nh_scope = RT_SCOPE_NOWHERE;
                 nh->nh_dev = dev_get_by_index(net, fi->fib_nh->nh_oif);
                 err = -ENODEV;
-                if (nh->nh_dev == NULL)
+                if (!nh->nh_dev)
                         goto failure;
         } else {
                 change_nexthops(fi) {
@@ -995,7 +995,7 @@ int fib_dump_info(struct sk_buff *skb, u32 portid, u32 seq, int event,
         struct rtmsg *rtm;
 
         nlh = nlmsg_put(skb, portid, seq, event, sizeof(*rtm), flags);
-        if (nlh == NULL)
+        if (!nlh)
                 return -EMSGSIZE;
 
         rtm = nlmsg_data(nlh);
@@ -1045,12 +1045,12 @@ int fib_dump_info(struct sk_buff *skb, u32 portid, u32 seq, int event,
                 struct nlattr *mp;
 
                 mp = nla_nest_start(skb, RTA_MULTIPATH);
-                if (mp == NULL)
+                if (!mp)
                         goto nla_put_failure;
 
                 for_nexthops(fi) {
                         rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
-                        if (rtnh == NULL)
+                        if (!rtnh)
                                 goto nla_put_failure;
 
                         rtnh->rtnh_flags = nh->nh_flags & 0xFF;
@@ -1093,7 +1093,7 @@ int fib_sync_down_addr(struct net *net, __be32 local)
         struct hlist_head *head = &fib_info_laddrhash[hash];
         struct fib_info *fi;
 
-        if (fib_info_laddrhash == NULL || local == 0)
+        if (!fib_info_laddrhash || local == 0)
                 return 0;
 
         hlist_for_each_entry(fi, head, fib_lhash) {
@@ -1182,7 +1182,7 @@ void fib_select_default(struct fib_result *res)
 
                 fib_alias_accessed(fa);
 
-                if (fi == NULL) {
+                if (!fi) {
                         if (next_fi != res->fi)
                                 break;
                 } else if (!fib_detect_death(fi, order, &last_resort,
@@ -1195,7 +1195,7 @@ void fib_select_default(struct fib_result *res)
                 order++;
         }
 
-        if (order <= 0 || fi == NULL) {
+        if (order <= 0 || !fi) {
                 tb->tb_default = -1;
                 goto out;
         }
@@ -1251,7 +1251,7 @@ int fib_sync_up(struct net_device *dev)
                                 alive++;
                                 continue;
                         }
-                        if (nexthop_nh->nh_dev == NULL ||
+                        if (!nexthop_nh->nh_dev ||
                             !(nexthop_nh->nh_dev->flags & IFF_UP))
                                 continue;
                         if (nexthop_nh->nh_dev != dev ||
diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c
index 2c7c299ee2b9..e13fcc602da2 100644
--- a/net/ipv4/fib_trie.c
+++ b/net/ipv4/fib_trie.c
@@ -391,9 +391,9 @@ static void put_child(struct key_vector *tn, unsigned long i,
         BUG_ON(i >= child_length(tn));
 
         /* update emptyChildren, overflow into fullChildren */
-        if (n == NULL && chi != NULL)
+        if (!n && chi)
                 empty_child_inc(tn);
-        if (n != NULL && chi == NULL)
+        if (n && !chi)
                 empty_child_dec(tn);
 
         /* update fullChildren */
@@ -528,7 +528,7 @@ static struct key_vector *inflate(struct trie *t,
                 unsigned long j, k;
 
                 /* An empty child */
-                if (inode == NULL)
+                if (!inode)
                         continue;
 
                 /* A leaf or an internal node with skipped bits */
@@ -1154,7 +1154,7 @@ int fib_table_insert(struct fib_table *tb, struct fib_config *cfg)
                         }
                         err = -ENOBUFS;
                         new_fa = kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
-                        if (new_fa == NULL)
+                        if (!new_fa)
                                 goto out;
 
                         fi_drop = fa->fa_info;
@@ -1204,7 +1204,7 @@ int fib_table_insert(struct fib_table *tb, struct fib_config *cfg)
 
         err = -ENOBUFS;
         new_fa = kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
-        if (new_fa == NULL)
+        if (!new_fa)
                 goto out;
 
         new_fa->fa_info = fi;
@@ -1975,7 +1975,7 @@ struct fib_table *fib_trie_table(u32 id, struct fib_table *alias)
                 sz += sizeof(struct trie);
 
         tb = kzalloc(sz, GFP_KERNEL);
-        if (tb == NULL)
+        if (!tb)
                 return NULL;
 
         tb->tb_id = id;
diff --git a/net/ipv4/geneve.c b/net/ipv4/geneve.c
index 5a4828ba05ad..b77f5e84c623 100644
--- a/net/ipv4/geneve.c
+++ b/net/ipv4/geneve.c
@@ -136,7 +136,7 @@ int geneve_xmit_skb(struct geneve_sock *gs, struct rtable *rt,
 
         skb_set_inner_protocol(skb, htons(ETH_P_TEB));
 
-        return udp_tunnel_xmit_skb(rt, skb, src, dst,
+        return udp_tunnel_xmit_skb(rt, gs->sock->sk, skb, src, dst,
                                    tos, ttl, df, src_port, dst_port, xnet,
                                    !csum);
 }
@@ -196,7 +196,7 @@ static struct sk_buff **geneve_gro_receive(struct sk_buff **head,
 
         rcu_read_lock();
         ptype = gro_find_receive_by_type(type);
-        if (ptype == NULL) {
+        if (!ptype) {
                 flush = 1;
                 goto out_unlock;
         }
@@ -230,7 +230,7 @@ static int geneve_gro_complete(struct sk_buff *skb, int nhoff,
 
         rcu_read_lock();
         ptype = gro_find_complete_by_type(type);
-        if (ptype != NULL)
+        if (ptype)
                 err = ptype->callbacks.gro_complete(skb, nhoff + gh_len);
 
         rcu_read_unlock();
diff --git a/net/ipv4/gre_offload.c b/net/ipv4/gre_offload.c
index 51973ddc05a6..5aa46d4b44ef 100644
--- a/net/ipv4/gre_offload.c
+++ b/net/ipv4/gre_offload.c
@@ -149,7 +149,7 @@ static struct sk_buff **gre_gro_receive(struct sk_buff **head,
 
         rcu_read_lock();
         ptype = gro_find_receive_by_type(type);
-        if (ptype == NULL)
+        if (!ptype)
                 goto out_unlock;
 
         grehlen = GRE_HEADER_SECTION;
@@ -243,7 +243,7 @@ static int gre_gro_complete(struct sk_buff *skb, int nhoff)
 
         rcu_read_lock();
         ptype = gro_find_complete_by_type(type);
-        if (ptype != NULL)
+        if (ptype)
                 err = ptype->callbacks.gro_complete(skb, nhoff + grehlen);
 
         rcu_read_unlock();
diff --git a/net/ipv4/icmp.c b/net/ipv4/icmp.c
index 5e564014a0b7..f5203fba6236 100644
--- a/net/ipv4/icmp.c
+++ b/net/ipv4/icmp.c
@@ -399,7 +399,7 @@ static void icmp_reply(struct icmp_bxm *icmp_param, struct sk_buff *skb)
                 return;
 
         sk = icmp_xmit_lock(net);
-        if (sk == NULL)
+        if (!sk)
                 return;
         inet = inet_sk(sk);
 
@@ -609,7 +609,7 @@ void icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info)
                                                  skb_in->data,
                                                  sizeof(_inner_type),
                                                  &_inner_type);
-                        if (itp == NULL)
+                        if (!itp)
                                 goto out;
 
                         /*
@@ -627,7 +627,7 @@ void icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info)
                 return;
 
         sk = icmp_xmit_lock(net);
-        if (sk == NULL)
+        if (!sk)
                 goto out_free;
 
         /*
diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c
index ad09213ac5b2..a3a697f5ffba 100644
--- a/net/ipv4/igmp.c
+++ b/net/ipv4/igmp.c
@@ -692,7 +692,7 @@ static int igmp_send_report(struct in_device *in_dev, struct ip_mc_list *pmc,
         hlen = LL_RESERVED_SPACE(dev);
         tlen = dev->needed_tailroom;
         skb = alloc_skb(IGMP_SIZE + hlen + tlen, GFP_ATOMIC);
-        if (skb == NULL) {
+        if (!skb) {
                 ip_rt_put(rt);
                 return -1;
         }
@@ -981,7 +981,7 @@ int igmp_rcv(struct sk_buff *skb)
         int len = skb->len;
         bool dropped = true;
 
-        if (in_dev == NULL)
+        if (!in_dev)
                 goto drop;
 
         if (!pskb_may_pull(skb, sizeof(struct igmphdr)))
@@ -1888,7 +1888,7 @@ int ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr)
         if (count >= sysctl_igmp_max_memberships)
                 goto done;
         iml = sock_kmalloc(sk, sizeof(*iml), GFP_KERNEL);
-        if (iml == NULL)
+        if (!iml)
                 goto done;
 
         memcpy(&iml->multi, imr, sizeof(*imr));
@@ -1909,7 +1909,7 @@ static int ip_mc_leave_src(struct sock *sk, struct ip_mc_socklist *iml,
         struct ip_sf_socklist *psf = rtnl_dereference(iml->sflist);
         int err;
 
-        if (psf == NULL) {
+        if (!psf) {
                 /* any-source empty exclude case */
                 return ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr,
                         iml->sfmode, 0, NULL, 0);
@@ -2360,7 +2360,7 @@ void ip_mc_drop_socket(struct sock *sk)
         struct ip_mc_socklist *iml;
         struct net *net = sock_net(sk);
 
-        if (inet->mc_list == NULL)
+        if (!inet->mc_list)
                 return;
 
         rtnl_lock();
@@ -2370,7 +2370,7 @@ void ip_mc_drop_socket(struct sock *sk)
                 inet->mc_list = iml->next_rcu;
                 in_dev = inetdev_by_index(net, iml->multi.imr_ifindex);
                 (void) ip_mc_leave_src(sk, iml, in_dev);
-                if (in_dev != NULL)
+                if (in_dev)
                         ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr);
                 /* decrease mem now to avoid the memleak warning */
                 atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
@@ -2587,13 +2587,13 @@ static inline struct ip_sf_list *igmp_mcf_get_first(struct seq_file *seq)
         for_each_netdev_rcu(net, state->dev) {
                 struct in_device *idev;
                 idev = __in_dev_get_rcu(state->dev);
-                if (unlikely(idev == NULL))
+                if (unlikely(!idev))
                         continue;
                 im = rcu_dereference(idev->mc_list);
-                if (likely(im != NULL)) {
+                if (likely(im)) {
                         spin_lock_bh(&im->lock);
                         psf = im->sources;
-                        if (likely(psf != NULL)) {
+                        if (likely(psf)) {
                                 state->im = im;
                                 state->idev = idev;
                                 break;
@@ -2663,7 +2663,7 @@ static void igmp_mcf_seq_stop(struct seq_file *seq, void *v)
         __releases(rcu)
 {
         struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
-        if (likely(state->im != NULL)) {
+        if (likely(state->im)) {
                 spin_unlock_bh(&state->im->lock);
                 state->im = NULL;
         }
diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
index 79c0c9439fdc..5c3dd6267ed3 100644
--- a/net/ipv4/inet_connection_sock.c
+++ b/net/ipv4/inet_connection_sock.c
@@ -673,7 +673,7 @@ struct sock *inet_csk_clone_lock(const struct sock *sk,
 {
         struct sock *newsk = sk_clone_lock(sk, priority);
 
-        if (newsk != NULL) {
+        if (newsk) {
                 struct inet_connection_sock *newicsk = inet_csk(newsk);
 
                 newsk->sk_state = TCP_SYN_RECV;
@@ -843,7 +843,7 @@ void inet_csk_listen_stop(struct sock *sk)
                 sk_acceptq_removed(sk);
                 reqsk_put(req);
         }
-        if (queue->fastopenq != NULL) {
+        if (queue->fastopenq) {
                 /* Free all the reqs queued in rskq_rst_head. */
                 spin_lock_bh(&queue->fastopenq->lock);
                 acc_req = queue->fastopenq->rskq_rst_head;
@@ -875,7 +875,7 @@ int inet_csk_compat_getsockopt(struct sock *sk, int level, int optname,
 {
         const struct inet_connection_sock *icsk = inet_csk(sk);
 
-        if (icsk->icsk_af_ops->compat_getsockopt != NULL)
+        if (icsk->icsk_af_ops->compat_getsockopt)
                 return icsk->icsk_af_ops->compat_getsockopt(sk, level, optname,
                                                             optval, optlen);
         return icsk->icsk_af_ops->getsockopt(sk, level, optname,
@@ -888,7 +888,7 @@ int inet_csk_compat_setsockopt(struct sock *sk, int level, int optname,
 {
         const struct inet_connection_sock *icsk = inet_csk(sk);
 
-        if (icsk->icsk_af_ops->compat_setsockopt != NULL)
+        if (icsk->icsk_af_ops->compat_setsockopt)
                 return icsk->icsk_af_ops->compat_setsockopt(sk, level, optname,
                                                             optval, optlen);
         return icsk->icsk_af_ops->setsockopt(sk, level, optname,
diff --git a/net/ipv4/inet_fragment.c b/net/ipv4/inet_fragment.c
index e7920352646a..5e346a082e5f 100644
--- a/net/ipv4/inet_fragment.c
+++ b/net/ipv4/inet_fragment.c
@@ -385,7 +385,7 @@ static struct inet_frag_queue *inet_frag_alloc(struct netns_frags *nf,
         }
 
         q = kmem_cache_zalloc(f->frags_cachep, GFP_ATOMIC);
-        if (q == NULL)
+        if (!q)
                 return NULL;
 
         q->net = nf;
@@ -406,7 +406,7 @@ static struct inet_frag_queue *inet_frag_create(struct netns_frags *nf,
         struct inet_frag_queue *q;
 
         q = inet_frag_alloc(nf, f, arg);
-        if (q == NULL)
+        if (!q)
                 return NULL;
 
         return inet_frag_intern(nf, q, f, arg);
diff --git a/net/ipv4/inet_hashtables.c b/net/ipv4/inet_hashtables.c
index 0fb841b9d834..d4630bf2d9aa 100644
--- a/net/ipv4/inet_hashtables.c
+++ b/net/ipv4/inet_hashtables.c
@@ -64,7 +64,7 @@ struct inet_bind_bucket *inet_bind_bucket_create(struct kmem_cache *cachep,
 {
         struct inet_bind_bucket *tb = kmem_cache_alloc(cachep, GFP_ATOMIC);
 
-        if (tb != NULL) {
+        if (tb) {
                 write_pnet(&tb->ib_net, net);
                 tb->port      = snum;
                 tb->fastreuse = 0;
diff --git a/net/ipv4/inet_timewait_sock.c b/net/ipv4/inet_timewait_sock.c
index f38e387448fb..118f0f195820 100644
--- a/net/ipv4/inet_timewait_sock.c
+++ b/net/ipv4/inet_timewait_sock.c
@@ -173,7 +173,7 @@ struct inet_timewait_sock *inet_twsk_alloc(const struct sock *sk, const int stat
         struct inet_timewait_sock *tw =
                 kmem_cache_alloc(sk->sk_prot_creator->twsk_prot->twsk_slab,
                                  GFP_ATOMIC);
-        if (tw != NULL) {
+        if (tw) {
                 const struct inet_sock *inet = inet_sk(sk);
 
                 kmemcheck_annotate_bitfield(tw, flags);
diff --git a/net/ipv4/ip_forward.c b/net/ipv4/ip_forward.c
index d9bc28ac5d1b..939992c456f3 100644
--- a/net/ipv4/ip_forward.c
+++ b/net/ipv4/ip_forward.c
@@ -57,7 +57,7 @@ static bool ip_exceeds_mtu(const struct sk_buff *skb, unsigned int mtu)
 }
 
 
-static int ip_forward_finish(struct sk_buff *skb)
+static int ip_forward_finish(struct sock *sk, struct sk_buff *skb)
 {
         struct ip_options *opt  = &(IPCB(skb)->opt);
 
@@ -68,7 +68,7 @@ static int ip_forward_finish(struct sk_buff *skb)
                 ip_forward_options(skb);
 
         skb_sender_cpu_clear(skb);
-        return dst_output(skb);
+        return dst_output_sk(sk, skb);
 }
 
 int ip_forward(struct sk_buff *skb)
@@ -136,8 +136,8 @@ int ip_forward(struct sk_buff *skb)
 
         skb->priority = rt_tos2priority(iph->tos);
 
-        return NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, skb, skb->dev,
-                       rt->dst.dev, ip_forward_finish);
+        return NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, NULL, skb,
+                       skb->dev, rt->dst.dev, ip_forward_finish);
 
 sr_failed:
         /*
diff --git a/net/ipv4/ip_fragment.c b/net/ipv4/ip_fragment.c
index 145a50c4d566..cc1da6d9cb35 100644
--- a/net/ipv4/ip_fragment.c
+++ b/net/ipv4/ip_fragment.c
@@ -372,7 +372,7 @@ static int ip_frag_queue(struct ipq *qp, struct sk_buff *skb)
                 goto err;
 
         err = -ENOMEM;
-        if (pskb_pull(skb, ihl) == NULL)
+        if (!pskb_pull(skb, ihl))
                 goto err;
 
         err = pskb_trim_rcsum(skb, end - offset);
@@ -537,7 +537,7 @@ static int ip_frag_reasm(struct ipq *qp, struct sk_buff *prev,
                 qp->q.fragments = head;
         }
 
-        WARN_ON(head == NULL);
+        WARN_ON(!head);
         WARN_ON(FRAG_CB(head)->offset != 0);
 
         /* Allocate a new buffer for the datagram. */
@@ -559,7 +559,8 @@ static int ip_frag_reasm(struct ipq *qp, struct sk_buff *prev,
                 struct sk_buff *clone;
                 int i, plen = 0;
 
-                if ((clone = alloc_skb(0, GFP_ATOMIC)) == NULL)
+                clone = alloc_skb(0, GFP_ATOMIC);
+                if (!clone)
                         goto out_nomem;
                 clone->next = head->next;
                 head->next = clone;
@@ -638,7 +639,8 @@ int ip_defrag(struct sk_buff *skb, u32 user)
         IP_INC_STATS_BH(net, IPSTATS_MIB_REASMREQDS);
 
         /* Lookup (or create) queue header */
-        if ((qp = ip_find(net, ip_hdr(skb), user)) != NULL) {
+        qp = ip_find(net, ip_hdr(skb), user);
+        if (qp) {
                 int ret;
 
                 spin_lock(&qp->q.lock);
@@ -754,7 +756,7 @@ static int __net_init ip4_frags_ns_ctl_register(struct net *net)
         table = ip4_frags_ns_ctl_table;
         if (!net_eq(net, &init_net)) {
                 table = kmemdup(table, sizeof(ip4_frags_ns_ctl_table), GFP_KERNEL);
-                if (table == NULL)
+                if (!table)
                         goto err_alloc;
 
                 table[0].data = &net->ipv4.frags.high_thresh;
@@ -770,7 +772,7 @@ static int __net_init ip4_frags_ns_ctl_register(struct net *net)
         }
 
         hdr = register_net_sysctl(net, "net/ipv4", table);
-        if (hdr == NULL)
+        if (!hdr)
                 goto err_reg;
 
         net->ipv4.frags_hdr = hdr;
diff --git a/net/ipv4/ip_gre.c b/net/ipv4/ip_gre.c
index 0eb2a040a830..5fd706473c73 100644
--- a/net/ipv4/ip_gre.c
+++ b/net/ipv4/ip_gre.c
@@ -182,7 +182,7 @@ static int ipgre_err(struct sk_buff *skb, u32 info,
         t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
                              iph->daddr, iph->saddr, tpi->key);
 
-        if (t == NULL)
+        if (!t)
                 return PACKET_REJECT;
 
         if (t->parms.iph.daddr == 0 ||
@@ -423,7 +423,7 @@ static int ipgre_open(struct net_device *dev)
                         return -EADDRNOTAVAIL;
                 dev = rt->dst.dev;
                 ip_rt_put(rt);
-                if (__in_dev_get_rtnl(dev) == NULL)
+                if (!__in_dev_get_rtnl(dev))
                         return -EADDRNOTAVAIL;
                 t->mlink = dev->ifindex;
                 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
@@ -456,6 +456,7 @@ static const struct net_device_ops ipgre_netdev_ops = {
         .ndo_do_ioctl           = ipgre_tunnel_ioctl,
         .ndo_change_mtu         = ip_tunnel_change_mtu,
         .ndo_get_stats64        = ip_tunnel_get_stats64,
+        .ndo_get_iflink         = ip_tunnel_get_iflink,
 };
 
 #define GRE_FEATURES (NETIF_F_SG |              \
@@ -686,6 +687,7 @@ static const struct net_device_ops gre_tap_netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_change_mtu         = ip_tunnel_change_mtu,
         .ndo_get_stats64        = ip_tunnel_get_stats64,
+        .ndo_get_iflink         = ip_tunnel_get_iflink,
 };
 
 static void ipgre_tap_setup(struct net_device *dev)
diff --git a/net/ipv4/ip_input.c b/net/ipv4/ip_input.c
index 3d4da2c16b6a..2db4c8773c1b 100644
--- a/net/ipv4/ip_input.c
+++ b/net/ipv4/ip_input.c
@@ -187,7 +187,7 @@ bool ip_call_ra_chain(struct sk_buff *skb)
         return false;
 }
 
-static int ip_local_deliver_finish(struct sk_buff *skb)
+static int ip_local_deliver_finish(struct sock *sk, struct sk_buff *skb)
 {
         struct net *net = dev_net(skb->dev);
 
@@ -203,7 +203,7 @@ static int ip_local_deliver_finish(struct sk_buff *skb)
                 raw = raw_local_deliver(skb, protocol);
 
                 ipprot = rcu_dereference(inet_protos[protocol]);
-                if (ipprot != NULL) {
+                if (ipprot) {
                         int ret;
 
                         if (!ipprot->no_policy) {
@@ -253,7 +253,8 @@ int ip_local_deliver(struct sk_buff *skb)
                         return 0;
         }
 
-        return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN, skb, skb->dev, NULL,
+        return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN, NULL, skb,
+                       skb->dev, NULL,
                        ip_local_deliver_finish);
 }
 
@@ -309,12 +310,12 @@ drop:
 int sysctl_ip_early_demux __read_mostly = 1;
 EXPORT_SYMBOL(sysctl_ip_early_demux);
 
-static int ip_rcv_finish(struct sk_buff *skb)
+static int ip_rcv_finish(struct sock *sk, struct sk_buff *skb)
 {
         const struct iphdr *iph = ip_hdr(skb);
         struct rtable *rt;
 
-        if (sysctl_ip_early_demux && !skb_dst(skb) && skb->sk == NULL) {
+        if (sysctl_ip_early_demux && !skb_dst(skb) && !skb->sk) {
                 const struct net_protocol *ipprot;
                 int protocol = iph->protocol;
 
@@ -387,7 +388,8 @@ int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt,
 
         IP_UPD_PO_STATS_BH(dev_net(dev), IPSTATS_MIB_IN, skb->len);
 
-        if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
+        skb = skb_share_check(skb, GFP_ATOMIC);
+        if (!skb) {
                 IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_INDISCARDS);
                 goto out;
         }
@@ -450,7 +452,8 @@ int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt,
         /* Must drop socket now because of tproxy. */
         skb_orphan(skb);
 
-        return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, skb, dev, NULL,
+        return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, NULL, skb,
+                       dev, NULL,
                        ip_rcv_finish);
 
 csum_error:
diff --git a/net/ipv4/ip_options.c b/net/ipv4/ip_options.c
index 5b3d91be2db0..bd246792360b 100644
--- a/net/ipv4/ip_options.c
+++ b/net/ipv4/ip_options.c
@@ -264,7 +264,7 @@ int ip_options_compile(struct net *net,
         unsigned char *iph;
         int optlen, l;
 
-        if (skb != NULL) {
+        if (skb) {
                 rt = skb_rtable(skb);
                 optptr = (unsigned char *)&(ip_hdr(skb)[1]);
         } else
diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c
index 8259e777b249..5da4d15262fd 100644
--- a/net/ipv4/ip_output.c
+++ b/net/ipv4/ip_output.c
@@ -91,14 +91,19 @@ void ip_send_check(struct iphdr *iph)
 }
 EXPORT_SYMBOL(ip_send_check);
 
-int __ip_local_out(struct sk_buff *skb)
+int __ip_local_out_sk(struct sock *sk, struct sk_buff *skb)
 {
         struct iphdr *iph = ip_hdr(skb);
 
         iph->tot_len = htons(skb->len);
         ip_send_check(iph);
-        return nf_hook(NFPROTO_IPV4, NF_INET_LOCAL_OUT, skb, NULL,
-                       skb_dst(skb)->dev, dst_output);
+        return nf_hook(NFPROTO_IPV4, NF_INET_LOCAL_OUT, sk, skb, NULL,
+                       skb_dst(skb)->dev, dst_output_sk);
+}
+
+int __ip_local_out(struct sk_buff *skb)
+{
+        return __ip_local_out_sk(skb->sk, skb);
 }
 
 int ip_local_out_sk(struct sock *sk, struct sk_buff *skb)
@@ -163,7 +168,7 @@ int ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk,
 }
 EXPORT_SYMBOL_GPL(ip_build_and_send_pkt);
 
-static inline int ip_finish_output2(struct sk_buff *skb)
+static inline int ip_finish_output2(struct sock *sk, struct sk_buff *skb)
 {
         struct dst_entry *dst = skb_dst(skb);
         struct rtable *rt = (struct rtable *)dst;
@@ -182,7 +187,7 @@ static inline int ip_finish_output2(struct sk_buff *skb)
                 struct sk_buff *skb2;
 
                 skb2 = skb_realloc_headroom(skb, LL_RESERVED_SPACE(dev));
-                if (skb2 == NULL) {
+                if (!skb2) {
                         kfree_skb(skb);
                         return -ENOMEM;
                 }
@@ -211,7 +216,7 @@ static inline int ip_finish_output2(struct sk_buff *skb)
         return -EINVAL;
 }
 
-static int ip_finish_output_gso(struct sk_buff *skb)
+static int ip_finish_output_gso(struct sock *sk, struct sk_buff *skb)
 {
         netdev_features_t features;
         struct sk_buff *segs;
@@ -220,7 +225,7 @@ static int ip_finish_output_gso(struct sk_buff *skb)
         /* common case: locally created skb or seglen is <= mtu */
         if (((IPCB(skb)->flags & IPSKB_FORWARDED) == 0) ||
               skb_gso_network_seglen(skb) <= ip_skb_dst_mtu(skb))
-                return ip_finish_output2(skb);
+                return ip_finish_output2(sk, skb);
 
         /* Slowpath -  GSO segment length is exceeding the dst MTU.
          *
@@ -243,7 +248,7 @@ static int ip_finish_output_gso(struct sk_buff *skb)
                 int err;
 
                 segs->next = NULL;
-                err = ip_fragment(segs, ip_finish_output2);
+                err = ip_fragment(sk, segs, ip_finish_output2);
 
                 if (err && ret == 0)
                         ret = err;
@@ -253,22 +258,22 @@ static int ip_finish_output_gso(struct sk_buff *skb)
         return ret;
 }
 
-static int ip_finish_output(struct sk_buff *skb)
+static int ip_finish_output(struct sock *sk, struct sk_buff *skb)
 {
 #if defined(CONFIG_NETFILTER) && defined(CONFIG_XFRM)
         /* Policy lookup after SNAT yielded a new policy */
-        if (skb_dst(skb)->xfrm != NULL) {
+        if (skb_dst(skb)->xfrm) {
                 IPCB(skb)->flags |= IPSKB_REROUTED;
-                return dst_output(skb);
+                return dst_output_sk(sk, skb);
         }
 #endif
         if (skb_is_gso(skb))
-                return ip_finish_output_gso(skb);
+                return ip_finish_output_gso(sk, skb);
 
         if (skb->len > ip_skb_dst_mtu(skb))
-                return ip_fragment(skb, ip_finish_output2);
+                return ip_fragment(sk, skb, ip_finish_output2);
 
-        return ip_finish_output2(skb);
+        return ip_finish_output2(sk, skb);
 }
 
 int ip_mc_output(struct sock *sk, struct sk_buff *skb)
@@ -307,7 +312,7 @@ int ip_mc_output(struct sock *sk, struct sk_buff *skb)
                         struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
                         if (newskb)
                                 NF_HOOK(NFPROTO_IPV4, NF_INET_POST_ROUTING,
-                                        newskb, NULL, newskb->dev,
+                                        sk, newskb, NULL, newskb->dev,
                                         dev_loopback_xmit);
                 }
 
@@ -322,11 +327,11 @@ int ip_mc_output(struct sock *sk, struct sk_buff *skb)
         if (rt->rt_flags&RTCF_BROADCAST) {
                 struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
                 if (newskb)
-                        NF_HOOK(NFPROTO_IPV4, NF_INET_POST_ROUTING, newskb,
+                        NF_HOOK(NFPROTO_IPV4, NF_INET_POST_ROUTING, sk, newskb,
                                 NULL, newskb->dev, dev_loopback_xmit);
         }
 
-        return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING, skb, NULL,
+        return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING, sk, skb, NULL,
                             skb->dev, ip_finish_output,
                             !(IPCB(skb)->flags & IPSKB_REROUTED));
 }
@@ -340,7 +345,8 @@ int ip_output(struct sock *sk, struct sk_buff *skb)
         skb->dev = dev;
         skb->protocol = htons(ETH_P_IP);
 
-        return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING, skb, NULL, dev,
+        return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING, sk, skb,
+                            NULL, dev,
                             ip_finish_output,
                             !(IPCB(skb)->flags & IPSKB_REROUTED));
 }
@@ -376,12 +382,12 @@ int ip_queue_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl)
         inet_opt = rcu_dereference(inet->inet_opt);
         fl4 = &fl->u.ip4;
         rt = skb_rtable(skb);
-        if (rt != NULL)
+        if (rt)
                 goto packet_routed;
 
         /* Make sure we can route this packet. */
         rt = (struct rtable *)__sk_dst_check(sk, 0);
-        if (rt == NULL) {
+        if (!rt) {
                 __be32 daddr;
 
                 /* Use correct destination address if we have options. */
@@ -480,7 +486,8 @@ static void ip_copy_metadata(struct sk_buff *to, struct sk_buff *from)
  *      single device frame, and queue such a frame for sending.
  */
 
-int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
+int ip_fragment(struct sock *sk, struct sk_buff *skb,
+                int (*output)(struct sock *, struct sk_buff *))
 {
         struct iphdr *iph;
         int ptr;
@@ -587,13 +594,13 @@ int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
                                         ip_options_fragment(frag);
                                 offset += skb->len - hlen;
                                 iph->frag_off = htons(offset>>3);
-                                if (frag->next != NULL)
+                                if (frag->next)
                                         iph->frag_off |= htons(IP_MF);
                                 /* Ready, complete checksum */
                                 ip_send_check(iph);
                         }
 
-                        err = output(skb);
+                        err = output(sk, skb);
 
                         if (!err)
                                 IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGCREATES);
@@ -730,7 +737,7 @@ slow_path:
 
                 ip_send_check(iph);
 
-                err = output(skb2);
+                err = output(sk, skb2);
                 if (err)
                         goto fail;
 
@@ -790,12 +797,13 @@ static inline int ip_ufo_append_data(struct sock *sk,
          * device, so create one single skb packet containing complete
          * udp datagram
          */
-        if ((skb = skb_peek_tail(queue)) == NULL) {
+        skb = skb_peek_tail(queue);
+        if (!skb) {
                 skb = sock_alloc_send_skb(sk,
                         hh_len + fragheaderlen + transhdrlen + 20,
                         (flags & MSG_DONTWAIT), &err);
 
-                if (skb == NULL)
+                if (!skb)
                         return err;
 
                 /* reserve space for Hardware header */
@@ -961,10 +969,10 @@ alloc_new_skb:
                                         skb = sock_wmalloc(sk,
                                                            alloclen + hh_len + 15, 1,
                                                            sk->sk_allocation);
-                                if (unlikely(skb == NULL))
+                                if (unlikely(!skb))
                                         err = -ENOBUFS;
                         }
-                        if (skb == NULL)
+                        if (!skb)
                                 goto error;
 
                         /*
@@ -1088,10 +1096,10 @@ static int ip_setup_cork(struct sock *sk, struct inet_cork *cork,
          */
         opt = ipc->opt;
         if (opt) {
-                if (cork->opt == NULL) {
+                if (!cork->opt) {
                         cork->opt = kmalloc(sizeof(struct ip_options) + 40,
                                             sk->sk_allocation);
-                        if (unlikely(cork->opt == NULL))
+                        if (unlikely(!cork->opt))
                                 return -ENOBUFS;
                 }
                 memcpy(cork->opt, &opt->opt, sizeof(struct ip_options) + opt->opt.optlen);
@@ -1198,7 +1206,8 @@ ssize_t	ip_append_page(struct sock *sk, struct flowi4 *fl4, struct page *page,
                 return -EMSGSIZE;
         }
 
-        if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)
+        skb = skb_peek_tail(&sk->sk_write_queue);
+        if (!skb)
                 return -EINVAL;
 
         cork->length += size;
@@ -1329,7 +1338,8 @@ struct sk_buff *__ip_make_skb(struct sock *sk,
         __be16 df = 0;
         __u8 ttl;
 
-        if ((skb = __skb_dequeue(queue)) == NULL)
+        skb = __skb_dequeue(queue);
+        if (!skb)
                 goto out;
         tail_skb = &(skb_shinfo(skb)->frag_list);
 
diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c
index f6a0d54b308a..7cfb0893f263 100644
--- a/net/ipv4/ip_sockglue.c
+++ b/net/ipv4/ip_sockglue.c
@@ -351,7 +351,7 @@ int ip_ra_control(struct sock *sk, unsigned char on,
                         return 0;
                 }
         }
-        if (new_ra == NULL) {
+        if (!new_ra) {
                 spin_unlock_bh(&ip_ra_lock);
                 return -ENOBUFS;
         }
@@ -387,7 +387,7 @@ void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
                                    skb_network_header(skb);
         serr->port = port;
 
-        if (skb_pull(skb, payload - skb->data) != NULL) {
+        if (skb_pull(skb, payload - skb->data)) {
                 skb_reset_transport_header(skb);
                 if (sock_queue_err_skb(sk, skb) == 0)
                         return;
@@ -482,7 +482,7 @@ int ip_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len)
 
         err = -EAGAIN;
         skb = sock_dequeue_err_skb(sk);
-        if (skb == NULL)
+        if (!skb)
                 goto out;
 
         copied = skb->len;
diff --git a/net/ipv4/ip_tunnel.c b/net/ipv4/ip_tunnel.c
index 2cd08280c77b..4c2c3ba4ba65 100644
--- a/net/ipv4/ip_tunnel.c
+++ b/net/ipv4/ip_tunnel.c
@@ -389,7 +389,6 @@ static int ip_tunnel_bind_dev(struct net_device *dev)
                 hlen = tdev->hard_header_len + tdev->needed_headroom;
                 mtu = tdev->mtu;
         }
-        dev->iflink = tunnel->parms.link;
 
         dev->needed_headroom = t_hlen + hlen;
         mtu -= (dev->hard_header_len + t_hlen);
@@ -655,7 +654,7 @@ void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
         if (dst == 0) {
                 /* NBMA tunnel */
 
-                if (skb_dst(skb) == NULL) {
+                if (!skb_dst(skb)) {
                         dev->stats.tx_fifo_errors++;
                         goto tx_error;
                 }
@@ -673,7 +672,7 @@ void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
 
                         neigh = dst_neigh_lookup(skb_dst(skb),
                                                  &ipv6_hdr(skb)->daddr);
-                        if (neigh == NULL)
+                        if (!neigh)
                                 goto tx_error;
 
                         addr6 = (const struct in6_addr *)&neigh->primary_key;
@@ -783,7 +782,7 @@ void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
                 return;
         }
 
-        err = iptunnel_xmit(skb->sk, rt, skb, fl4.saddr, fl4.daddr, protocol,
+        err = iptunnel_xmit(NULL, rt, skb, fl4.saddr, fl4.daddr, protocol,
                             tos, ttl, df, !net_eq(tunnel->net, dev_net(dev)));
         iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
 
@@ -844,7 +843,7 @@ int ip_tunnel_ioctl(struct net_device *dev, struct ip_tunnel_parm *p, int cmd)
         case SIOCGETTUNNEL:
                 if (dev == itn->fb_tunnel_dev) {
                         t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
-                        if (t == NULL)
+                        if (!t)
                                 t = netdev_priv(dev);
                 }
                 memcpy(p, &t->parms, sizeof(*p));
@@ -877,7 +876,7 @@ int ip_tunnel_ioctl(struct net_device *dev, struct ip_tunnel_parm *p, int cmd)
                         break;
                 }
                 if (dev != itn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
-                        if (t != NULL) {
+                        if (t) {
                                 if (t->dev != dev) {
                                         err = -EEXIST;
                                         break;
@@ -915,7 +914,7 @@ int ip_tunnel_ioctl(struct net_device *dev, struct ip_tunnel_parm *p, int cmd)
                 if (dev == itn->fb_tunnel_dev) {
                         err = -ENOENT;
                         t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
-                        if (t == NULL)
+                        if (!t)
                                 goto done;
                         err = -EPERM;
                         if (t == netdev_priv(itn->fb_tunnel_dev))
@@ -980,6 +979,14 @@ struct net *ip_tunnel_get_link_net(const struct net_device *dev)
 }
 EXPORT_SYMBOL(ip_tunnel_get_link_net);
 
+int ip_tunnel_get_iflink(const struct net_device *dev)
+{
+        struct ip_tunnel *tunnel = netdev_priv(dev);
+
+        return tunnel->parms.link;
+}
+EXPORT_SYMBOL(ip_tunnel_get_iflink);
+
 int ip_tunnel_init_net(struct net *net, int ip_tnl_net_id,
                                   struct rtnl_link_ops *ops, char *devname)
 {
diff --git a/net/ipv4/ip_vti.c b/net/ipv4/ip_vti.c
index 5a6e27054f0a..9f7269f3c54a 100644
--- a/net/ipv4/ip_vti.c
+++ b/net/ipv4/ip_vti.c
@@ -60,7 +60,7 @@ static int vti_input(struct sk_buff *skb, int nexthdr, __be32 spi,
 
         tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY,
                                   iph->saddr, iph->daddr, 0);
-        if (tunnel != NULL) {
+        if (tunnel) {
                 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
                         goto drop;
 
@@ -341,6 +341,7 @@ static const struct net_device_ops vti_netdev_ops = {
         .ndo_do_ioctl   = vti_tunnel_ioctl,
         .ndo_change_mtu = ip_tunnel_change_mtu,
         .ndo_get_stats64 = ip_tunnel_get_stats64,
+        .ndo_get_iflink = ip_tunnel_get_iflink,
 };
 
 static void vti_tunnel_setup(struct net_device *dev)
@@ -361,7 +362,6 @@ static int vti_tunnel_init(struct net_device *dev)
         dev->hard_header_len    = LL_MAX_HEADER + sizeof(struct iphdr);
         dev->mtu                = ETH_DATA_LEN;
         dev->flags              = IFF_NOARP;
-        dev->iflink             = 0;
         dev->addr_len           = 4;
         dev->features           |= NETIF_F_LLTX;
         netif_keep_dst(dev);
diff --git a/net/ipv4/ipcomp.c b/net/ipv4/ipcomp.c
index c0855d50a3fa..d97f4f2787f5 100644
--- a/net/ipv4/ipcomp.c
+++ b/net/ipv4/ipcomp.c
@@ -63,7 +63,7 @@ static struct xfrm_state *ipcomp_tunnel_create(struct xfrm_state *x)
         struct xfrm_state *t;
 
         t = xfrm_state_alloc(net);
-        if (t == NULL)
+        if (!t)
                 goto out;
 
         t->id.proto = IPPROTO_IPIP;
diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c
index b26376ef87f6..8e7328c6a390 100644
--- a/net/ipv4/ipconfig.c
+++ b/net/ipv4/ipconfig.c
@@ -504,7 +504,8 @@ ic_rarp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt
         if (!net_eq(dev_net(dev), &init_net))
                 goto drop;
 
-        if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
+        skb = skb_share_check(skb, GFP_ATOMIC);
+        if (!skb)
                 return NET_RX_DROP;
 
         if (!pskb_may_pull(skb, sizeof(struct arphdr)))
@@ -958,7 +959,8 @@ static int __init ic_bootp_recv(struct sk_buff *skb, struct net_device *dev, str
         if (skb->pkt_type == PACKET_OTHERHOST)
                 goto drop;
 
-        if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
+        skb = skb_share_check(skb, GFP_ATOMIC);
+        if (!skb)
                 return NET_RX_DROP;
 
         if (!pskb_may_pull(skb,
diff --git a/net/ipv4/ipip.c b/net/ipv4/ipip.c
index bfbcc85c02ee..ff96396ebec5 100644
--- a/net/ipv4/ipip.c
+++ b/net/ipv4/ipip.c
@@ -144,7 +144,7 @@ static int ipip_err(struct sk_buff *skb, u32 info)
         err = -ENOENT;
         t = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY,
                              iph->daddr, iph->saddr, 0);
-        if (t == NULL)
+        if (!t)
                 goto out;
 
         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
@@ -272,6 +272,7 @@ static const struct net_device_ops ipip_netdev_ops = {
         .ndo_do_ioctl   = ipip_tunnel_ioctl,
         .ndo_change_mtu = ip_tunnel_change_mtu,
         .ndo_get_stats64 = ip_tunnel_get_stats64,
+        .ndo_get_iflink = ip_tunnel_get_iflink,
 };
 
 #define IPIP_FEATURES (NETIF_F_SG |             \
@@ -286,7 +287,6 @@ static void ipip_tunnel_setup(struct net_device *dev)
 
         dev->type               = ARPHRD_TUNNEL;
         dev->flags              = IFF_NOARP;
-        dev->iflink             = 0;
         dev->addr_len           = 4;
         dev->features           |= NETIF_F_LLTX;
         netif_keep_dst(dev);
diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index b4a545d24adb..3a2c0162c3ba 100644
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -189,7 +189,7 @@ static int ipmr_rule_action(struct fib_rule *rule, struct flowi *flp,
         }
 
         mrt = ipmr_get_table(rule->fr_net, rule->table);
-        if (mrt == NULL)
+        if (!mrt)
                 return -EAGAIN;
         res->mrt = mrt;
         return 0;
@@ -253,7 +253,7 @@ static int __net_init ipmr_rules_init(struct net *net)
         INIT_LIST_HEAD(&net->ipv4.mr_tables);
 
         mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
-        if (mrt == NULL) {
+        if (!mrt) {
                 err = -ENOMEM;
                 goto err1;
         }
@@ -266,7 +266,7 @@ static int __net_init ipmr_rules_init(struct net *net)
         return 0;
 
 err2:
-        kfree(mrt);
+        ipmr_free_table(mrt);
 err1:
         fib_rules_unregister(ops);
         return err;
@@ -276,11 +276,13 @@ static void __net_exit ipmr_rules_exit(struct net *net)
 {
         struct mr_table *mrt, *next;
 
+        rtnl_lock();
         list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
                 list_del(&mrt->list);
                 ipmr_free_table(mrt);
         }
         fib_rules_unregister(net->ipv4.mr_rules_ops);
+        rtnl_unlock();
 }
 #else
 #define ipmr_for_each_table(mrt, net) \
@@ -306,7 +308,10 @@ static int __net_init ipmr_rules_init(struct net *net)
 
 static void __net_exit ipmr_rules_exit(struct net *net)
 {
+        rtnl_lock();
         ipmr_free_table(net->ipv4.mrt);
+        net->ipv4.mrt = NULL;
+        rtnl_unlock();
 }
 #endif
 
@@ -316,11 +321,11 @@ static struct mr_table *ipmr_new_table(struct net *net, u32 id)
         unsigned int i;
 
         mrt = ipmr_get_table(net, id);
-        if (mrt != NULL)
+        if (mrt)
                 return mrt;
 
         mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
-        if (mrt == NULL)
+        if (!mrt)
                 return NULL;
         write_pnet(&mrt->net, net);
         mrt->id = id;
@@ -422,7 +427,7 @@ struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
                         dev->flags |= IFF_MULTICAST;
 
                         in_dev = __in_dev_get_rtnl(dev);
-                        if (in_dev == NULL)
+                        if (!in_dev)
                                 goto failure;
 
                         ipv4_devconf_setall(in_dev);
@@ -473,8 +478,14 @@ static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
         return NETDEV_TX_OK;
 }
 
+static int reg_vif_get_iflink(const struct net_device *dev)
+{
+        return 0;
+}
+
 static const struct net_device_ops reg_vif_netdev_ops = {
         .ndo_start_xmit = reg_vif_xmit,
+        .ndo_get_iflink = reg_vif_get_iflink,
 };
 
 static void reg_vif_setup(struct net_device *dev)
@@ -500,7 +511,7 @@ static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
 
         dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
 
-        if (dev == NULL)
+        if (!dev)
                 return NULL;
 
         dev_net_set(dev, net);
@@ -509,7 +520,6 @@ static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
                 free_netdev(dev);
                 return NULL;
         }
-        dev->iflink = 0;
 
         rcu_read_lock();
         in_dev = __in_dev_get_rcu(dev);
@@ -757,7 +767,7 @@ static int vif_add(struct net *net, struct mr_table *mrt,
         case 0:
                 if (vifc->vifc_flags == VIFF_USE_IFINDEX) {
                         dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex);
-                        if (dev && __in_dev_get_rtnl(dev) == NULL) {
+                        if (dev && !__in_dev_get_rtnl(dev)) {
                                 dev_put(dev);
                                 return -EADDRNOTAVAIL;
                         }
@@ -801,7 +811,7 @@ static int vif_add(struct net *net, struct mr_table *mrt,
         v->pkt_out = 0;
         v->link = dev->ifindex;
         if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER))
-                v->link = dev->iflink;
+                v->link = dev_get_iflink(dev);
 
         /* And finish update writing critical data */
         write_lock_bh(&mrt_lock);
@@ -1003,7 +1013,7 @@ static int ipmr_cache_report(struct mr_table *mrt,
 
         rcu_read_lock();
         mroute_sk = rcu_dereference(mrt->mroute_sk);
-        if (mroute_sk == NULL) {
+        if (!mroute_sk) {
                 rcu_read_unlock();
                 kfree_skb(skb);
                 return -EINVAL;
@@ -1156,7 +1166,7 @@ static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
                 return -EINVAL;
 
         c = ipmr_cache_alloc();
-        if (c == NULL)
+        if (!c)
                 return -ENOMEM;
 
         c->mfc_origin = mfc->mfcc_origin.s_addr;
@@ -1278,7 +1288,7 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
                 return -EOPNOTSUPP;
 
         mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
-        if (mrt == NULL)
+        if (!mrt)
                 return -ENOENT;
 
         if (optname != MRT_INIT) {
@@ -1441,7 +1451,7 @@ int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int
                 return -EOPNOTSUPP;
 
         mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
-        if (mrt == NULL)
+        if (!mrt)
                 return -ENOENT;
 
         if (optname != MRT_VERSION &&
@@ -1487,7 +1497,7 @@ int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
         struct mr_table *mrt;
 
         mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
-        if (mrt == NULL)
+        if (!mrt)
                 return -ENOENT;
 
         switch (cmd) {
@@ -1561,7 +1571,7 @@ int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
         struct mr_table *mrt;
 
         mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
-        if (mrt == NULL)
+        if (!mrt)
                 return -ENOENT;
 
         switch (cmd) {
@@ -1669,7 +1679,7 @@ static void ip_encap(struct net *net, struct sk_buff *skb,
         nf_reset(skb);
 }
 
-static inline int ipmr_forward_finish(struct sk_buff *skb)
+static inline int ipmr_forward_finish(struct sock *sk, struct sk_buff *skb)
 {
         struct ip_options *opt = &(IPCB(skb)->opt);
 
@@ -1679,7 +1689,7 @@ static inline int ipmr_forward_finish(struct sk_buff *skb)
         if (unlikely(opt->optlen))
                 ip_forward_options(skb);
 
-        return dst_output(skb);
+        return dst_output_sk(sk, skb);
 }
 
 /*
@@ -1696,7 +1706,7 @@ static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
         struct flowi4 fl4;
         int    encap = 0;
 
-        if (vif->dev == NULL)
+        if (!vif->dev)
                 goto out_free;
 
 #ifdef CONFIG_IP_PIMSM
@@ -1778,7 +1788,8 @@ static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
          * not mrouter) cannot join to more than one interface - it will
          * result in receiving multiple packets.
          */
-        NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, skb, skb->dev, dev,
+        NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, NULL, skb,
+                skb->dev, dev,
                 ipmr_forward_finish);
         return;
 
@@ -1987,7 +1998,7 @@ int ip_mr_input(struct sk_buff *skb)
 
         /* already under rcu_read_lock() */
         cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
-        if (cache == NULL) {
+        if (!cache) {
                 int vif = ipmr_find_vif(mrt, skb->dev);
 
                 if (vif >= 0)
@@ -1998,13 +2009,13 @@ int ip_mr_input(struct sk_buff *skb)
         /*
          *      No usable cache entry
          */
-        if (cache == NULL) {
+        if (!cache) {
                 int vif;
 
                 if (local) {
                         struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
                         ip_local_deliver(skb);
-                        if (skb2 == NULL)
+                        if (!skb2)
                                 return -ENOBUFS;
                         skb = skb2;
                 }
@@ -2063,7 +2074,7 @@ static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
                 reg_dev = mrt->vif_table[mrt->mroute_reg_vif_num].dev;
         read_unlock(&mrt_lock);
 
-        if (reg_dev == NULL)
+        if (!reg_dev)
                 return 1;
 
         skb->mac_header = skb->network_header;
@@ -2193,18 +2204,18 @@ int ipmr_get_route(struct net *net, struct sk_buff *skb,
         int err;
 
         mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
-        if (mrt == NULL)
+        if (!mrt)
                 return -ENOENT;
 
         rcu_read_lock();
         cache = ipmr_cache_find(mrt, saddr, daddr);
-        if (cache == NULL && skb->dev) {
+        if (!cache && skb->dev) {
                 int vif = ipmr_find_vif(mrt, skb->dev);
 
                 if (vif >= 0)
                         cache = ipmr_cache_find_any(mrt, daddr, vif);
         }
-        if (cache == NULL) {
+        if (!cache) {
                 struct sk_buff *skb2;
                 struct iphdr *iph;
                 struct net_device *dev;
@@ -2262,7 +2273,7 @@ static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
         int err;
 
         nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
-        if (nlh == NULL)
+        if (!nlh)
                 return -EMSGSIZE;
 
         rtm = nlmsg_data(nlh);
@@ -2327,7 +2338,7 @@ static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
 
         skb = nlmsg_new(mroute_msgsize(mfc->mfc_parent >= MAXVIFS, mrt->maxvif),
                         GFP_ATOMIC);
-        if (skb == NULL)
+        if (!skb)
                 goto errout;
 
         err = ipmr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
@@ -2442,7 +2453,7 @@ static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
         struct mr_table *mrt;
 
         mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
-        if (mrt == NULL)
+        if (!mrt)
                 return ERR_PTR(-ENOENT);
 
         iter->mrt = mrt;
@@ -2561,7 +2572,7 @@ static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
         struct mr_table *mrt;
 
         mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
-        if (mrt == NULL)
+        if (!mrt)
                 return ERR_PTR(-ENOENT);
 
         it->mrt = mrt;
diff --git a/net/ipv4/netfilter.c b/net/ipv4/netfilter.c
index 7ebd6e37875c..65de0684e22a 100644
--- a/net/ipv4/netfilter.c
+++ b/net/ipv4/netfilter.c
@@ -94,7 +94,7 @@ static void nf_ip_saveroute(const struct sk_buff *skb,
 {
         struct ip_rt_info *rt_info = nf_queue_entry_reroute(entry);
 
-        if (entry->hook == NF_INET_LOCAL_OUT) {
+        if (entry->state.hook == NF_INET_LOCAL_OUT) {
                 const struct iphdr *iph = ip_hdr(skb);
 
                 rt_info->tos = iph->tos;
@@ -109,7 +109,7 @@ static int nf_ip_reroute(struct sk_buff *skb,
 {
         const struct ip_rt_info *rt_info = nf_queue_entry_reroute(entry);
 
-        if (entry->hook == NF_INET_LOCAL_OUT) {
+        if (entry->state.hook == NF_INET_LOCAL_OUT) {
                 const struct iphdr *iph = ip_hdr(skb);
 
                 if (!(iph->tos == rt_info->tos &&
diff --git a/net/ipv4/netfilter/arp_tables.c b/net/ipv4/netfilter/arp_tables.c
index f95b6f93814b..13bfe84bf3ca 100644
--- a/net/ipv4/netfilter/arp_tables.c
+++ b/net/ipv4/netfilter/arp_tables.c
@@ -248,8 +248,7 @@ struct arpt_entry *arpt_next_entry(const struct arpt_entry *entry)
 
 unsigned int arpt_do_table(struct sk_buff *skb,
                            unsigned int hook,
-                           const struct net_device *in,
-                           const struct net_device *out,
+                           const struct nf_hook_state *state,
                            struct xt_table *table)
 {
         static const char nulldevname[IFNAMSIZ] __attribute__((aligned(sizeof(long))));
@@ -265,8 +264,8 @@ unsigned int arpt_do_table(struct sk_buff *skb,
         if (!pskb_may_pull(skb, arp_hdr_len(skb->dev)))
                 return NF_DROP;
 
-        indev = in ? in->name : nulldevname;
-        outdev = out ? out->name : nulldevname;
+        indev = state->in ? state->in->name : nulldevname;
+        outdev = state->out ? state->out->name : nulldevname;
 
         local_bh_disable();
         addend = xt_write_recseq_begin();
@@ -281,8 +280,8 @@ unsigned int arpt_do_table(struct sk_buff *skb,
         e = get_entry(table_base, private->hook_entry[hook]);
         back = get_entry(table_base, private->underflow[hook]);
 
-        acpar.in      = in;
-        acpar.out     = out;
+        acpar.in      = state->in;
+        acpar.out     = state->out;
         acpar.hooknum = hook;
         acpar.family  = NFPROTO_ARP;
         acpar.hotdrop = false;
diff --git a/net/ipv4/netfilter/arptable_filter.c b/net/ipv4/netfilter/arptable_filter.c
index 802ddecb30b8..93876d03120c 100644
--- a/net/ipv4/netfilter/arptable_filter.c
+++ b/net/ipv4/netfilter/arptable_filter.c
@@ -28,12 +28,11 @@ static const struct xt_table packet_filter = {
 /* The work comes in here from netfilter.c */
 static unsigned int
 arptable_filter_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                     const struct net_device *in, const struct net_device *out,
-                     int (*okfn)(struct sk_buff *))
+                     const struct nf_hook_state *state)
 {
-        const struct net *net = dev_net((in != NULL) ? in : out);
+        const struct net *net = dev_net(state->in ? state->in : state->out);
 
-        return arpt_do_table(skb, ops->hooknum, in, out,
+        return arpt_do_table(skb, ops->hooknum, state,
                              net->ipv4.arptable_filter);
 }
 
diff --git a/net/ipv4/netfilter/ip_tables.c b/net/ipv4/netfilter/ip_tables.c
index cf5e82f39d3b..c69db7fa25ee 100644
--- a/net/ipv4/netfilter/ip_tables.c
+++ b/net/ipv4/netfilter/ip_tables.c
@@ -288,8 +288,7 @@ struct ipt_entry *ipt_next_entry(const struct ipt_entry *entry)
 unsigned int
 ipt_do_table(struct sk_buff *skb,
              unsigned int hook,
-             const struct net_device *in,
-             const struct net_device *out,
+             const struct nf_hook_state *state,
              struct xt_table *table)
 {
         static const char nulldevname[IFNAMSIZ] __attribute__((aligned(sizeof(long))));
@@ -306,8 +305,8 @@ ipt_do_table(struct sk_buff *skb,
 
         /* Initialization */
         ip = ip_hdr(skb);
-        indev = in ? in->name : nulldevname;
-        outdev = out ? out->name : nulldevname;
+        indev = state->in ? state->in->name : nulldevname;
+        outdev = state->out ? state->out->name : nulldevname;
         /* We handle fragments by dealing with the first fragment as
          * if it was a normal packet.  All other fragments are treated
          * normally, except that they will NEVER match rules that ask
@@ -317,8 +316,8 @@ ipt_do_table(struct sk_buff *skb,
         acpar.fragoff = ntohs(ip->frag_off) & IP_OFFSET;
         acpar.thoff   = ip_hdrlen(skb);
         acpar.hotdrop = false;
-        acpar.in      = in;
-        acpar.out     = out;
+        acpar.in      = state->in;
+        acpar.out     = state->out;
         acpar.family  = NFPROTO_IPV4;
         acpar.hooknum = hook;
 
@@ -370,7 +369,7 @@ ipt_do_table(struct sk_buff *skb,
 #if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE)
                 /* The packet is traced: log it */
                 if (unlikely(skb->nf_trace))
-                        trace_packet(skb, hook, in, out,
+                        trace_packet(skb, hook, state->in, state->out,
                                      table->name, private, e);
 #endif
                 /* Standard target? */
diff --git a/net/ipv4/netfilter/ipt_CLUSTERIP.c b/net/ipv4/netfilter/ipt_CLUSTERIP.c
index f75e9df5e017..771ab3d01ad3 100644
--- a/net/ipv4/netfilter/ipt_CLUSTERIP.c
+++ b/net/ipv4/netfilter/ipt_CLUSTERIP.c
@@ -504,14 +504,12 @@ static void arp_print(struct arp_payload *payload)
 static unsigned int
 arp_mangle(const struct nf_hook_ops *ops,
            struct sk_buff *skb,
-           const struct net_device *in,
-           const struct net_device *out,
-           int (*okfn)(struct sk_buff *))
+           const struct nf_hook_state *state)
 {
         struct arphdr *arp = arp_hdr(skb);
         struct arp_payload *payload;
         struct clusterip_config *c;
-        struct net *net = dev_net(in ? in : out);
+        struct net *net = dev_net(state->in ? state->in : state->out);
 
         /* we don't care about non-ethernet and non-ipv4 ARP */
         if (arp->ar_hrd != htons(ARPHRD_ETHER) ||
@@ -536,10 +534,10 @@ arp_mangle(const struct nf_hook_ops *ops,
          * addresses on different interfacs.  However, in the CLUSTERIP case
          * this wouldn't work, since we didn't subscribe the mcast group on
          * other interfaces */
-        if (c->dev != out) {
+        if (c->dev != state->out) {
                 pr_debug("not mangling arp reply on different "
                          "interface: cip'%s'-skb'%s'\n",
-                         c->dev->name, out->name);
+                         c->dev->name, state->out->name);
                 clusterip_config_put(c);
                 return NF_ACCEPT;
         }
diff --git a/net/ipv4/netfilter/ipt_SYNPROXY.c b/net/ipv4/netfilter/ipt_SYNPROXY.c
index a313c3fbeb46..e9e67793055f 100644
--- a/net/ipv4/netfilter/ipt_SYNPROXY.c
+++ b/net/ipv4/netfilter/ipt_SYNPROXY.c
@@ -300,11 +300,9 @@ synproxy_tg4(struct sk_buff *skb, const struct xt_action_param *par)
 
 static unsigned int ipv4_synproxy_hook(const struct nf_hook_ops *ops,
                                        struct sk_buff *skb,
-                                       const struct net_device *in,
-                                       const struct net_device *out,
-                                       int (*okfn)(struct sk_buff *))
+                                       const struct nf_hook_state *nhs)
 {
-        struct synproxy_net *snet = synproxy_pernet(dev_net(in ? : out));
+        struct synproxy_net *snet = synproxy_pernet(dev_net(nhs->in ? : nhs->out));
         enum ip_conntrack_info ctinfo;
         struct nf_conn *ct;
         struct nf_conn_synproxy *synproxy;
diff --git a/net/ipv4/netfilter/iptable_filter.c b/net/ipv4/netfilter/iptable_filter.c
index e08a74a243a8..a0f3beca52d2 100644
--- a/net/ipv4/netfilter/iptable_filter.c
+++ b/net/ipv4/netfilter/iptable_filter.c
@@ -34,8 +34,7 @@ static const struct xt_table packet_filter = {
 
 static unsigned int
 iptable_filter_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                    const struct net_device *in, const struct net_device *out,
-                    int (*okfn)(struct sk_buff *))
+                    const struct nf_hook_state *state)
 {
         const struct net *net;
 
@@ -45,9 +44,8 @@ iptable_filter_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
                 /* root is playing with raw sockets. */
                 return NF_ACCEPT;
 
-        net = dev_net((in != NULL) ? in : out);
-        return ipt_do_table(skb, ops->hooknum, in, out,
-                            net->ipv4.iptable_filter);
+        net = dev_net(state->in ? state->in : state->out);
+        return ipt_do_table(skb, ops->hooknum, state, net->ipv4.iptable_filter);
 }
 
 static struct nf_hook_ops *filter_ops __read_mostly;
diff --git a/net/ipv4/netfilter/iptable_mangle.c b/net/ipv4/netfilter/iptable_mangle.c
index 6a5079c34bb3..62cbb8c5f4a8 100644
--- a/net/ipv4/netfilter/iptable_mangle.c
+++ b/net/ipv4/netfilter/iptable_mangle.c
@@ -37,8 +37,9 @@ static const struct xt_table packet_mangler = {
 };
 
 static unsigned int
-ipt_mangle_out(struct sk_buff *skb, const struct net_device *out)
+ipt_mangle_out(struct sk_buff *skb, const struct nf_hook_state *state)
 {
+        struct net_device *out = state->out;
         unsigned int ret;
         const struct iphdr *iph;
         u_int8_t tos;
@@ -58,7 +59,7 @@ ipt_mangle_out(struct sk_buff *skb, const struct net_device *out)
         daddr = iph->daddr;
         tos = iph->tos;
 
-        ret = ipt_do_table(skb, NF_INET_LOCAL_OUT, NULL, out,
+        ret = ipt_do_table(skb, NF_INET_LOCAL_OUT, state,
                            dev_net(out)->ipv4.iptable_mangle);
         /* Reroute for ANY change. */
         if (ret != NF_DROP && ret != NF_STOLEN) {
@@ -81,18 +82,16 @@ ipt_mangle_out(struct sk_buff *skb, const struct net_device *out)
 static unsigned int
 iptable_mangle_hook(const struct nf_hook_ops *ops,
                      struct sk_buff *skb,
-                     const struct net_device *in,
-                     const struct net_device *out,
-                     int (*okfn)(struct sk_buff *))
+                     const struct nf_hook_state *state)
 {
         if (ops->hooknum == NF_INET_LOCAL_OUT)
-                return ipt_mangle_out(skb, out);
+                return ipt_mangle_out(skb, state);
         if (ops->hooknum == NF_INET_POST_ROUTING)
-                return ipt_do_table(skb, ops->hooknum, in, out,
-                                    dev_net(out)->ipv4.iptable_mangle);
+                return ipt_do_table(skb, ops->hooknum, state,
+                                    dev_net(state->out)->ipv4.iptable_mangle);
         /* PREROUTING/INPUT/FORWARD: */
-        return ipt_do_table(skb, ops->hooknum, in, out,
-                            dev_net(in)->ipv4.iptable_mangle);
+        return ipt_do_table(skb, ops->hooknum, state,
+                            dev_net(state->in)->ipv4.iptable_mangle);
 }
 
 static struct nf_hook_ops *mangle_ops __read_mostly;
diff --git a/net/ipv4/netfilter/iptable_nat.c b/net/ipv4/netfilter/iptable_nat.c
index 6b67d7e9a75d..0d4d9cdf98a4 100644
--- a/net/ipv4/netfilter/iptable_nat.c
+++ b/net/ipv4/netfilter/iptable_nat.c
@@ -30,49 +30,40 @@ static const struct xt_table nf_nat_ipv4_table = {
 
 static unsigned int iptable_nat_do_chain(const struct nf_hook_ops *ops,
                                          struct sk_buff *skb,
-                                         const struct net_device *in,
-                                         const struct net_device *out,
+                                         const struct nf_hook_state *state,
                                          struct nf_conn *ct)
 {
         struct net *net = nf_ct_net(ct);
 
-        return ipt_do_table(skb, ops->hooknum, in, out, net->ipv4.nat_table);
+        return ipt_do_table(skb, ops->hooknum, state, net->ipv4.nat_table);
 }
 
 static unsigned int iptable_nat_ipv4_fn(const struct nf_hook_ops *ops,
                                         struct sk_buff *skb,
-                                        const struct net_device *in,
-                                        const struct net_device *out,
-                                        int (*okfn)(struct sk_buff *))
+                                        const struct nf_hook_state *state)
 {
-        return nf_nat_ipv4_fn(ops, skb, in, out, iptable_nat_do_chain);
+        return nf_nat_ipv4_fn(ops, skb, state, iptable_nat_do_chain);
 }
 
 static unsigned int iptable_nat_ipv4_in(const struct nf_hook_ops *ops,
                                         struct sk_buff *skb,
-                                        const struct net_device *in,
-                                        const struct net_device *out,
-                                        int (*okfn)(struct sk_buff *))
+                                        const struct nf_hook_state *state)
 {
-        return nf_nat_ipv4_in(ops, skb, in, out, iptable_nat_do_chain);
+        return nf_nat_ipv4_in(ops, skb, state, iptable_nat_do_chain);
 }
 
 static unsigned int iptable_nat_ipv4_out(const struct nf_hook_ops *ops,
                                          struct sk_buff *skb,
-                                         const struct net_device *in,
-                                         const struct net_device *out,
-                                         int (*okfn)(struct sk_buff *))
+                                         const struct nf_hook_state *state)
 {
-        return nf_nat_ipv4_out(ops, skb, in, out, iptable_nat_do_chain);
+        return nf_nat_ipv4_out(ops, skb, state, iptable_nat_do_chain);
 }
 
 static unsigned int iptable_nat_ipv4_local_fn(const struct nf_hook_ops *ops,
                                               struct sk_buff *skb,
-                                              const struct net_device *in,
-                                              const struct net_device *out,
-                                              int (*okfn)(struct sk_buff *))
+                                              const struct nf_hook_state *state)
 {
-        return nf_nat_ipv4_local_fn(ops, skb, in, out, iptable_nat_do_chain);
+        return nf_nat_ipv4_local_fn(ops, skb, state, iptable_nat_do_chain);
 }
 
 static struct nf_hook_ops nf_nat_ipv4_ops[] __read_mostly = {
diff --git a/net/ipv4/netfilter/iptable_raw.c b/net/ipv4/netfilter/iptable_raw.c
index b2f7e8f98316..0356e6da4bb7 100644
--- a/net/ipv4/netfilter/iptable_raw.c
+++ b/net/ipv4/netfilter/iptable_raw.c
@@ -21,8 +21,7 @@ static const struct xt_table packet_raw = {
 /* The work comes in here from netfilter.c. */
 static unsigned int
 iptable_raw_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                 const struct net_device *in, const struct net_device *out,
-                 int (*okfn)(struct sk_buff *))
+                 const struct nf_hook_state *state)
 {
         const struct net *net;
 
@@ -32,8 +31,8 @@ iptable_raw_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
                 /* root is playing with raw sockets. */
                 return NF_ACCEPT;
 
-        net = dev_net((in != NULL) ? in : out);
-        return ipt_do_table(skb, ops->hooknum, in, out, net->ipv4.iptable_raw);
+        net = dev_net(state->in ? state->in : state->out);
+        return ipt_do_table(skb, ops->hooknum, state, net->ipv4.iptable_raw);
 }
 
 static struct nf_hook_ops *rawtable_ops __read_mostly;
diff --git a/net/ipv4/netfilter/iptable_security.c b/net/ipv4/netfilter/iptable_security.c
index c86647ed2078..4bce3980ccd9 100644
--- a/net/ipv4/netfilter/iptable_security.c
+++ b/net/ipv4/netfilter/iptable_security.c
@@ -38,9 +38,7 @@ static const struct xt_table security_table = {
 
 static unsigned int
 iptable_security_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                      const struct net_device *in,
-                      const struct net_device *out,
-                      int (*okfn)(struct sk_buff *))
+                      const struct nf_hook_state *state)
 {
         const struct net *net;
 
@@ -50,8 +48,8 @@ iptable_security_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
                 /* Somebody is playing with raw sockets. */
                 return NF_ACCEPT;
 
-        net = dev_net((in != NULL) ? in : out);
-        return ipt_do_table(skb, ops->hooknum, in, out,
+        net = dev_net(state->in ? state->in : state->out);
+        return ipt_do_table(skb, ops->hooknum, state,
                             net->ipv4.iptable_security);
 }
 
diff --git a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
index 8c8d6642cbb0..30ad9554b5e9 100644
--- a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
+++ b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
@@ -94,9 +94,7 @@ static int ipv4_get_l4proto(const struct sk_buff *skb, unsigned int nhoff,
 
 static unsigned int ipv4_helper(const struct nf_hook_ops *ops,
                                 struct sk_buff *skb,
-                                const struct net_device *in,
-                                const struct net_device *out,
-                                int (*okfn)(struct sk_buff *))
+                                const struct nf_hook_state *state)
 {
         struct nf_conn *ct;
         enum ip_conntrack_info ctinfo;
@@ -123,9 +121,7 @@ static unsigned int ipv4_helper(const struct nf_hook_ops *ops,
 
 static unsigned int ipv4_confirm(const struct nf_hook_ops *ops,
                                  struct sk_buff *skb,
-                                 const struct net_device *in,
-                                 const struct net_device *out,
-                                 int (*okfn)(struct sk_buff *))
+                                 const struct nf_hook_state *state)
 {
         struct nf_conn *ct;
         enum ip_conntrack_info ctinfo;
@@ -149,24 +145,20 @@ out:
 
 static unsigned int ipv4_conntrack_in(const struct nf_hook_ops *ops,
                                       struct sk_buff *skb,
-                                      const struct net_device *in,
-                                      const struct net_device *out,
-                                      int (*okfn)(struct sk_buff *))
+                                      const struct nf_hook_state *state)
 {
-        return nf_conntrack_in(dev_net(in), PF_INET, ops->hooknum, skb);
+        return nf_conntrack_in(dev_net(state->in), PF_INET, ops->hooknum, skb);
 }
 
 static unsigned int ipv4_conntrack_local(const struct nf_hook_ops *ops,
                                          struct sk_buff *skb,
-                                         const struct net_device *in,
-                                         const struct net_device *out,
-                                         int (*okfn)(struct sk_buff *))
+                                         const struct nf_hook_state *state)
 {
         /* root is playing with raw sockets. */
         if (skb->len < sizeof(struct iphdr) ||
             ip_hdrlen(skb) < sizeof(struct iphdr))
                 return NF_ACCEPT;
-        return nf_conntrack_in(dev_net(out), PF_INET, ops->hooknum, skb);
+        return nf_conntrack_in(dev_net(state->out), PF_INET, ops->hooknum, skb);
 }
 
 /* Connection tracking may drop packets, but never alters them, so
diff --git a/net/ipv4/netfilter/nf_defrag_ipv4.c b/net/ipv4/netfilter/nf_defrag_ipv4.c
index 7e5ca6f2d0cd..c88b7d434718 100644
--- a/net/ipv4/netfilter/nf_defrag_ipv4.c
+++ b/net/ipv4/netfilter/nf_defrag_ipv4.c
@@ -63,9 +63,7 @@ static enum ip_defrag_users nf_ct_defrag_user(unsigned int hooknum,
 
 static unsigned int ipv4_conntrack_defrag(const struct nf_hook_ops *ops,
                                           struct sk_buff *skb,
-                                          const struct net_device *in,
-                                          const struct net_device *out,
-                                          int (*okfn)(struct sk_buff *))
+                                          const struct nf_hook_state *state)
 {
         struct sock *sk = skb->sk;
         struct inet_sock *inet = inet_sk(skb->sk);
diff --git a/net/ipv4/netfilter/nf_nat_l3proto_ipv4.c b/net/ipv4/netfilter/nf_nat_l3proto_ipv4.c
index fc37711e11f3..e59cc05c09e9 100644
--- a/net/ipv4/netfilter/nf_nat_l3proto_ipv4.c
+++ b/net/ipv4/netfilter/nf_nat_l3proto_ipv4.c
@@ -256,11 +256,10 @@ EXPORT_SYMBOL_GPL(nf_nat_icmp_reply_translation);
 
 unsigned int
 nf_nat_ipv4_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
-               const struct net_device *in, const struct net_device *out,
+               const struct nf_hook_state *state,
                unsigned int (*do_chain)(const struct nf_hook_ops *ops,
                                         struct sk_buff *skb,
-                                        const struct net_device *in,
-                                        const struct net_device *out,
+                                        const struct nf_hook_state *state,
                                         struct nf_conn *ct))
 {
         struct nf_conn *ct;
@@ -309,7 +308,7 @@ nf_nat_ipv4_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
                 if (!nf_nat_initialized(ct, maniptype)) {
                         unsigned int ret;
 
-                        ret = do_chain(ops, skb, in, out, ct);
+                        ret = do_chain(ops, skb, state, ct);
                         if (ret != NF_ACCEPT)
                                 return ret;
 
@@ -323,7 +322,8 @@ nf_nat_ipv4_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
                         pr_debug("Already setup manip %s for ct %p\n",
                                  maniptype == NF_NAT_MANIP_SRC ? "SRC" : "DST",
                                  ct);
-                        if (nf_nat_oif_changed(ops->hooknum, ctinfo, nat, out))
+                        if (nf_nat_oif_changed(ops->hooknum, ctinfo, nat,
+                                               state->out))
                                 goto oif_changed;
                 }
                 break;
@@ -332,7 +332,7 @@ nf_nat_ipv4_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
                 /* ESTABLISHED */
                 NF_CT_ASSERT(ctinfo == IP_CT_ESTABLISHED ||
                              ctinfo == IP_CT_ESTABLISHED_REPLY);
-                if (nf_nat_oif_changed(ops->hooknum, ctinfo, nat, out))
+                if (nf_nat_oif_changed(ops->hooknum, ctinfo, nat, state->out))
                         goto oif_changed;
         }
 
@@ -346,17 +346,16 @@ EXPORT_SYMBOL_GPL(nf_nat_ipv4_fn);
 
 unsigned int
 nf_nat_ipv4_in(const struct nf_hook_ops *ops, struct sk_buff *skb,
-               const struct net_device *in, const struct net_device *out,
+               const struct nf_hook_state *state,
                unsigned int (*do_chain)(const struct nf_hook_ops *ops,
                                          struct sk_buff *skb,
-                                         const struct net_device *in,
-                                         const struct net_device *out,
+                                         const struct nf_hook_state *state,
                                          struct nf_conn *ct))
 {
         unsigned int ret;
         __be32 daddr = ip_hdr(skb)->daddr;
 
-        ret = nf_nat_ipv4_fn(ops, skb, in, out, do_chain);
+        ret = nf_nat_ipv4_fn(ops, skb, state, do_chain);
         if (ret != NF_DROP && ret != NF_STOLEN &&
             daddr != ip_hdr(skb)->daddr)
                 skb_dst_drop(skb);
@@ -367,11 +366,10 @@ EXPORT_SYMBOL_GPL(nf_nat_ipv4_in);
 
 unsigned int
 nf_nat_ipv4_out(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                const struct net_device *in, const struct net_device *out,
+                const struct nf_hook_state *state,
                 unsigned int (*do_chain)(const struct nf_hook_ops *ops,
                                           struct sk_buff *skb,
-                                          const struct net_device *in,
-                                          const struct net_device *out,
+                                          const struct nf_hook_state *state,
                                           struct nf_conn *ct))
 {
 #ifdef CONFIG_XFRM
@@ -386,7 +384,7 @@ nf_nat_ipv4_out(const struct nf_hook_ops *ops, struct sk_buff *skb,
             ip_hdrlen(skb) < sizeof(struct iphdr))
                 return NF_ACCEPT;
 
-        ret = nf_nat_ipv4_fn(ops, skb, in, out, do_chain);
+        ret = nf_nat_ipv4_fn(ops, skb, state, do_chain);
 #ifdef CONFIG_XFRM
         if (ret != NF_DROP && ret != NF_STOLEN &&
             !(IPCB(skb)->flags & IPSKB_XFRM_TRANSFORMED) &&
@@ -410,11 +408,10 @@ EXPORT_SYMBOL_GPL(nf_nat_ipv4_out);
 
 unsigned int
 nf_nat_ipv4_local_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                     const struct net_device *in, const struct net_device *out,
+                     const struct nf_hook_state *state,
                      unsigned int (*do_chain)(const struct nf_hook_ops *ops,
                                                struct sk_buff *skb,
-                                               const struct net_device *in,
-                                               const struct net_device *out,
+                                               const struct nf_hook_state *state,
                                                struct nf_conn *ct))
 {
         const struct nf_conn *ct;
@@ -427,7 +424,7 @@ nf_nat_ipv4_local_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
             ip_hdrlen(skb) < sizeof(struct iphdr))
                 return NF_ACCEPT;
 
-        ret = nf_nat_ipv4_fn(ops, skb, in, out, do_chain);
+        ret = nf_nat_ipv4_fn(ops, skb, state, do_chain);
         if (ret != NF_DROP && ret != NF_STOLEN &&
             (ct = nf_ct_get(skb, &ctinfo)) != NULL) {
                 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
diff --git a/net/ipv4/netfilter/nf_tables_arp.c b/net/ipv4/netfilter/nf_tables_arp.c
index 19412a4063fb..8412268bbad1 100644
--- a/net/ipv4/netfilter/nf_tables_arp.c
+++ b/net/ipv4/netfilter/nf_tables_arp.c
@@ -17,13 +17,11 @@
 static unsigned int
 nft_do_chain_arp(const struct nf_hook_ops *ops,
                   struct sk_buff *skb,
-                  const struct net_device *in,
-                  const struct net_device *out,
-                  int (*okfn)(struct sk_buff *))
+                  const struct nf_hook_state *state)
 {
         struct nft_pktinfo pkt;
 
-        nft_set_pktinfo(&pkt, ops, skb, in, out);
+        nft_set_pktinfo(&pkt, ops, skb, state);
 
         return nft_do_chain(&pkt, ops);
 }
diff --git a/net/ipv4/netfilter/nf_tables_ipv4.c b/net/ipv4/netfilter/nf_tables_ipv4.c
index 6820c8c40842..aa180d3a69a5 100644
--- a/net/ipv4/netfilter/nf_tables_ipv4.c
+++ b/net/ipv4/netfilter/nf_tables_ipv4.c
@@ -20,22 +20,18 @@
 
 static unsigned int nft_do_chain_ipv4(const struct nf_hook_ops *ops,
                                       struct sk_buff *skb,
-                                      const struct net_device *in,
-                                      const struct net_device *out,
-                                      int (*okfn)(struct sk_buff *))
+                                      const struct nf_hook_state *state)
 {
         struct nft_pktinfo pkt;
 
-        nft_set_pktinfo_ipv4(&pkt, ops, skb, in, out);
+        nft_set_pktinfo_ipv4(&pkt, ops, skb, state);
 
         return nft_do_chain(&pkt, ops);
 }
 
 static unsigned int nft_ipv4_output(const struct nf_hook_ops *ops,
                                     struct sk_buff *skb,
-                                    const struct net_device *in,
-                                    const struct net_device *out,
-                                    int (*okfn)(struct sk_buff *))
+                                    const struct nf_hook_state *state)
 {
         if (unlikely(skb->len < sizeof(struct iphdr) ||
                      ip_hdr(skb)->ihl < sizeof(struct iphdr) / 4)) {
@@ -45,7 +41,7 @@ static unsigned int nft_ipv4_output(const struct nf_hook_ops *ops,
                 return NF_ACCEPT;
         }
 
-        return nft_do_chain_ipv4(ops, skb, in, out, okfn);
+        return nft_do_chain_ipv4(ops, skb, state);
 }
 
 struct nft_af_info nft_af_ipv4 __read_mostly = {
diff --git a/net/ipv4/netfilter/nft_chain_nat_ipv4.c b/net/ipv4/netfilter/nft_chain_nat_ipv4.c
index df547bf50078..bf5c30ae14e4 100644
--- a/net/ipv4/netfilter/nft_chain_nat_ipv4.c
+++ b/net/ipv4/netfilter/nft_chain_nat_ipv4.c
@@ -28,51 +28,42 @@
 
 static unsigned int nft_nat_do_chain(const struct nf_hook_ops *ops,
                                       struct sk_buff *skb,
-                                      const struct net_device *in,
-                                      const struct net_device *out,
+                                      const struct nf_hook_state *state,
                                       struct nf_conn *ct)
 {
         struct nft_pktinfo pkt;
 
-        nft_set_pktinfo_ipv4(&pkt, ops, skb, in, out);
+        nft_set_pktinfo_ipv4(&pkt, ops, skb, state);
 
         return nft_do_chain(&pkt, ops);
 }
 
 static unsigned int nft_nat_ipv4_fn(const struct nf_hook_ops *ops,
                                     struct sk_buff *skb,
-                                    const struct net_device *in,
-                                    const struct net_device *out,
-                                    int (*okfn)(struct sk_buff *))
+                                    const struct nf_hook_state *state)
 {
-        return nf_nat_ipv4_fn(ops, skb, in, out, nft_nat_do_chain);
+        return nf_nat_ipv4_fn(ops, skb, state, nft_nat_do_chain);
 }
 
 static unsigned int nft_nat_ipv4_in(const struct nf_hook_ops *ops,
                                     struct sk_buff *skb,
-                                    const struct net_device *in,
-                                    const struct net_device *out,
-                                    int (*okfn)(struct sk_buff *))
+                                    const struct nf_hook_state *state)
 {
-        return nf_nat_ipv4_in(ops, skb, in, out, nft_nat_do_chain);
+        return nf_nat_ipv4_in(ops, skb, state, nft_nat_do_chain);
 }
 
 static unsigned int nft_nat_ipv4_out(const struct nf_hook_ops *ops,
                                      struct sk_buff *skb,
-                                     const struct net_device *in,
-                                     const struct net_device *out,
-                                     int (*okfn)(struct sk_buff *))
+                                     const struct nf_hook_state *state)
 {
-        return nf_nat_ipv4_out(ops, skb, in, out, nft_nat_do_chain);
+        return nf_nat_ipv4_out(ops, skb, state, nft_nat_do_chain);
 }
 
 static unsigned int nft_nat_ipv4_local_fn(const struct nf_hook_ops *ops,
                                           struct sk_buff *skb,
-                                          const struct net_device *in,
-                                          const struct net_device *out,
-                                          int (*okfn)(struct sk_buff *))
+                                          const struct nf_hook_state *state)
 {
-        return nf_nat_ipv4_local_fn(ops, skb, in, out, nft_nat_do_chain);
+        return nf_nat_ipv4_local_fn(ops, skb, state, nft_nat_do_chain);
 }
 
 static const struct nf_chain_type nft_chain_nat_ipv4 = {
diff --git a/net/ipv4/netfilter/nft_chain_route_ipv4.c b/net/ipv4/netfilter/nft_chain_route_ipv4.c
index 125b66766c0a..e335b0afdaf3 100644
--- a/net/ipv4/netfilter/nft_chain_route_ipv4.c
+++ b/net/ipv4/netfilter/nft_chain_route_ipv4.c
@@ -23,9 +23,7 @@
 
 static unsigned int nf_route_table_hook(const struct nf_hook_ops *ops,
                                         struct sk_buff *skb,
-                                        const struct net_device *in,
-                                        const struct net_device *out,
-                                        int (*okfn)(struct sk_buff *))
+                                        const struct nf_hook_state *state)
 {
         unsigned int ret;
         struct nft_pktinfo pkt;
@@ -39,7 +37,7 @@ static unsigned int nf_route_table_hook(const struct nf_hook_ops *ops,
             ip_hdrlen(skb) < sizeof(struct iphdr))
                 return NF_ACCEPT;
 
-        nft_set_pktinfo_ipv4(&pkt, ops, skb, in, out);
+        nft_set_pktinfo_ipv4(&pkt, ops, skb, state);
 
         mark = skb->mark;
         iph = ip_hdr(skb);
diff --git a/net/ipv4/ping.c b/net/ipv4/ping.c
index 344e7cdfb8d4..a93f260cf24c 100644
--- a/net/ipv4/ping.c
+++ b/net/ipv4/ping.c
@@ -516,7 +516,7 @@ void ping_err(struct sk_buff *skb, int offset, u32 info)
                  ntohs(icmph->un.echo.sequence));
 
         sk = ping_lookup(net, skb, ntohs(icmph->un.echo.id));
-        if (sk == NULL) {
+        if (!sk) {
                 pr_debug("no socket, dropping\n");
                 return; /* No socket for error */
         }
@@ -971,7 +971,7 @@ bool ping_rcv(struct sk_buff *skb)
         skb_push(skb, skb->data - (u8 *)icmph);
 
         sk = ping_lookup(net, skb, ntohs(icmph->un.echo.id));
-        if (sk != NULL) {
+        if (sk) {
                 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
 
                 pr_debug("rcv on socket %p\n", sk);
diff --git a/net/ipv4/raw.c b/net/ipv4/raw.c
index 56946f47d446..c0bb648fb2f9 100644
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -293,7 +293,7 @@ void raw_icmp_error(struct sk_buff *skb, int protocol, u32 info)
 
         read_lock(&raw_v4_hashinfo.lock);
         raw_sk = sk_head(&raw_v4_hashinfo.ht[hash]);
-        if (raw_sk != NULL) {
+        if (raw_sk) {
                 iph = (const struct iphdr *)skb->data;
                 net = dev_net(skb->dev);
 
@@ -363,7 +363,7 @@ static int raw_send_hdrinc(struct sock *sk, struct flowi4 *fl4,
         skb = sock_alloc_send_skb(sk,
                                   length + hlen + tlen + 15,
                                   flags & MSG_DONTWAIT, &err);
-        if (skb == NULL)
+        if (!skb)
                 goto error;
         skb_reserve(skb, hlen);
 
@@ -412,8 +412,8 @@ static int raw_send_hdrinc(struct sock *sk, struct flowi4 *fl4,
                 icmp_out_count(net, ((struct icmphdr *)
                         skb_transport_header(skb))->type);
 
-        err = NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_OUT, skb, NULL,
-                      rt->dst.dev, dst_output);
+        err = NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_OUT, sk, skb,
+                      NULL, rt->dst.dev, dst_output_sk);
         if (err > 0)
                 err = net_xmit_errno(err);
         if (err)
@@ -872,7 +872,7 @@ static int raw_ioctl(struct sock *sk, int cmd, unsigned long arg)
 
                 spin_lock_bh(&sk->sk_receive_queue.lock);
                 skb = skb_peek(&sk->sk_receive_queue);
-                if (skb != NULL)
+                if (skb)
                         amount = skb->len;
                 spin_unlock_bh(&sk->sk_receive_queue.lock);
                 return put_user(amount, (int __user *)arg);
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index 652b92ebd7ba..a78540f28276 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -1056,7 +1056,7 @@ void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
         __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
 
         rt = (struct rtable *)odst;
-        if (odst->obsolete && odst->ops->check(odst, 0) == NULL) {
+        if (odst->obsolete && !odst->ops->check(odst, 0)) {
                 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
                 if (IS_ERR(rt))
                         goto out;
@@ -1450,7 +1450,7 @@ static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
 
         /* Primary sanity checks. */
 
-        if (in_dev == NULL)
+        if (!in_dev)
                 return -EINVAL;
 
         if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
@@ -1553,7 +1553,7 @@ static int __mkroute_input(struct sk_buff *skb,
 
         /* get a working reference to the output device */
         out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
-        if (out_dev == NULL) {
+        if (!out_dev) {
                 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
                 return -EINVAL;
         }
@@ -1591,7 +1591,7 @@ static int __mkroute_input(struct sk_buff *skb,
 
         fnhe = find_exception(&FIB_RES_NH(*res), daddr);
         if (do_cache) {
-                if (fnhe != NULL)
+                if (fnhe)
                         rth = rcu_dereference(fnhe->fnhe_rth_input);
                 else
                         rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
@@ -2054,7 +2054,7 @@ struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
                      ipv4_is_lbcast(fl4->daddr))) {
                         /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
                         dev_out = __ip_dev_find(net, fl4->saddr, false);
-                        if (dev_out == NULL)
+                        if (!dev_out)
                                 goto out;
 
                         /* Special hack: user can direct multicasts
@@ -2087,7 +2087,7 @@ struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
         if (fl4->flowi4_oif) {
                 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
                 rth = ERR_PTR(-ENODEV);
-                if (dev_out == NULL)
+                if (!dev_out)
                         goto out;
 
                 /* RACE: Check return value of inet_select_addr instead. */
@@ -2299,7 +2299,7 @@ static int rt_fill_info(struct net *net,  __be32 dst, __be32 src,
         u32 metrics[RTAX_MAX];
 
         nlh = nlmsg_put(skb, portid, seq, event, sizeof(*r), flags);
-        if (nlh == NULL)
+        if (!nlh)
                 return -EMSGSIZE;
 
         r = nlmsg_data(nlh);
@@ -2421,7 +2421,7 @@ static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
         rtm = nlmsg_data(nlh);
 
         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
-        if (skb == NULL) {
+        if (!skb) {
                 err = -ENOBUFS;
                 goto errout;
         }
@@ -2452,7 +2452,7 @@ static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
                 struct net_device *dev;
 
                 dev = __dev_get_by_index(net, iif);
-                if (dev == NULL) {
+                if (!dev) {
                         err = -ENODEV;
                         goto errout_free;
                 }
@@ -2651,7 +2651,7 @@ static __net_init int sysctl_route_net_init(struct net *net)
         tbl = ipv4_route_flush_table;
         if (!net_eq(net, &init_net)) {
                 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
-                if (tbl == NULL)
+                if (!tbl)
                         goto err_dup;
 
                 /* Don't export sysctls to unprivileged users */
@@ -2661,7 +2661,7 @@ static __net_init int sysctl_route_net_init(struct net *net)
         tbl[0].extra1 = net;
 
         net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
-        if (net->ipv4.route_hdr == NULL)
+        if (!net->ipv4.route_hdr)
                 goto err_reg;
         return 0;
 
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index fdf899163d44..c3852a7ff3c7 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -909,7 +909,7 @@ static __net_init int ipv4_sysctl_init_net(struct net *net)
                 int i;
 
                 table = kmemdup(table, sizeof(ipv4_net_table), GFP_KERNEL);
-                if (table == NULL)
+                if (!table)
                         goto err_alloc;
 
                 /* Update the variables to point into the current struct net */
@@ -918,7 +918,7 @@ static __net_init int ipv4_sysctl_init_net(struct net *net)
         }
 
         net->ipv4.ipv4_hdr = register_net_sysctl(net, "net/ipv4", table);
-        if (net->ipv4.ipv4_hdr == NULL)
+        if (!net->ipv4.ipv4_hdr)
                 goto err_reg;
 
         net->ipv4.sysctl_local_reserved_ports = kzalloc(65536 / 8, GFP_KERNEL);
@@ -956,7 +956,7 @@ static __init int sysctl_ipv4_init(void)
         struct ctl_table_header *hdr;
 
         hdr = register_net_sysctl(&init_net, "net/ipv4", ipv4_table);
-        if (hdr == NULL)
+        if (!hdr)
                 return -ENOMEM;
 
         if (register_pernet_subsys(&ipv4_sysctl_ops)) {
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index dbd51cefaf02..094a6822c71d 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -496,7 +496,7 @@ unsigned int tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
 
         /* Connected or passive Fast Open socket? */
         if (sk->sk_state != TCP_SYN_SENT &&
-            (sk->sk_state != TCP_SYN_RECV || tp->fastopen_rsk != NULL)) {
+            (sk->sk_state != TCP_SYN_RECV || tp->fastopen_rsk)) {
                 int target = sock_rcvlowat(sk, 0, INT_MAX);
 
                 if (tp->urg_seq == tp->copied_seq &&
@@ -1028,7 +1028,7 @@ static inline int select_size(const struct sock *sk, bool sg)
 
 void tcp_free_fastopen_req(struct tcp_sock *tp)
 {
-        if (tp->fastopen_req != NULL) {
+        if (tp->fastopen_req) {
                 kfree(tp->fastopen_req);
                 tp->fastopen_req = NULL;
         }
@@ -1042,12 +1042,12 @@ static int tcp_sendmsg_fastopen(struct sock *sk, struct msghdr *msg,
 
         if (!(sysctl_tcp_fastopen & TFO_CLIENT_ENABLE))
                 return -EOPNOTSUPP;
-        if (tp->fastopen_req != NULL)
+        if (tp->fastopen_req)
                 return -EALREADY; /* Another Fast Open is in progress */
 
         tp->fastopen_req = kzalloc(sizeof(struct tcp_fastopen_request),
                                    sk->sk_allocation);
-        if (unlikely(tp->fastopen_req == NULL))
+        if (unlikely(!tp->fastopen_req))
                 return -ENOBUFS;
         tp->fastopen_req->data = msg;
         tp->fastopen_req->size = size;
@@ -2138,7 +2138,7 @@ adjudge_to_death:
                  * aborted (e.g., closed with unread data) before 3WHS
                  * finishes.
                  */
-                if (req != NULL)
+                if (req)
                         reqsk_fastopen_remove(sk, req, false);
                 inet_csk_destroy_sock(sk);
         }
@@ -2776,7 +2776,7 @@ static int do_tcp_getsockopt(struct sock *sk, int level,
                 break;
 
         case TCP_FASTOPEN:
-                if (icsk->icsk_accept_queue.fastopenq != NULL)
+                if (icsk->icsk_accept_queue.fastopenq)
                         val = icsk->icsk_accept_queue.fastopenq->max_qlen;
                 else
                         val = 0;
@@ -2960,7 +2960,7 @@ void tcp_done(struct sock *sk)
 
         tcp_set_state(sk, TCP_CLOSE);
         tcp_clear_xmit_timers(sk);
-        if (req != NULL)
+        if (req)
                 reqsk_fastopen_remove(sk, req, false);
 
         sk->sk_shutdown = SHUTDOWN_MASK;
diff --git a/net/ipv4/tcp_diag.c b/net/ipv4/tcp_diag.c
index 86dc119a3815..79b34a0f4a4a 100644
--- a/net/ipv4/tcp_diag.c
+++ b/net/ipv4/tcp_diag.c
@@ -29,7 +29,7 @@ static void tcp_diag_get_info(struct sock *sk, struct inet_diag_msg *r,
                 r->idiag_rqueue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
                 r->idiag_wqueue = tp->write_seq - tp->snd_una;
         }
-        if (info != NULL)
+        if (info)
                 tcp_get_info(sk, info);
 }
 
diff --git a/net/ipv4/tcp_fastopen.c b/net/ipv4/tcp_fastopen.c
index 2eb887ec0ce3..e3d87aca6be8 100644
--- a/net/ipv4/tcp_fastopen.c
+++ b/net/ipv4/tcp_fastopen.c
@@ -141,7 +141,7 @@ static bool tcp_fastopen_create_child(struct sock *sk,
         req->sk = NULL;
 
         child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);
-        if (child == NULL)
+        if (!child)
                 return false;
 
         spin_lock(&queue->fastopenq->lock);
@@ -214,7 +214,7 @@ static bool tcp_fastopen_create_child(struct sock *sk,
         sk->sk_data_ready(sk);
         bh_unlock_sock(child);
         sock_put(child);
-        WARN_ON(req->sk == NULL);
+        WARN_ON(!req->sk);
         return true;
 }
 
@@ -233,7 +233,7 @@ static bool tcp_fastopen_queue_check(struct sock *sk)
          * temporarily vs a server not supporting Fast Open at all.
          */
         fastopenq = inet_csk(sk)->icsk_accept_queue.fastopenq;
-        if (fastopenq == NULL || fastopenq->max_qlen == 0)
+        if (!fastopenq || fastopenq->max_qlen == 0)
                 return false;
 
         if (fastopenq->qlen >= fastopenq->max_qlen) {
@@ -303,6 +303,7 @@ fastopen:
         } else if (foc->len > 0) /* Client presents an invalid cookie */
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPFASTOPENPASSIVEFAIL);
 
+        valid_foc.exp = foc->exp;
         *foc = valid_foc;
         return false;
 }
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 18b80e8bc533..031cf72cd05c 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -866,7 +866,7 @@ static void tcp_update_reordering(struct sock *sk, const int metric,
 /* This must be called before lost_out is incremented */
 static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
 {
-        if ((tp->retransmit_skb_hint == NULL) ||
+        if (!tp->retransmit_skb_hint ||
             before(TCP_SKB_CB(skb)->seq,
                    TCP_SKB_CB(tp->retransmit_skb_hint)->seq))
                 tp->retransmit_skb_hint = skb;
@@ -1256,7 +1256,7 @@ static u8 tcp_sacktag_one(struct sock *sk,
                 fack_count += pcount;
 
                 /* Lost marker hint past SACKed? Tweak RFC3517 cnt */
-                if (!tcp_is_fack(tp) && (tp->lost_skb_hint != NULL) &&
+                if (!tcp_is_fack(tp) && tp->lost_skb_hint &&
                     before(start_seq, TCP_SKB_CB(tp->lost_skb_hint)->seq))
                         tp->lost_cnt_hint += pcount;
 
@@ -1535,7 +1535,7 @@ static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
                 if (!before(TCP_SKB_CB(skb)->seq, end_seq))
                         break;
 
-                if ((next_dup != NULL) &&
+                if (next_dup  &&
                     before(TCP_SKB_CB(skb)->seq, next_dup->end_seq)) {
                         in_sack = tcp_match_skb_to_sack(sk, skb,
                                                         next_dup->start_seq,
@@ -1551,7 +1551,7 @@ static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
                 if (in_sack <= 0) {
                         tmp = tcp_shift_skb_data(sk, skb, state,
                                                  start_seq, end_seq, dup_sack);
-                        if (tmp != NULL) {
+                        if (tmp) {
                                 if (tmp != skb) {
                                         skb = tmp;
                                         continue;
@@ -1614,7 +1614,7 @@ static struct sk_buff *tcp_maybe_skipping_dsack(struct sk_buff *skb,
                                                 struct tcp_sacktag_state *state,
                                                 u32 skip_to_seq)
 {
-        if (next_dup == NULL)
+        if (!next_dup)
                 return skb;
 
         if (before(next_dup->start_seq, skip_to_seq)) {
@@ -1783,7 +1783,7 @@ tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
                         if (tcp_highest_sack_seq(tp) == cache->end_seq) {
                                 /* ...but better entrypoint exists! */
                                 skb = tcp_highest_sack(sk);
-                                if (skb == NULL)
+                                if (!skb)
                                         break;
                                 state.fack_count = tp->fackets_out;
                                 cache++;
@@ -1798,7 +1798,7 @@ tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
 
                 if (!before(start_seq, tcp_highest_sack_seq(tp))) {
                         skb = tcp_highest_sack(sk);
-                        if (skb == NULL)
+                        if (!skb)
                                 break;
                         state.fack_count = tp->fackets_out;
                 }
@@ -3105,10 +3105,11 @@ static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
                         if (!first_ackt.v64)
                                 first_ackt = last_ackt;
 
-                        if (!(sacked & TCPCB_SACKED_ACKED))
+                        if (!(sacked & TCPCB_SACKED_ACKED)) {
                                 reord = min(pkts_acked, reord);
-                        if (!after(scb->end_seq, tp->high_seq))
-                                flag |= FLAG_ORIG_SACK_ACKED;
+                                if (!after(scb->end_seq, tp->high_seq))
+                                        flag |= FLAG_ORIG_SACK_ACKED;
+                        }
                 }
 
                 if (sacked & TCPCB_SACKED_ACKED)
@@ -3602,6 +3603,23 @@ old_ack:
         return 0;
 }
 
+static void tcp_parse_fastopen_option(int len, const unsigned char *cookie,
+                                      bool syn, struct tcp_fastopen_cookie *foc,
+                                      bool exp_opt)
+{
+        /* Valid only in SYN or SYN-ACK with an even length.  */
+        if (!foc || !syn || len < 0 || (len & 1))
+                return;
+
+        if (len >= TCP_FASTOPEN_COOKIE_MIN &&
+            len <= TCP_FASTOPEN_COOKIE_MAX)
+                memcpy(foc->val, cookie, len);
+        else if (len != 0)
+                len = -1;
+        foc->len = len;
+        foc->exp = exp_opt;
+}
+
 /* Look for tcp options. Normally only called on SYN and SYNACK packets.
  * But, this can also be called on packets in the established flow when
  * the fast version below fails.
@@ -3691,21 +3709,22 @@ void tcp_parse_options(const struct sk_buff *skb,
                                  */
                                 break;
 #endif
+                        case TCPOPT_FASTOPEN:
+                                tcp_parse_fastopen_option(
+                                        opsize - TCPOLEN_FASTOPEN_BASE,
+                                        ptr, th->syn, foc, false);
+                                break;
+
                         case TCPOPT_EXP:
                                 /* Fast Open option shares code 254 using a
-                                 * 16 bits magic number. It's valid only in
-                                 * SYN or SYN-ACK with an even size.
+                                 * 16 bits magic number.
                                  */
-                                if (opsize < TCPOLEN_EXP_FASTOPEN_BASE ||
-                                    get_unaligned_be16(ptr) != TCPOPT_FASTOPEN_MAGIC ||
-                                    foc == NULL || !th->syn || (opsize & 1))
-                                        break;
-                                foc->len = opsize - TCPOLEN_EXP_FASTOPEN_BASE;
-                                if (foc->len >= TCP_FASTOPEN_COOKIE_MIN &&
-                                    foc->len <= TCP_FASTOPEN_COOKIE_MAX)
-                                        memcpy(foc->val, ptr + 2, foc->len);
-                                else if (foc->len != 0)
-                                        foc->len = -1;
+                                if (opsize >= TCPOLEN_EXP_FASTOPEN_BASE &&
+                                    get_unaligned_be16(ptr) ==
+                                    TCPOPT_FASTOPEN_MAGIC)
+                                        tcp_parse_fastopen_option(opsize -
+                                                TCPOLEN_EXP_FASTOPEN_BASE,
+                                                ptr + 2, th->syn, foc, true);
                                 break;
 
                         }
@@ -4669,7 +4688,7 @@ static void tcp_collapse_ofo_queue(struct sock *sk)
         struct sk_buff *head;
         u32 start, end;
 
-        if (skb == NULL)
+        if (!skb)
                 return;
 
         start = TCP_SKB_CB(skb)->seq;
@@ -5124,7 +5143,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
 {
         struct tcp_sock *tp = tcp_sk(sk);
 
-        if (unlikely(sk->sk_rx_dst == NULL))
+        if (unlikely(!sk->sk_rx_dst))
                 inet_csk(sk)->icsk_af_ops->sk_rx_dst_set(sk, skb);
         /*
          *      Header prediction.
@@ -5321,7 +5340,7 @@ void tcp_finish_connect(struct sock *sk, struct sk_buff *skb)
 
         tcp_set_state(sk, TCP_ESTABLISHED);
 
-        if (skb != NULL) {
+        if (skb) {
                 icsk->icsk_af_ops->sk_rx_dst_set(sk, skb);
                 security_inet_conn_established(sk, skb);
         }
@@ -5359,8 +5378,8 @@ static bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack,
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct sk_buff *data = tp->syn_data ? tcp_write_queue_head(sk) : NULL;
-        u16 mss = tp->rx_opt.mss_clamp;
-        bool syn_drop;
+        u16 mss = tp->rx_opt.mss_clamp, try_exp = 0;
+        bool syn_drop = false;
 
         if (mss == tp->rx_opt.user_mss) {
                 struct tcp_options_received opt;
@@ -5372,16 +5391,25 @@ static bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack,
                 mss = opt.mss_clamp;
         }
 
-        if (!tp->syn_fastopen)  /* Ignore an unsolicited cookie */
+        if (!tp->syn_fastopen) {
+                /* Ignore an unsolicited cookie */
                 cookie->len = -1;
+        } else if (tp->total_retrans) {
+                /* SYN timed out and the SYN-ACK neither has a cookie nor
+                 * acknowledges data. Presumably the remote received only
+                 * the retransmitted (regular) SYNs: either the original
+                 * SYN-data or the corresponding SYN-ACK was dropped.
+                 */
+                syn_drop = (cookie->len < 0 && data);
+        } else if (cookie->len < 0 && !tp->syn_data) {
+                /* We requested a cookie but didn't get it. If we did not use
+                 * the (old) exp opt format then try so next time (try_exp=1).
+                 * Otherwise we go back to use the RFC7413 opt (try_exp=2).
+                 */
+                try_exp = tp->syn_fastopen_exp ? 2 : 1;
+        }
 
-        /* The SYN-ACK neither has cookie nor acknowledges the data. Presumably
-         * the remote receives only the retransmitted (regular) SYNs: either
-         * the original SYN-data or the corresponding SYN-ACK is lost.
-         */
-        syn_drop = (cookie->len <= 0 && data && tp->total_retrans);
-
-        tcp_fastopen_cache_set(sk, mss, cookie, syn_drop);
+        tcp_fastopen_cache_set(sk, mss, cookie, syn_drop, try_exp);
 
         if (data) { /* Retransmit unacked data in SYN */
                 tcp_for_write_queue_from(data, sk) {
@@ -5690,11 +5718,11 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
         }
 
         req = tp->fastopen_rsk;
-        if (req != NULL) {
+        if (req) {
                 WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV &&
                     sk->sk_state != TCP_FIN_WAIT1);
 
-                if (tcp_check_req(sk, skb, req, true) == NULL)
+                if (!tcp_check_req(sk, skb, req, true))
                         goto discard;
         }
 
@@ -5780,7 +5808,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
                  * ACK we have received, this would have acknowledged
                  * our SYNACK so stop the SYNACK timer.
                  */
-                if (req != NULL) {
+                if (req) {
                         /* Return RST if ack_seq is invalid.
                          * Note that RFC793 only says to generate a
                          * DUPACK for it but for TCP Fast Open it seems
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 5aababa20a21..560f9571f7c4 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -122,7 +122,7 @@ int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
            and use initial timestamp retrieved from peer table.
          */
         if (tcptw->tw_ts_recent_stamp &&
-            (twp == NULL || (sysctl_tcp_tw_reuse &&
+            (!twp || (sysctl_tcp_tw_reuse &&
                              get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
                 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
                 if (tp->write_seq == 0)
@@ -494,7 +494,7 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
                 /* Only in fast or simultaneous open. If a fast open socket is
                  * is already accepted it is treated as a connected one below.
                  */
-                if (fastopen && fastopen->sk == NULL)
+                if (fastopen && !fastopen->sk)
                         break;
 
                 if (!sock_owned_by_user(sk)) {
@@ -1305,7 +1305,7 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
         /* Copy over the MD5 key from the original socket */
         key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&newinet->inet_daddr,
                                 AF_INET);
-        if (key != NULL) {
+        if (key) {
                 /*
                  * We're using one, so create a matching key
                  * on the newsk structure. If we fail to get
@@ -1390,7 +1390,7 @@ int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
                 sk_mark_napi_id(sk, skb);
                 if (dst) {
                         if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
-                            dst->ops->check(dst, 0) == NULL) {
+                            !dst->ops->check(dst, 0)) {
                                 dst_release(dst);
                                 sk->sk_rx_dst = NULL;
                         }
@@ -1469,7 +1469,7 @@ void tcp_v4_early_demux(struct sk_buff *skb)
                 skb->sk = sk;
                 skb->destructor = sock_edemux;
                 if (sk_fullsock(sk)) {
-                        struct dst_entry *dst = sk->sk_rx_dst;
+                        struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst);
 
                         if (dst)
                                 dst = dst_check(dst, 0);
@@ -1797,7 +1797,7 @@ void tcp_v4_destroy_sock(struct sock *sk)
         if (inet_csk(sk)->icsk_bind_hash)
                 inet_put_port(sk);
 
-        BUG_ON(tp->fastopen_rsk != NULL);
+        BUG_ON(tp->fastopen_rsk);
 
         /* If socket is aborted during connect operation */
         tcp_free_fastopen_req(tp);
diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c
index 71ec14c87579..a51d63a43e33 100644
--- a/net/ipv4/tcp_metrics.c
+++ b/net/ipv4/tcp_metrics.c
@@ -28,7 +28,8 @@ static struct tcp_metrics_block *__tcp_get_metrics(const struct inetpeer_addr *s
 
 struct tcp_fastopen_metrics {
         u16     mss;
-        u16     syn_loss:10;            /* Recurring Fast Open SYN losses */
+        u16     syn_loss:10,            /* Recurring Fast Open SYN losses */
+                try_exp:2;              /* Request w/ exp. option (once) */
         unsigned long   last_syn_loss;  /* Last Fast Open SYN loss */
         struct  tcp_fastopen_cookie     cookie;
 };
@@ -131,6 +132,8 @@ static void tcpm_suck_dst(struct tcp_metrics_block *tm,
         if (fastopen_clear) {
                 tm->tcpm_fastopen.mss = 0;
                 tm->tcpm_fastopen.syn_loss = 0;
+                tm->tcpm_fastopen.try_exp = 0;
+                tm->tcpm_fastopen.cookie.exp = false;
                 tm->tcpm_fastopen.cookie.len = 0;
         }
 }
@@ -505,7 +508,7 @@ void tcp_init_metrics(struct sock *sk)
         struct tcp_metrics_block *tm;
         u32 val, crtt = 0; /* cached RTT scaled by 8 */
 
-        if (dst == NULL)
+        if (!dst)
                 goto reset;
 
         dst_confirm(dst);
@@ -713,6 +716,8 @@ void tcp_fastopen_cache_get(struct sock *sk, u16 *mss,
                         if (tfom->mss)
                                 *mss = tfom->mss;
                         *cookie = tfom->cookie;
+                        if (cookie->len <= 0 && tfom->try_exp == 1)
+                                cookie->exp = true;
                         *syn_loss = tfom->syn_loss;
                         *last_syn_loss = *syn_loss ? tfom->last_syn_loss : 0;
                 } while (read_seqretry(&fastopen_seqlock, seq));
@@ -721,7 +726,8 @@ void tcp_fastopen_cache_get(struct sock *sk, u16 *mss,
 }
 
 void tcp_fastopen_cache_set(struct sock *sk, u16 mss,
-                            struct tcp_fastopen_cookie *cookie, bool syn_lost)
+                            struct tcp_fastopen_cookie *cookie, bool syn_lost,
+                            u16 try_exp)
 {
         struct dst_entry *dst = __sk_dst_get(sk);
         struct tcp_metrics_block *tm;
@@ -738,6 +744,9 @@ void tcp_fastopen_cache_set(struct sock *sk, u16 mss,
                         tfom->mss = mss;
                 if (cookie && cookie->len > 0)
                         tfom->cookie = *cookie;
+                else if (try_exp > tfom->try_exp &&
+                         tfom->cookie.len <= 0 && !tfom->cookie.exp)
+                        tfom->try_exp = try_exp;
                 if (syn_lost) {
                         ++tfom->syn_loss;
                         tfom->last_syn_loss = jiffies;
diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index 274e96fb369b..d7003911c894 100644
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -294,7 +294,7 @@ void tcp_time_wait(struct sock *sk, int state, int timeo)
         if (tcp_death_row.tw_count < tcp_death_row.sysctl_max_tw_buckets)
                 tw = inet_twsk_alloc(sk, state);
 
-        if (tw != NULL) {
+        if (tw) {
                 struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
                 const int rto = (icsk->icsk_rto << 2) - (icsk->icsk_rto >> 1);
                 struct inet_sock *inet = inet_sk(sk);
@@ -332,7 +332,7 @@ void tcp_time_wait(struct sock *sk, int state, int timeo)
                         struct tcp_md5sig_key *key;
                         tcptw->tw_md5_key = NULL;
                         key = tp->af_specific->md5_lookup(sk, sk);
-                        if (key != NULL) {
+                        if (key) {
                                 tcptw->tw_md5_key = kmemdup(key, sizeof(*key), GFP_ATOMIC);
                                 if (tcptw->tw_md5_key && !tcp_alloc_md5sig_pool())
                                         BUG();
@@ -454,7 +454,7 @@ struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req,
 {
         struct sock *newsk = inet_csk_clone_lock(sk, req, GFP_ATOMIC);
 
-        if (newsk != NULL) {
+        if (newsk) {
                 const struct inet_request_sock *ireq = inet_rsk(req);
                 struct tcp_request_sock *treq = tcp_rsk(req);
                 struct inet_connection_sock *newicsk = inet_csk(newsk);
@@ -763,7 +763,7 @@ struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
          * socket is created, wait for troubles.
          */
         child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);
-        if (child == NULL)
+        if (!child)
                 goto listen_overflow;
 
         inet_csk_reqsk_queue_unlink(sk, req);
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 2e69b8d16e68..e662d85d1635 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -518,17 +518,26 @@ static void tcp_options_write(__be32 *ptr, struct tcp_sock *tp,
 
         if (unlikely(OPTION_FAST_OPEN_COOKIE & options)) {
                 struct tcp_fastopen_cookie *foc = opts->fastopen_cookie;
+                u8 *p = (u8 *)ptr;
+                u32 len; /* Fast Open option length */
+
+                if (foc->exp) {
+                        len = TCPOLEN_EXP_FASTOPEN_BASE + foc->len;
+                        *ptr = htonl((TCPOPT_EXP << 24) | (len << 16) |
+                                     TCPOPT_FASTOPEN_MAGIC);
+                        p += TCPOLEN_EXP_FASTOPEN_BASE;
+                } else {
+                        len = TCPOLEN_FASTOPEN_BASE + foc->len;
+                        *p++ = TCPOPT_FASTOPEN;
+                        *p++ = len;
+                }
 
-                *ptr++ = htonl((TCPOPT_EXP << 24) |
-                               ((TCPOLEN_EXP_FASTOPEN_BASE + foc->len) << 16) |
-                               TCPOPT_FASTOPEN_MAGIC);
-
-                memcpy(ptr, foc->val, foc->len);
-                if ((foc->len & 3) == 2) {
-                        u8 *align = ((u8 *)ptr) + foc->len;
-                        align[0] = align[1] = TCPOPT_NOP;
+                memcpy(p, foc->val, foc->len);
+                if ((len & 3) == 2) {
+                        p[foc->len] = TCPOPT_NOP;
+                        p[foc->len + 1] = TCPOPT_NOP;
                 }
-                ptr += (foc->len + 3) >> 2;
+                ptr += (len + 3) >> 2;
         }
 }
 
@@ -565,7 +574,7 @@ static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb,
         opts->mss = tcp_advertise_mss(sk);
         remaining -= TCPOLEN_MSS_ALIGNED;
 
-        if (likely(sysctl_tcp_timestamps && *md5 == NULL)) {
+        if (likely(sysctl_tcp_timestamps && !*md5)) {
                 opts->options |= OPTION_TS;
                 opts->tsval = tcp_skb_timestamp(skb) + tp->tsoffset;
                 opts->tsecr = tp->rx_opt.ts_recent;
@@ -583,13 +592,17 @@ static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb,
         }
 
         if (fastopen && fastopen->cookie.len >= 0) {
-                u32 need = TCPOLEN_EXP_FASTOPEN_BASE + fastopen->cookie.len;
+                u32 need = fastopen->cookie.len;
+
+                need += fastopen->cookie.exp ? TCPOLEN_EXP_FASTOPEN_BASE :
+                                               TCPOLEN_FASTOPEN_BASE;
                 need = (need + 3) & ~3U;  /* Align to 32 bits */
                 if (remaining >= need) {
                         opts->options |= OPTION_FAST_OPEN_COOKIE;
                         opts->fastopen_cookie = &fastopen->cookie;
                         remaining -= need;
                         tp->syn_fastopen = 1;
+                        tp->syn_fastopen_exp = fastopen->cookie.exp ? 1 : 0;
                 }
         }
 
@@ -642,7 +655,10 @@ static unsigned int tcp_synack_options(struct sock *sk,
                         remaining -= TCPOLEN_SACKPERM_ALIGNED;
         }
         if (foc != NULL && foc->len >= 0) {
-                u32 need = TCPOLEN_EXP_FASTOPEN_BASE + foc->len;
+                u32 need = foc->len;
+
+                need += foc->exp ? TCPOLEN_EXP_FASTOPEN_BASE :
+                                   TCPOLEN_FASTOPEN_BASE;
                 need = (need + 3) & ~3U;  /* Align to 32 bits */
                 if (remaining >= need) {
                         opts->options |= OPTION_FAST_OPEN_COOKIE;
@@ -1148,7 +1164,7 @@ int tcp_fragment(struct sock *sk, struct sk_buff *skb, u32 len,
 
         /* Get a new skb... force flag on. */
         buff = sk_stream_alloc_skb(sk, nsize, gfp);
-        if (buff == NULL)
+        if (!buff)
                 return -ENOMEM; /* We'll just try again later. */
 
         sk->sk_wmem_queued += buff->truesize;
@@ -1707,7 +1723,7 @@ static int tso_fragment(struct sock *sk, struct sk_buff *skb, unsigned int len,
                 return tcp_fragment(sk, skb, len, mss_now, gfp);
 
         buff = sk_stream_alloc_skb(sk, 0, gfp);
-        if (unlikely(buff == NULL))
+        if (unlikely(!buff))
                 return -ENOMEM;
 
         sk->sk_wmem_queued += buff->truesize;
@@ -1925,7 +1941,8 @@ static int tcp_mtu_probe(struct sock *sk)
         }
 
         /* We're allowed to probe.  Build it now. */
-        if ((nskb = sk_stream_alloc_skb(sk, probe_size, GFP_ATOMIC)) == NULL)
+        nskb = sk_stream_alloc_skb(sk, probe_size, GFP_ATOMIC);
+        if (!nskb)
                 return -1;
         sk->sk_wmem_queued += nskb->truesize;
         sk_mem_charge(sk, nskb->truesize);
@@ -2223,7 +2240,7 @@ void tcp_send_loss_probe(struct sock *sk)
         int mss = tcp_current_mss(sk);
         int err = -1;
 
-        if (tcp_send_head(sk) != NULL) {
+        if (tcp_send_head(sk)) {
                 err = tcp_write_xmit(sk, mss, TCP_NAGLE_OFF, 2, GFP_ATOMIC);
                 goto rearm_timer;
         }
@@ -2733,7 +2750,7 @@ void tcp_xmit_retransmit_queue(struct sock *sk)
                 if (skb == tcp_send_head(sk))
                         break;
                 /* we could do better than to assign each time */
-                if (hole == NULL)
+                if (!hole)
                         tp->retransmit_skb_hint = skb;
 
                 /* Assume this retransmit will generate
@@ -2757,7 +2774,7 @@ begin_fwd:
                         if (!tcp_can_forward_retransmit(sk))
                                 break;
                         /* Backtrack if necessary to non-L'ed skb */
-                        if (hole != NULL) {
+                        if (hole) {
                                 skb = hole;
                                 hole = NULL;
                         }
@@ -2765,7 +2782,7 @@ begin_fwd:
                         goto begin_fwd;
 
                 } else if (!(sacked & TCPCB_LOST)) {
-                        if (hole == NULL && !(sacked & (TCPCB_SACKED_RETRANS|TCPCB_SACKED_ACKED)))
+                        if (!hole && !(sacked & (TCPCB_SACKED_RETRANS|TCPCB_SACKED_ACKED)))
                                 hole = skb;
                         continue;
 
@@ -2810,7 +2827,7 @@ void tcp_send_fin(struct sock *sk)
          */
         mss_now = tcp_current_mss(sk);
 
-        if (tcp_send_head(sk) != NULL) {
+        if (tcp_send_head(sk)) {
                 TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_FIN;
                 TCP_SKB_CB(skb)->end_seq++;
                 tp->write_seq++;
@@ -2868,14 +2885,14 @@ int tcp_send_synack(struct sock *sk)
         struct sk_buff *skb;
 
         skb = tcp_write_queue_head(sk);
-        if (skb == NULL || !(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
+        if (!skb || !(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
                 pr_debug("%s: wrong queue state\n", __func__);
                 return -EFAULT;
         }
         if (!(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACK)) {
                 if (skb_cloned(skb)) {
                         struct sk_buff *nskb = skb_copy(skb, GFP_ATOMIC);
-                        if (nskb == NULL)
+                        if (!nskb)
                                 return -ENOMEM;
                         tcp_unlink_write_queue(skb, sk);
                         __skb_header_release(nskb);
@@ -3014,7 +3031,7 @@ static void tcp_connect_init(struct sock *sk)
                 (sysctl_tcp_timestamps ? TCPOLEN_TSTAMP_ALIGNED : 0);
 
 #ifdef CONFIG_TCP_MD5SIG
-        if (tp->af_specific->md5_lookup(sk, sk) != NULL)
+        if (tp->af_specific->md5_lookup(sk, sk))
                 tp->tcp_header_len += TCPOLEN_MD5SIG_ALIGNED;
 #endif
 
@@ -3300,7 +3317,7 @@ void tcp_send_ack(struct sock *sk)
          * sock.
          */
         buff = alloc_skb(MAX_TCP_HEADER, sk_gfp_atomic(sk, GFP_ATOMIC));
-        if (buff == NULL) {
+        if (!buff) {
                 inet_csk_schedule_ack(sk);
                 inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
@@ -3344,7 +3361,7 @@ static int tcp_xmit_probe_skb(struct sock *sk, int urgent)
 
         /* We don't queue it, tcp_transmit_skb() sets ownership. */
         skb = alloc_skb(MAX_TCP_HEADER, sk_gfp_atomic(sk, GFP_ATOMIC));
-        if (skb == NULL)
+        if (!skb)
                 return -1;
 
         /* Reserve space for headers and set control bits. */
@@ -3375,8 +3392,8 @@ int tcp_write_wakeup(struct sock *sk)
         if (sk->sk_state == TCP_CLOSE)
                 return -1;
 
-        if ((skb = tcp_send_head(sk)) != NULL &&
-            before(TCP_SKB_CB(skb)->seq, tcp_wnd_end(tp))) {
+        skb = tcp_send_head(sk);
+        if (skb && before(TCP_SKB_CB(skb)->seq, tcp_wnd_end(tp))) {
                 int err;
                 unsigned int mss = tcp_current_mss(sk);
                 unsigned int seg_size = tcp_wnd_end(tp) - TCP_SKB_CB(skb)->seq;
diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
index 2568fd282873..8c65dc147d8b 100644
--- a/net/ipv4/tcp_timer.c
+++ b/net/ipv4/tcp_timer.c
@@ -167,7 +167,7 @@ static int tcp_write_timeout(struct sock *sk)
                 if (icsk->icsk_retransmits) {
                         dst_negative_advice(sk);
                         if (tp->syn_fastopen || tp->syn_data)
-                                tcp_fastopen_cache_set(sk, 0, NULL, true);
+                                tcp_fastopen_cache_set(sk, 0, NULL, true, 0);
                         if (tp->syn_data)
                                 NET_INC_STATS_BH(sock_net(sk),
                                                  LINUX_MIB_TCPFASTOPENACTIVEFAIL);
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 294af16633af..2162fc6ce1c1 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -633,7 +633,7 @@ void __udp4_lib_err(struct sk_buff *skb, u32 info, struct udp_table *udptable)
 
         sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,
                         iph->saddr, uh->source, skb->dev->ifindex, udptable);
-        if (sk == NULL) {
+        if (!sk) {
                 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
                 return; /* No socket for error */
         }
@@ -1011,7 +1011,7 @@ int udp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
         if (connected)
                 rt = (struct rtable *)sk_dst_check(sk, 0);
 
-        if (rt == NULL) {
+        if (!rt) {
                 struct net *net = sock_net(sk);
 
                 fl4 = &fl4_stack;
@@ -1522,7 +1522,7 @@ int udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
 
                 /* if we're overly short, let UDP handle it */
                 encap_rcv = ACCESS_ONCE(up->encap_rcv);
-                if (skb->len > sizeof(struct udphdr) && encap_rcv != NULL) {
+                if (skb->len > sizeof(struct udphdr) && encap_rcv) {
                         int ret;
 
                         /* Verify checksum before giving to encap */
@@ -1619,7 +1619,7 @@ static void flush_stack(struct sock **stack, unsigned int count,
 
         for (i = 0; i < count; i++) {
                 sk = stack[i];
-                if (likely(skb1 == NULL))
+                if (likely(!skb1))
                         skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);
 
                 if (!skb1) {
@@ -1802,7 +1802,7 @@ int __udp4_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
                                                 saddr, daddr, udptable, proto);
 
         sk = __udp4_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
-        if (sk != NULL) {
+        if (sk) {
                 int ret;
 
                 if (inet_get_convert_csum(sk) && uh->check && !IS_UDPLITE(sk))
diff --git a/net/ipv4/udp_diag.c b/net/ipv4/udp_diag.c
index 2dbfc1f1f7b3..b763c39ae1d7 100644
--- a/net/ipv4/udp_diag.c
+++ b/net/ipv4/udp_diag.c
@@ -58,7 +58,7 @@ static int udp_dump_one(struct udp_table *tbl, struct sk_buff *in_skb,
                 goto out_nosk;
 
         err = -ENOENT;
-        if (sk == NULL)
+        if (!sk)
                 goto out_nosk;
 
         err = sock_diag_check_cookie(sk, req->id.idiag_cookie);
diff --git a/net/ipv4/udp_offload.c b/net/ipv4/udp_offload.c
index 4915d8284a86..f9386160cbee 100644
--- a/net/ipv4/udp_offload.c
+++ b/net/ipv4/udp_offload.c
@@ -285,7 +285,7 @@ void udp_del_offload(struct udp_offload *uo)
         pr_warn("udp_del_offload: didn't find offload for port %d\n", ntohs(uo->port));
 unlock:
         spin_unlock(&udp_offload_lock);
-        if (uo_priv != NULL)
+        if (uo_priv)
                 call_rcu(&uo_priv->rcu, udp_offload_free_routine);
 }
 EXPORT_SYMBOL(udp_del_offload);
@@ -394,7 +394,7 @@ int udp_gro_complete(struct sk_buff *skb, int nhoff)
                         break;
         }
 
-        if (uo_priv != NULL) {
+        if (uo_priv) {
                 NAPI_GRO_CB(skb)->proto = uo_priv->offload->ipproto;
                 err = uo_priv->offload->callbacks.gro_complete(skb,
                                 nhoff + sizeof(struct udphdr),
diff --git a/net/ipv4/udp_tunnel.c b/net/ipv4/udp_tunnel.c
index c83b35485056..6bb98cc193c9 100644
--- a/net/ipv4/udp_tunnel.c
+++ b/net/ipv4/udp_tunnel.c
@@ -75,7 +75,7 @@ void setup_udp_tunnel_sock(struct net *net, struct socket *sock,
 }
 EXPORT_SYMBOL_GPL(setup_udp_tunnel_sock);
 
-int udp_tunnel_xmit_skb(struct rtable *rt, struct sk_buff *skb,
+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)
@@ -92,7 +92,7 @@ int udp_tunnel_xmit_skb(struct rtable *rt, struct sk_buff *skb,
 
         udp_set_csum(nocheck, skb, src, dst, skb->len);
 
-        return iptunnel_xmit(skb->sk, rt, skb, src, dst, IPPROTO_UDP,
+        return iptunnel_xmit(sk, rt, skb, src, dst, IPPROTO_UDP,
                              tos, ttl, df, xnet);
 }
 EXPORT_SYMBOL_GPL(udp_tunnel_xmit_skb);
diff --git a/net/ipv4/xfrm4_input.c b/net/ipv4/xfrm4_input.c
index aac6197b7a71..60b032f58ccc 100644
--- a/net/ipv4/xfrm4_input.c
+++ b/net/ipv4/xfrm4_input.c
@@ -22,9 +22,9 @@ int xfrm4_extract_input(struct xfrm_state *x, struct sk_buff *skb)
         return xfrm4_extract_header(skb);
 }
 
-static inline int xfrm4_rcv_encap_finish(struct sk_buff *skb)
+static inline int xfrm4_rcv_encap_finish(struct sock *sk, struct sk_buff *skb)
 {
-        if (skb_dst(skb) == NULL) {
+        if (!skb_dst(skb)) {
                 const struct iphdr *iph = ip_hdr(skb);
 
                 if (ip_route_input_noref(skb, iph->daddr, iph->saddr,
@@ -52,7 +52,8 @@ int xfrm4_transport_finish(struct sk_buff *skb, int async)
         iph->tot_len = htons(skb->len);
         ip_send_check(iph);
 
-        NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, skb, skb->dev, NULL,
+        NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, NULL, skb,
+                skb->dev, NULL,
                 xfrm4_rcv_encap_finish);
         return 0;
 }
diff --git a/net/ipv4/xfrm4_output.c b/net/ipv4/xfrm4_output.c
index dab73813cb92..2878dbfffeb7 100644
--- a/net/ipv4/xfrm4_output.c
+++ b/net/ipv4/xfrm4_output.c
@@ -69,7 +69,7 @@ int xfrm4_prepare_output(struct xfrm_state *x, struct sk_buff *skb)
 }
 EXPORT_SYMBOL(xfrm4_prepare_output);
 
-int xfrm4_output_finish(struct sk_buff *skb)
+int xfrm4_output_finish(struct sock *sk, struct sk_buff *skb)
 {
         memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
 
@@ -77,26 +77,26 @@ int xfrm4_output_finish(struct sk_buff *skb)
         IPCB(skb)->flags |= IPSKB_XFRM_TRANSFORMED;
 #endif
 
-        return xfrm_output(skb);
+        return xfrm_output(sk, skb);
 }
 
-static int __xfrm4_output(struct sk_buff *skb)
+static int __xfrm4_output(struct sock *sk, struct sk_buff *skb)
 {
         struct xfrm_state *x = skb_dst(skb)->xfrm;
 
 #ifdef CONFIG_NETFILTER
         if (!x) {
                 IPCB(skb)->flags |= IPSKB_REROUTED;
-                return dst_output(skb);
+                return dst_output_sk(sk, skb);
         }
 #endif
 
-        return x->outer_mode->afinfo->output_finish(skb);
+        return x->outer_mode->afinfo->output_finish(sk, skb);
 }
 
 int xfrm4_output(struct sock *sk, struct sk_buff *skb)
 {
-        return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING, skb,
+        return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING, sk, skb,
                             NULL, skb_dst(skb)->dev, __xfrm4_output,
                             !(IPCB(skb)->flags & IPSKB_REROUTED));
 }
diff --git a/net/ipv4/xfrm4_policy.c b/net/ipv4/xfrm4_policy.c
index c224c856247b..bff69746e05f 100644
--- a/net/ipv4/xfrm4_policy.c
+++ b/net/ipv4/xfrm4_policy.c
@@ -298,7 +298,7 @@ static void __net_exit xfrm4_net_exit(struct net *net)
 {
         struct ctl_table *table;
 
-        if (net->ipv4.xfrm4_hdr == NULL)
+        if (!net->ipv4.xfrm4_hdr)
                 return;
 
         table = net->ipv4.xfrm4_hdr->ctl_table_arg;
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index 5c9e94cb1b2c..37b70e82bff8 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -4858,8 +4858,8 @@ static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
             (dev->addr_len &&
              nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
             nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
-            (dev->ifindex != dev->iflink &&
-             nla_put_u32(skb, IFLA_LINK, dev->iflink)))
+            (dev->ifindex != dev_get_iflink(dev) &&
+             nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
                 goto nla_put_failure;
         protoinfo = nla_nest_start(skb, IFLA_PROTINFO);
         if (!protoinfo)
diff --git a/net/ipv6/fib6_rules.c b/net/ipv6/fib6_rules.c
index 61fb184b818d..2367a16eae58 100644
--- a/net/ipv6/fib6_rules.c
+++ b/net/ipv6/fib6_rules.c
@@ -315,7 +315,9 @@ out_fib6_rules_ops:
 
 static void __net_exit fib6_rules_net_exit(struct net *net)
 {
+        rtnl_lock();
         fib_rules_unregister(net->ipv6.fib6_rules_ops);
+        rtnl_unlock();
 }
 
 static struct pernet_operations fib6_rules_net_ops = {
diff --git a/net/ipv6/ip6_gre.c b/net/ipv6/ip6_gre.c
index 0f4e73da14e4..b5e6cc1d4a73 100644
--- a/net/ipv6/ip6_gre.c
+++ b/net/ipv6/ip6_gre.c
@@ -760,7 +760,7 @@ static netdev_tx_t ip6gre_xmit2(struct sk_buff *skb,
 
         skb_set_inner_protocol(skb, protocol);
 
-        ip6tunnel_xmit(skb, dev);
+        ip6tunnel_xmit(NULL, skb, dev);
         if (ndst)
                 ip6_tnl_dst_store(tunnel, ndst);
         return 0;
@@ -1216,6 +1216,7 @@ static const struct net_device_ops ip6gre_netdev_ops = {
         .ndo_do_ioctl           = ip6gre_tunnel_ioctl,
         .ndo_change_mtu         = ip6gre_tunnel_change_mtu,
         .ndo_get_stats64        = ip_tunnel_get_stats64,
+        .ndo_get_iflink         = ip6_tnl_get_iflink,
 };
 
 static void ip6gre_dev_free(struct net_device *dev)
@@ -1238,7 +1239,6 @@ static void ip6gre_tunnel_setup(struct net_device *dev)
         if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
                 dev->mtu -= 8;
         dev->flags |= IFF_NOARP;
-        dev->iflink = 0;
         dev->addr_len = sizeof(struct in6_addr);
         netif_keep_dst(dev);
 }
@@ -1270,8 +1270,6 @@ static int ip6gre_tunnel_init(struct net_device *dev)
                 u64_stats_init(&ip6gre_tunnel_stats->syncp);
         }
 
-        dev->iflink = tunnel->parms.link;
-
         return 0;
 }
 
@@ -1480,8 +1478,6 @@ static int ip6gre_tap_init(struct net_device *dev)
         if (!dev->tstats)
                 return -ENOMEM;
 
-        dev->iflink = tunnel->parms.link;
-
         return 0;
 }
 
@@ -1493,6 +1489,7 @@ static const struct net_device_ops ip6gre_tap_netdev_ops = {
         .ndo_validate_addr = eth_validate_addr,
         .ndo_change_mtu = ip6gre_tunnel_change_mtu,
         .ndo_get_stats64 = ip_tunnel_get_stats64,
+        .ndo_get_iflink = ip6_tnl_get_iflink,
 };
 
 static void ip6gre_tap_setup(struct net_device *dev)
@@ -1503,7 +1500,6 @@ static void ip6gre_tap_setup(struct net_device *dev)
         dev->netdev_ops = &ip6gre_tap_netdev_ops;
         dev->destructor = ip6gre_dev_free;
 
-        dev->iflink = 0;
         dev->features |= NETIF_F_NETNS_LOCAL;
 }
 
diff --git a/net/ipv6/ip6_input.c b/net/ipv6/ip6_input.c
index fb97f7f8d4ed..f2e464eba5ef 100644
--- a/net/ipv6/ip6_input.c
+++ b/net/ipv6/ip6_input.c
@@ -46,8 +46,7 @@
 #include <net/xfrm.h>
 #include <net/inet_ecn.h>
 
-
-int ip6_rcv_finish(struct sk_buff *skb)
+int ip6_rcv_finish(struct sock *sk, struct sk_buff *skb)
 {
         if (sysctl_ip_early_demux && !skb_dst(skb) && skb->sk == NULL) {
                 const struct inet6_protocol *ipprot;
@@ -183,7 +182,8 @@ int ipv6_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt
         /* Must drop socket now because of tproxy. */
         skb_orphan(skb);
 
-        return NF_HOOK(NFPROTO_IPV6, NF_INET_PRE_ROUTING, skb, dev, NULL,
+        return NF_HOOK(NFPROTO_IPV6, NF_INET_PRE_ROUTING, NULL, skb,
+                       dev, NULL,
                        ip6_rcv_finish);
 err:
         IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_INHDRERRORS);
@@ -198,7 +198,7 @@ drop:
  */
 
 
-static int ip6_input_finish(struct sk_buff *skb)
+static int ip6_input_finish(struct sock *sk, struct sk_buff *skb)
 {
         struct net *net = dev_net(skb_dst(skb)->dev);
         const struct inet6_protocol *ipprot;
@@ -277,7 +277,8 @@ discard:
 
 int ip6_input(struct sk_buff *skb)
 {
-        return NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_IN, skb, skb->dev, NULL,
+        return NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_IN, NULL, skb,
+                       skb->dev, NULL,
                        ip6_input_finish);
 }
 
diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c
index 84c58da10f5c..7fde1f265c90 100644
--- a/net/ipv6/ip6_output.c
+++ b/net/ipv6/ip6_output.c
@@ -56,7 +56,7 @@
 #include <net/checksum.h>
 #include <linux/mroute6.h>
 
-static int ip6_finish_output2(struct sk_buff *skb)
+static int ip6_finish_output2(struct sock *sk, struct sk_buff *skb)
 {
         struct dst_entry *dst = skb_dst(skb);
         struct net_device *dev = dst->dev;
@@ -70,7 +70,7 @@ static int ip6_finish_output2(struct sk_buff *skb)
         if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr)) {
                 struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
 
-                if (!(dev->flags & IFF_LOOPBACK) && sk_mc_loop(skb->sk) &&
+                if (!(dev->flags & IFF_LOOPBACK) && sk_mc_loop(sk) &&
                     ((mroute6_socket(dev_net(dev), skb) &&
                      !(IP6CB(skb)->flags & IP6SKB_FORWARDED)) ||
                      ipv6_chk_mcast_addr(dev, &ipv6_hdr(skb)->daddr,
@@ -82,7 +82,7 @@ static int ip6_finish_output2(struct sk_buff *skb)
                          */
                         if (newskb)
                                 NF_HOOK(NFPROTO_IPV6, NF_INET_POST_ROUTING,
-                                        newskb, NULL, newskb->dev,
+                                        sk, newskb, NULL, newskb->dev,
                                         dev_loopback_xmit);
 
                         if (ipv6_hdr(skb)->hop_limit == 0) {
@@ -122,14 +122,14 @@ static int ip6_finish_output2(struct sk_buff *skb)
         return -EINVAL;
 }
 
-static int ip6_finish_output(struct sk_buff *skb)
+static int ip6_finish_output(struct sock *sk, struct sk_buff *skb)
 {
         if ((skb->len > ip6_skb_dst_mtu(skb) && !skb_is_gso(skb)) ||
             dst_allfrag(skb_dst(skb)) ||
             (IP6CB(skb)->frag_max_size && skb->len > IP6CB(skb)->frag_max_size))
-                return ip6_fragment(skb, ip6_finish_output2);
+                return ip6_fragment(sk, skb, ip6_finish_output2);
         else
-                return ip6_finish_output2(skb);
+                return ip6_finish_output2(sk, skb);
 }
 
 int ip6_output(struct sock *sk, struct sk_buff *skb)
@@ -143,7 +143,8 @@ int ip6_output(struct sock *sk, struct sk_buff *skb)
                 return 0;
         }
 
-        return NF_HOOK_COND(NFPROTO_IPV6, NF_INET_POST_ROUTING, skb, NULL, dev,
+        return NF_HOOK_COND(NFPROTO_IPV6, NF_INET_POST_ROUTING, sk, skb,
+                            NULL, dev,
                             ip6_finish_output,
                             !(IP6CB(skb)->flags & IP6SKB_REROUTED));
 }
@@ -223,8 +224,8 @@ int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6,
         if ((skb->len <= mtu) || skb->ignore_df || skb_is_gso(skb)) {
                 IP6_UPD_PO_STATS(net, ip6_dst_idev(skb_dst(skb)),
                               IPSTATS_MIB_OUT, skb->len);
-                return NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL,
-                               dst->dev, dst_output);
+                return NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, sk, skb,
+                               NULL, dst->dev, dst_output_sk);
         }
 
         skb->dev = dst->dev;
@@ -316,10 +317,10 @@ static int ip6_forward_proxy_check(struct sk_buff *skb)
         return 0;
 }
 
-static inline int ip6_forward_finish(struct sk_buff *skb)
+static inline int ip6_forward_finish(struct sock *sk, struct sk_buff *skb)
 {
         skb_sender_cpu_clear(skb);
-        return dst_output(skb);
+        return dst_output_sk(sk, skb);
 }
 
 static unsigned int ip6_dst_mtu_forward(const struct dst_entry *dst)
@@ -511,7 +512,8 @@ int ip6_forward(struct sk_buff *skb)
 
         IP6_INC_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTFORWDATAGRAMS);
         IP6_ADD_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTOCTETS, skb->len);
-        return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, skb, skb->dev, dst->dev,
+        return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, NULL, skb,
+                       skb->dev, dst->dev,
                        ip6_forward_finish);
 
 error:
@@ -538,11 +540,13 @@ static void ip6_copy_metadata(struct sk_buff *to, struct sk_buff *from)
         skb_copy_secmark(to, from);
 }
 
-int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
+int ip6_fragment(struct sock *sk, struct sk_buff *skb,
+                 int (*output)(struct sock *, struct sk_buff *))
 {
         struct sk_buff *frag;
         struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
-        struct ipv6_pinfo *np = skb->sk ? inet6_sk(skb->sk) : NULL;
+        struct ipv6_pinfo *np = skb->sk && !dev_recursion_level() ?
+                                inet6_sk(skb->sk) : NULL;
         struct ipv6hdr *tmp_hdr;
         struct frag_hdr *fh;
         unsigned int mtu, hlen, left, len;
@@ -666,7 +670,7 @@ int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
                                 ip6_copy_metadata(frag, skb);
                         }
 
-                        err = output(skb);
+                        err = output(sk, skb);
                         if (!err)
                                 IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
                                               IPSTATS_MIB_FRAGCREATES);
@@ -799,7 +803,7 @@ slow_path:
                 /*
                  *      Put this fragment into the sending queue.
                  */
-                err = output(frag);
+                err = output(sk, frag);
                 if (err)
                         goto fail;
 
diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c
index 9bd85f0dff69..5cafd92c2312 100644
--- a/net/ipv6/ip6_tunnel.c
+++ b/net/ipv6/ip6_tunnel.c
@@ -1100,7 +1100,7 @@ static int ip6_tnl_xmit2(struct sk_buff *skb,
         ipv6h->nexthdr = proto;
         ipv6h->saddr = fl6->saddr;
         ipv6h->daddr = fl6->daddr;
-        ip6tunnel_xmit(skb, dev);
+        ip6tunnel_xmit(NULL, skb, dev);
         if (ndst)
                 ip6_tnl_dst_store(t, ndst);
         return 0;
@@ -1264,8 +1264,6 @@ static void ip6_tnl_link_config(struct ip6_tnl *t)
         else
                 dev->flags &= ~IFF_POINTOPOINT;
 
-        dev->iflink = p->link;
-
         if (p->flags & IP6_TNL_F_CAP_XMIT) {
                 int strict = (ipv6_addr_type(&p->raddr) &
                               (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));
@@ -1517,6 +1515,13 @@ ip6_tnl_change_mtu(struct net_device *dev, int new_mtu)
         return 0;
 }
 
+int ip6_tnl_get_iflink(const struct net_device *dev)
+{
+        struct ip6_tnl *t = netdev_priv(dev);
+
+        return t->parms.link;
+}
+EXPORT_SYMBOL(ip6_tnl_get_iflink);
 
 static const struct net_device_ops ip6_tnl_netdev_ops = {
         .ndo_init       = ip6_tnl_dev_init,
@@ -1525,6 +1530,7 @@ static const struct net_device_ops ip6_tnl_netdev_ops = {
         .ndo_do_ioctl   = ip6_tnl_ioctl,
         .ndo_change_mtu = ip6_tnl_change_mtu,
         .ndo_get_stats  = ip6_get_stats,
+        .ndo_get_iflink = ip6_tnl_get_iflink,
 };
 
 
diff --git a/net/ipv6/ip6_udp_tunnel.c b/net/ipv6/ip6_udp_tunnel.c
index 32d9b268e7d8..bba8903e871f 100644
--- a/net/ipv6/ip6_udp_tunnel.c
+++ b/net/ipv6/ip6_udp_tunnel.c
@@ -62,7 +62,8 @@ error:
 }
 EXPORT_SYMBOL_GPL(udp_sock_create6);
 
-int udp_tunnel6_xmit_skb(struct dst_entry *dst, struct sk_buff *skb,
+int udp_tunnel6_xmit_skb(struct dst_entry *dst, struct sock *sk,
+                         struct sk_buff *skb,
                          struct net_device *dev, struct in6_addr *saddr,
                          struct in6_addr *daddr,
                          __u8 prio, __u8 ttl, __be16 src_port,
@@ -97,7 +98,7 @@ int udp_tunnel6_xmit_skb(struct dst_entry *dst, struct sk_buff *skb,
         ip6h->daddr       = *daddr;
         ip6h->saddr       = *saddr;
 
-        ip6tunnel_xmit(skb, dev);
+        ip6tunnel_xmit(sk, skb, dev);
         return 0;
 }
 EXPORT_SYMBOL_GPL(udp_tunnel6_xmit_skb);
diff --git a/net/ipv6/ip6_vti.c b/net/ipv6/ip6_vti.c
index 53d90ed68905..b53148444e15 100644
--- a/net/ipv6/ip6_vti.c
+++ b/net/ipv6/ip6_vti.c
@@ -601,8 +601,6 @@ static void vti6_link_config(struct ip6_tnl *t)
                 dev->flags |= IFF_POINTOPOINT;
         else
                 dev->flags &= ~IFF_POINTOPOINT;
-
-        dev->iflink = p->link;
 }
 
 /**
@@ -808,6 +806,7 @@ static const struct net_device_ops vti6_netdev_ops = {
         .ndo_do_ioctl   = vti6_ioctl,
         .ndo_change_mtu = vti6_change_mtu,
         .ndo_get_stats64 = ip_tunnel_get_stats64,
+        .ndo_get_iflink = ip6_tnl_get_iflink,
 };
 
 /**
diff --git a/net/ipv6/ip6mr.c b/net/ipv6/ip6mr.c
index caf6b99374e6..74ceb73c1c9a 100644
--- a/net/ipv6/ip6mr.c
+++ b/net/ipv6/ip6mr.c
@@ -250,7 +250,7 @@ static int __net_init ip6mr_rules_init(struct net *net)
         return 0;
 
 err2:
-        kfree(mrt);
+        ip6mr_free_table(mrt);
 err1:
         fib_rules_unregister(ops);
         return err;
@@ -265,8 +265,8 @@ static void __net_exit ip6mr_rules_exit(struct net *net)
                 list_del(&mrt->list);
                 ip6mr_free_table(mrt);
         }
-        rtnl_unlock();
         fib_rules_unregister(net->ipv6.mr6_rules_ops);
+        rtnl_unlock();
 }
 #else
 #define ip6mr_for_each_table(mrt, net) \
@@ -334,7 +334,7 @@ static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
 
 static void ip6mr_free_table(struct mr6_table *mrt)
 {
-        del_timer(&mrt->ipmr_expire_timer);
+        del_timer_sync(&mrt->ipmr_expire_timer);
         mroute_clean_tables(mrt);
         kfree(mrt);
 }
@@ -718,8 +718,14 @@ static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
         return NETDEV_TX_OK;
 }
 
+static int reg_vif_get_iflink(const struct net_device *dev)
+{
+        return 0;
+}
+
 static const struct net_device_ops reg_vif_netdev_ops = {
         .ndo_start_xmit = reg_vif_xmit,
+        .ndo_get_iflink = reg_vif_get_iflink,
 };
 
 static void reg_vif_setup(struct net_device *dev)
@@ -752,7 +758,6 @@ static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
                 free_netdev(dev);
                 return NULL;
         }
-        dev->iflink = 0;
 
         if (dev_open(dev))
                 goto failure;
@@ -992,7 +997,7 @@ static int mif6_add(struct net *net, struct mr6_table *mrt,
         v->pkt_out = 0;
         v->link = dev->ifindex;
         if (v->flags & MIFF_REGISTER)
-                v->link = dev->iflink;
+                v->link = dev_get_iflink(dev);
 
         /* And finish update writing critical data */
         write_lock_bh(&mrt_lock);
@@ -1981,13 +1986,13 @@ int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
 }
 #endif
 
-static inline int ip6mr_forward2_finish(struct sk_buff *skb)
+static inline int ip6mr_forward2_finish(struct sock *sk, struct sk_buff *skb)
 {
         IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
                          IPSTATS_MIB_OUTFORWDATAGRAMS);
         IP6_ADD_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
                          IPSTATS_MIB_OUTOCTETS, skb->len);
-        return dst_output(skb);
+        return dst_output_sk(sk, skb);
 }
 
 /*
@@ -2059,7 +2064,8 @@ static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
 
         IP6CB(skb)->flags |= IP6SKB_FORWARDED;
 
-        return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, skb, skb->dev, dev,
+        return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, NULL, skb,
+                       skb->dev, dev,
                        ip6mr_forward2_finish);
 
 out_free:
diff --git a/net/ipv6/mcast.c b/net/ipv6/mcast.c
index fac1f27e428e..083b2927fc67 100644
--- a/net/ipv6/mcast.c
+++ b/net/ipv6/mcast.c
@@ -1644,8 +1644,9 @@ static void mld_sendpack(struct sk_buff *skb)
 
         payload_len = skb->len;
 
-        err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, skb->dev,
-                      dst_output);
+        err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT,
+                      net->ipv6.igmp_sk, skb, NULL, skb->dev,
+                      dst_output_sk);
 out:
         if (!err) {
                 ICMP6MSGOUT_INC_STATS(net, idev, ICMPV6_MLD2_REPORT);
@@ -2007,8 +2008,8 @@ static void igmp6_send(struct in6_addr *addr, struct net_device *dev, int type)
         }
 
         skb_dst_set(skb, dst);
-        err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, skb->dev,
-                      dst_output);
+        err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, sk, skb,
+                      NULL, skb->dev, dst_output_sk);
 out:
         if (!err) {
                 ICMP6MSGOUT_INC_STATS(net, idev, type);
diff --git a/net/ipv6/ndisc.c b/net/ipv6/ndisc.c
index c283827d60e2..96f153c0846b 100644
--- a/net/ipv6/ndisc.c
+++ b/net/ipv6/ndisc.c
@@ -463,8 +463,9 @@ static void ndisc_send_skb(struct sk_buff *skb,
         idev = __in6_dev_get(dst->dev);
         IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
 
-        err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
-                      dst_output);
+        err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, sk, skb,
+                      NULL, dst->dev,
+                      dst_output_sk);
         if (!err) {
                 ICMP6MSGOUT_INC_STATS(net, idev, type);
                 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
@@ -1225,7 +1226,14 @@ static void ndisc_router_discovery(struct sk_buff *skb)
         if (rt)
                 rt6_set_expires(rt, jiffies + (HZ * lifetime));
         if (ra_msg->icmph.icmp6_hop_limit) {
-                in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
+                /* Only set hop_limit on the interface if it is higher than
+                 * the current hop_limit.
+                 */
+                if (in6_dev->cnf.hop_limit < ra_msg->icmph.icmp6_hop_limit) {
+                        in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
+                } else {
+                        ND_PRINTK(2, warn, "RA: Got route advertisement with lower hop_limit than current\n");
+                }
                 if (rt)
                         dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
                                        ra_msg->icmph.icmp6_hop_limit);
diff --git a/net/ipv6/netfilter.c b/net/ipv6/netfilter.c
index 398377a9d018..d958718b5031 100644
--- a/net/ipv6/netfilter.c
+++ b/net/ipv6/netfilter.c
@@ -84,7 +84,7 @@ static void nf_ip6_saveroute(const struct sk_buff *skb,
 {
         struct ip6_rt_info *rt_info = nf_queue_entry_reroute(entry);
 
-        if (entry->hook == NF_INET_LOCAL_OUT) {
+        if (entry->state.hook == NF_INET_LOCAL_OUT) {
                 const struct ipv6hdr *iph = ipv6_hdr(skb);
 
                 rt_info->daddr = iph->daddr;
@@ -98,7 +98,7 @@ static int nf_ip6_reroute(struct sk_buff *skb,
 {
         struct ip6_rt_info *rt_info = nf_queue_entry_reroute(entry);
 
-        if (entry->hook == NF_INET_LOCAL_OUT) {
+        if (entry->state.hook == NF_INET_LOCAL_OUT) {
                 const struct ipv6hdr *iph = ipv6_hdr(skb);
                 if (!ipv6_addr_equal(&iph->daddr, &rt_info->daddr) ||
                     !ipv6_addr_equal(&iph->saddr, &rt_info->saddr) ||
diff --git a/net/ipv6/netfilter/ip6_tables.c b/net/ipv6/netfilter/ip6_tables.c
index 83f59dc3cccc..1a732a1d3c8e 100644
--- a/net/ipv6/netfilter/ip6_tables.c
+++ b/net/ipv6/netfilter/ip6_tables.c
@@ -317,8 +317,7 @@ ip6t_next_entry(const struct ip6t_entry *entry)
 unsigned int
 ip6t_do_table(struct sk_buff *skb,
               unsigned int hook,
-              const struct net_device *in,
-              const struct net_device *out,
+              const struct nf_hook_state *state,
               struct xt_table *table)
 {
         static const char nulldevname[IFNAMSIZ] __attribute__((aligned(sizeof(long))));
@@ -333,8 +332,8 @@ ip6t_do_table(struct sk_buff *skb,
         unsigned int addend;
 
         /* Initialization */
-        indev = in ? in->name : nulldevname;
-        outdev = out ? out->name : nulldevname;
+        indev = state->in ? state->in->name : nulldevname;
+        outdev = state->out ? state->out->name : nulldevname;
         /* We handle fragments by dealing with the first fragment as
          * if it was a normal packet.  All other fragments are treated
          * normally, except that they will NEVER match rules that ask
@@ -342,8 +341,8 @@ ip6t_do_table(struct sk_buff *skb,
          * rule is also a fragment-specific rule, non-fragments won't
          * match it. */
         acpar.hotdrop = false;
-        acpar.in      = in;
-        acpar.out     = out;
+        acpar.in      = state->in;
+        acpar.out     = state->out;
         acpar.family  = NFPROTO_IPV6;
         acpar.hooknum = hook;
 
@@ -393,7 +392,7 @@ ip6t_do_table(struct sk_buff *skb,
 #if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE)
                 /* The packet is traced: log it */
                 if (unlikely(skb->nf_trace))
-                        trace_packet(skb, hook, in, out,
+                        trace_packet(skb, hook, state->in, state->out,
                                      table->name, private, e);
 #endif
                 /* Standard target? */
diff --git a/net/ipv6/netfilter/ip6t_SYNPROXY.c b/net/ipv6/netfilter/ip6t_SYNPROXY.c
index a0d17270117c..6edb7b106de7 100644
--- a/net/ipv6/netfilter/ip6t_SYNPROXY.c
+++ b/net/ipv6/netfilter/ip6t_SYNPROXY.c
@@ -315,11 +315,9 @@ synproxy_tg6(struct sk_buff *skb, const struct xt_action_param *par)
 
 static unsigned int ipv6_synproxy_hook(const struct nf_hook_ops *ops,
                                        struct sk_buff *skb,
-                                       const struct net_device *in,
-                                       const struct net_device *out,
-                                       int (*okfn)(struct sk_buff *))
+                                       const struct nf_hook_state *nhs)
 {
-        struct synproxy_net *snet = synproxy_pernet(dev_net(in ? : out));
+        struct synproxy_net *snet = synproxy_pernet(dev_net(nhs->in ? : nhs->out));
         enum ip_conntrack_info ctinfo;
         struct nf_conn *ct;
         struct nf_conn_synproxy *synproxy;
diff --git a/net/ipv6/netfilter/ip6table_filter.c b/net/ipv6/netfilter/ip6table_filter.c
index ca7f6c128086..5c33d8abc077 100644
--- a/net/ipv6/netfilter/ip6table_filter.c
+++ b/net/ipv6/netfilter/ip6table_filter.c
@@ -33,13 +33,11 @@ static const struct xt_table packet_filter = {
 /* The work comes in here from netfilter.c. */
 static unsigned int
 ip6table_filter_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                     const struct net_device *in, const struct net_device *out,
-                     int (*okfn)(struct sk_buff *))
+                     const struct nf_hook_state *state)
 {
-        const struct net *net = dev_net((in != NULL) ? in : out);
+        const struct net *net = dev_net(state->in ? state->in : state->out);
 
-        return ip6t_do_table(skb, ops->hooknum, in, out,
-                             net->ipv6.ip6table_filter);
+        return ip6t_do_table(skb, ops->hooknum, state, net->ipv6.ip6table_filter);
 }
 
 static struct nf_hook_ops *filter_ops __read_mostly;
diff --git a/net/ipv6/netfilter/ip6table_mangle.c b/net/ipv6/netfilter/ip6table_mangle.c
index 307bbb782d14..b551f5b79fe2 100644
--- a/net/ipv6/netfilter/ip6table_mangle.c
+++ b/net/ipv6/netfilter/ip6table_mangle.c
@@ -32,7 +32,7 @@ static const struct xt_table packet_mangler = {
 };
 
 static unsigned int
-ip6t_mangle_out(struct sk_buff *skb, const struct net_device *out)
+ip6t_mangle_out(struct sk_buff *skb, const struct nf_hook_state *state)
 {
         unsigned int ret;
         struct in6_addr saddr, daddr;
@@ -57,8 +57,8 @@ ip6t_mangle_out(struct sk_buff *skb, const struct net_device *out)
         /* flowlabel and prio (includes version, which shouldn't change either */
         flowlabel = *((u_int32_t *)ipv6_hdr(skb));
 
-        ret = ip6t_do_table(skb, NF_INET_LOCAL_OUT, NULL, out,
-                            dev_net(out)->ipv6.ip6table_mangle);
+        ret = ip6t_do_table(skb, NF_INET_LOCAL_OUT, state,
+                            dev_net(state->out)->ipv6.ip6table_mangle);
 
         if (ret != NF_DROP && ret != NF_STOLEN &&
             (!ipv6_addr_equal(&ipv6_hdr(skb)->saddr, &saddr) ||
@@ -77,17 +77,16 @@ ip6t_mangle_out(struct sk_buff *skb, const struct net_device *out)
 /* The work comes in here from netfilter.c. */
 static unsigned int
 ip6table_mangle_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                     const struct net_device *in, const struct net_device *out,
-                     int (*okfn)(struct sk_buff *))
+                     const struct nf_hook_state *state)
 {
         if (ops->hooknum == NF_INET_LOCAL_OUT)
-                return ip6t_mangle_out(skb, out);
+                return ip6t_mangle_out(skb, state);
         if (ops->hooknum == NF_INET_POST_ROUTING)
-                return ip6t_do_table(skb, ops->hooknum, in, out,
-                                     dev_net(out)->ipv6.ip6table_mangle);
+                return ip6t_do_table(skb, ops->hooknum, state,
+                                     dev_net(state->out)->ipv6.ip6table_mangle);
         /* INPUT/FORWARD */
-        return ip6t_do_table(skb, ops->hooknum, in, out,
-                             dev_net(in)->ipv6.ip6table_mangle);
+        return ip6t_do_table(skb, ops->hooknum, state,
+                             dev_net(state->in)->ipv6.ip6table_mangle);
 }
 
 static struct nf_hook_ops *mangle_ops __read_mostly;
diff --git a/net/ipv6/netfilter/ip6table_nat.c b/net/ipv6/netfilter/ip6table_nat.c
index b0634ac996b7..c3a7f7af0ed4 100644
--- a/net/ipv6/netfilter/ip6table_nat.c
+++ b/net/ipv6/netfilter/ip6table_nat.c
@@ -32,49 +32,40 @@ static const struct xt_table nf_nat_ipv6_table = {
 
 static unsigned int ip6table_nat_do_chain(const struct nf_hook_ops *ops,
                                           struct sk_buff *skb,
-                                          const struct net_device *in,
-                                          const struct net_device *out,
+                                          const struct nf_hook_state *state,
                                           struct nf_conn *ct)
 {
         struct net *net = nf_ct_net(ct);
 
-        return ip6t_do_table(skb, ops->hooknum, in, out, net->ipv6.ip6table_nat);
+        return ip6t_do_table(skb, ops->hooknum, state, net->ipv6.ip6table_nat);
 }
 
 static unsigned int ip6table_nat_fn(const struct nf_hook_ops *ops,
                                     struct sk_buff *skb,
-                                    const struct net_device *in,
-                                    const struct net_device *out,
-                                    int (*okfn)(struct sk_buff *))
+                                    const struct nf_hook_state *state)
 {
-        return nf_nat_ipv6_fn(ops, skb, in, out, ip6table_nat_do_chain);
+        return nf_nat_ipv6_fn(ops, skb, state, ip6table_nat_do_chain);
 }
 
 static unsigned int ip6table_nat_in(const struct nf_hook_ops *ops,
                                     struct sk_buff *skb,
-                                    const struct net_device *in,
-                                    const struct net_device *out,
-                                    int (*okfn)(struct sk_buff *))
+                                    const struct nf_hook_state *state)
 {
-        return nf_nat_ipv6_in(ops, skb, in, out, ip6table_nat_do_chain);
+        return nf_nat_ipv6_in(ops, skb, state, ip6table_nat_do_chain);
 }
 
 static unsigned int ip6table_nat_out(const struct nf_hook_ops *ops,
                                      struct sk_buff *skb,
-                                     const struct net_device *in,
-                                     const struct net_device *out,
-                                     int (*okfn)(struct sk_buff *))
+                                     const struct nf_hook_state *state)
 {
-        return nf_nat_ipv6_out(ops, skb, in, out, ip6table_nat_do_chain);
+        return nf_nat_ipv6_out(ops, skb, state, ip6table_nat_do_chain);
 }
 
 static unsigned int ip6table_nat_local_fn(const struct nf_hook_ops *ops,
                                           struct sk_buff *skb,
-                                          const struct net_device *in,
-                                          const struct net_device *out,
-                                          int (*okfn)(struct sk_buff *))
+                                          const struct nf_hook_state *state)
 {
-        return nf_nat_ipv6_local_fn(ops, skb, in, out, ip6table_nat_do_chain);
+        return nf_nat_ipv6_local_fn(ops, skb, state, ip6table_nat_do_chain);
 }
 
 static struct nf_hook_ops nf_nat_ipv6_ops[] __read_mostly = {
diff --git a/net/ipv6/netfilter/ip6table_raw.c b/net/ipv6/netfilter/ip6table_raw.c
index 5274740acecc..0b33caad2b69 100644
--- a/net/ipv6/netfilter/ip6table_raw.c
+++ b/net/ipv6/netfilter/ip6table_raw.c
@@ -20,13 +20,11 @@ static const struct xt_table packet_raw = {
 /* The work comes in here from netfilter.c. */
 static unsigned int
 ip6table_raw_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                  const struct net_device *in, const struct net_device *out,
-                  int (*okfn)(struct sk_buff *))
+                  const struct nf_hook_state *state)
 {
-        const struct net *net = dev_net((in != NULL) ? in : out);
+        const struct net *net = dev_net(state->in ? state->in : state->out);
 
-        return ip6t_do_table(skb, ops->hooknum, in, out,
-                             net->ipv6.ip6table_raw);
+        return ip6t_do_table(skb, ops->hooknum, state, net->ipv6.ip6table_raw);
 }
 
 static struct nf_hook_ops *rawtable_ops __read_mostly;
diff --git a/net/ipv6/netfilter/ip6table_security.c b/net/ipv6/netfilter/ip6table_security.c
index ab3b0219ecfa..fcef83c25f7b 100644
--- a/net/ipv6/netfilter/ip6table_security.c
+++ b/net/ipv6/netfilter/ip6table_security.c
@@ -37,13 +37,11 @@ static const struct xt_table security_table = {
 
 static unsigned int
 ip6table_security_hook(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                       const struct net_device *in,
-                       const struct net_device *out,
-                       int (*okfn)(struct sk_buff *))
+                       const struct nf_hook_state *state)
 {
-        const struct net *net = dev_net((in != NULL) ? in : out);
+        const struct net *net = dev_net(state->in ? state->in : state->out);
 
-        return ip6t_do_table(skb, ops->hooknum, in, out,
+        return ip6t_do_table(skb, ops->hooknum, state,
                              net->ipv6.ip6table_security);
 }
 
diff --git a/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c b/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
index fba91c6fc7ca..4ba0c34c627b 100644
--- a/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
+++ b/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
@@ -97,9 +97,7 @@ static int ipv6_get_l4proto(const struct sk_buff *skb, unsigned int nhoff,
 
 static unsigned int ipv6_helper(const struct nf_hook_ops *ops,
                                 struct sk_buff *skb,
-                                const struct net_device *in,
-                                const struct net_device *out,
-                                int (*okfn)(struct sk_buff *))
+                                const struct nf_hook_state *state)
 {
         struct nf_conn *ct;
         const struct nf_conn_help *help;
@@ -135,9 +133,7 @@ static unsigned int ipv6_helper(const struct nf_hook_ops *ops,
 
 static unsigned int ipv6_confirm(const struct nf_hook_ops *ops,
                                  struct sk_buff *skb,
-                                 const struct net_device *in,
-                                 const struct net_device *out,
-                                 int (*okfn)(struct sk_buff *))
+                                 const struct nf_hook_state *state)
 {
         struct nf_conn *ct;
         enum ip_conntrack_info ctinfo;
@@ -171,25 +167,21 @@ out:
 
 static unsigned int ipv6_conntrack_in(const struct nf_hook_ops *ops,
                                       struct sk_buff *skb,
-                                      const struct net_device *in,
-                                      const struct net_device *out,
-                                      int (*okfn)(struct sk_buff *))
+                                      const struct nf_hook_state *state)
 {
-        return nf_conntrack_in(dev_net(in), PF_INET6, ops->hooknum, skb);
+        return nf_conntrack_in(dev_net(state->in), PF_INET6, ops->hooknum, skb);
 }
 
 static unsigned int ipv6_conntrack_local(const struct nf_hook_ops *ops,
                                          struct sk_buff *skb,
-                                         const struct net_device *in,
-                                         const struct net_device *out,
-                                         int (*okfn)(struct sk_buff *))
+                                         const struct nf_hook_state *state)
 {
         /* root is playing with raw sockets. */
         if (skb->len < sizeof(struct ipv6hdr)) {
                 net_notice_ratelimited("ipv6_conntrack_local: packet too short\n");
                 return NF_ACCEPT;
         }
-        return nf_conntrack_in(dev_net(out), PF_INET6, ops->hooknum, skb);
+        return nf_conntrack_in(dev_net(state->out), PF_INET6, ops->hooknum, skb);
 }
 
 static struct nf_hook_ops ipv6_conntrack_ops[] __read_mostly = {
diff --git a/net/ipv6/netfilter/nf_defrag_ipv6_hooks.c b/net/ipv6/netfilter/nf_defrag_ipv6_hooks.c
index e70382e4dfb5..a45db0b4785c 100644
--- a/net/ipv6/netfilter/nf_defrag_ipv6_hooks.c
+++ b/net/ipv6/netfilter/nf_defrag_ipv6_hooks.c
@@ -54,9 +54,7 @@ static enum ip6_defrag_users nf_ct6_defrag_user(unsigned int hooknum,
 
 static unsigned int ipv6_defrag(const struct nf_hook_ops *ops,
                                 struct sk_buff *skb,
-                                const struct net_device *in,
-                                const struct net_device *out,
-                                int (*okfn)(struct sk_buff *))
+                                const struct nf_hook_state *state)
 {
         struct sk_buff *reasm;
 
@@ -77,9 +75,9 @@ static unsigned int ipv6_defrag(const struct nf_hook_ops *ops,
 
         nf_ct_frag6_consume_orig(reasm);
 
-        NF_HOOK_THRESH(NFPROTO_IPV6, ops->hooknum, reasm,
-                       (struct net_device *) in, (struct net_device *) out,
-                       okfn, NF_IP6_PRI_CONNTRACK_DEFRAG + 1);
+        NF_HOOK_THRESH(NFPROTO_IPV6, ops->hooknum, state->sk, reasm,
+                       state->in, state->out,
+                       state->okfn, NF_IP6_PRI_CONNTRACK_DEFRAG + 1);
 
         return NF_STOLEN;
 }
diff --git a/net/ipv6/netfilter/nf_nat_l3proto_ipv6.c b/net/ipv6/netfilter/nf_nat_l3proto_ipv6.c
index c5812e1c1ffb..e76900e0aa92 100644
--- a/net/ipv6/netfilter/nf_nat_l3proto_ipv6.c
+++ b/net/ipv6/netfilter/nf_nat_l3proto_ipv6.c
@@ -263,11 +263,10 @@ EXPORT_SYMBOL_GPL(nf_nat_icmpv6_reply_translation);
 
 unsigned int
 nf_nat_ipv6_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
-               const struct net_device *in, const struct net_device *out,
+               const struct nf_hook_state *state,
                unsigned int (*do_chain)(const struct nf_hook_ops *ops,
                                         struct sk_buff *skb,
-                                        const struct net_device *in,
-                                        const struct net_device *out,
+                                        const struct nf_hook_state *state,
                                         struct nf_conn *ct))
 {
         struct nf_conn *ct;
@@ -318,7 +317,7 @@ nf_nat_ipv6_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
                 if (!nf_nat_initialized(ct, maniptype)) {
                         unsigned int ret;
 
-                        ret = do_chain(ops, skb, in, out, ct);
+                        ret = do_chain(ops, skb, state, ct);
                         if (ret != NF_ACCEPT)
                                 return ret;
 
@@ -332,7 +331,7 @@ nf_nat_ipv6_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
                         pr_debug("Already setup manip %s for ct %p\n",
                                  maniptype == NF_NAT_MANIP_SRC ? "SRC" : "DST",
                                  ct);
-                        if (nf_nat_oif_changed(ops->hooknum, ctinfo, nat, out))
+                        if (nf_nat_oif_changed(ops->hooknum, ctinfo, nat, state->out))
                                 goto oif_changed;
                 }
                 break;
@@ -341,7 +340,7 @@ nf_nat_ipv6_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
                 /* ESTABLISHED */
                 NF_CT_ASSERT(ctinfo == IP_CT_ESTABLISHED ||
                              ctinfo == IP_CT_ESTABLISHED_REPLY);
-                if (nf_nat_oif_changed(ops->hooknum, ctinfo, nat, out))
+                if (nf_nat_oif_changed(ops->hooknum, ctinfo, nat, state->out))
                         goto oif_changed;
         }
 
@@ -355,17 +354,16 @@ EXPORT_SYMBOL_GPL(nf_nat_ipv6_fn);
 
 unsigned int
 nf_nat_ipv6_in(const struct nf_hook_ops *ops, struct sk_buff *skb,
-               const struct net_device *in, const struct net_device *out,
+               const struct nf_hook_state *state,
                unsigned int (*do_chain)(const struct nf_hook_ops *ops,
                                         struct sk_buff *skb,
-                                        const struct net_device *in,
-                                        const struct net_device *out,
+                                        const struct nf_hook_state *state,
                                         struct nf_conn *ct))
 {
         unsigned int ret;
         struct in6_addr daddr = ipv6_hdr(skb)->daddr;
 
-        ret = nf_nat_ipv6_fn(ops, skb, in, out, do_chain);
+        ret = nf_nat_ipv6_fn(ops, skb, state, do_chain);
         if (ret != NF_DROP && ret != NF_STOLEN &&
             ipv6_addr_cmp(&daddr, &ipv6_hdr(skb)->daddr))
                 skb_dst_drop(skb);
@@ -376,11 +374,10 @@ EXPORT_SYMBOL_GPL(nf_nat_ipv6_in);
 
 unsigned int
 nf_nat_ipv6_out(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                const struct net_device *in, const struct net_device *out,
+                const struct nf_hook_state *state,
                 unsigned int (*do_chain)(const struct nf_hook_ops *ops,
                                          struct sk_buff *skb,
-                                         const struct net_device *in,
-                                         const struct net_device *out,
+                                         const struct nf_hook_state *state,
                                          struct nf_conn *ct))
 {
 #ifdef CONFIG_XFRM
@@ -394,7 +391,7 @@ nf_nat_ipv6_out(const struct nf_hook_ops *ops, struct sk_buff *skb,
         if (skb->len < sizeof(struct ipv6hdr))
                 return NF_ACCEPT;
 
-        ret = nf_nat_ipv6_fn(ops, skb, in, out, do_chain);
+        ret = nf_nat_ipv6_fn(ops, skb, state, do_chain);
 #ifdef CONFIG_XFRM
         if (ret != NF_DROP && ret != NF_STOLEN &&
             !(IP6CB(skb)->flags & IP6SKB_XFRM_TRANSFORMED) &&
@@ -418,11 +415,10 @@ EXPORT_SYMBOL_GPL(nf_nat_ipv6_out);
 
 unsigned int
 nf_nat_ipv6_local_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                     const struct net_device *in, const struct net_device *out,
+                     const struct nf_hook_state *state,
                      unsigned int (*do_chain)(const struct nf_hook_ops *ops,
                                               struct sk_buff *skb,
-                                              const struct net_device *in,
-                                              const struct net_device *out,
+                                              const struct nf_hook_state *state,
                                               struct nf_conn *ct))
 {
         const struct nf_conn *ct;
@@ -434,7 +430,7 @@ nf_nat_ipv6_local_fn(const struct nf_hook_ops *ops, struct sk_buff *skb,
         if (skb->len < sizeof(struct ipv6hdr))
                 return NF_ACCEPT;
 
-        ret = nf_nat_ipv6_fn(ops, skb, in, out, do_chain);
+        ret = nf_nat_ipv6_fn(ops, skb, state, do_chain);
         if (ret != NF_DROP && ret != NF_STOLEN &&
             (ct = nf_ct_get(skb, &ctinfo)) != NULL) {
                 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
diff --git a/net/ipv6/netfilter/nf_tables_ipv6.c b/net/ipv6/netfilter/nf_tables_ipv6.c
index 0d812b31277d..c8148ba76d1a 100644
--- a/net/ipv6/netfilter/nf_tables_ipv6.c
+++ b/net/ipv6/netfilter/nf_tables_ipv6.c
@@ -18,14 +18,12 @@
 
 static unsigned int nft_do_chain_ipv6(const struct nf_hook_ops *ops,
                                       struct sk_buff *skb,
-                                      const struct net_device *in,
-                                      const struct net_device *out,
-                                      int (*okfn)(struct sk_buff *))
+                                      const struct nf_hook_state *state)
 {
         struct nft_pktinfo pkt;
 
         /* malformed packet, drop it */
-        if (nft_set_pktinfo_ipv6(&pkt, ops, skb, in, out) < 0)
+        if (nft_set_pktinfo_ipv6(&pkt, ops, skb, state) < 0)
                 return NF_DROP;
 
         return nft_do_chain(&pkt, ops);
@@ -33,9 +31,7 @@ static unsigned int nft_do_chain_ipv6(const struct nf_hook_ops *ops,
 
 static unsigned int nft_ipv6_output(const struct nf_hook_ops *ops,
                                     struct sk_buff *skb,
-                                    const struct net_device *in,
-                                    const struct net_device *out,
-                                    int (*okfn)(struct sk_buff *))
+                                    const struct nf_hook_state *state)
 {
         if (unlikely(skb->len < sizeof(struct ipv6hdr))) {
                 if (net_ratelimit())
@@ -44,7 +40,7 @@ static unsigned int nft_ipv6_output(const struct nf_hook_ops *ops,
                 return NF_ACCEPT;
         }
 
-        return nft_do_chain_ipv6(ops, skb, in, out, okfn);
+        return nft_do_chain_ipv6(ops, skb, state);
 }
 
 struct nft_af_info nft_af_ipv6 __read_mostly = {
diff --git a/net/ipv6/netfilter/nft_chain_nat_ipv6.c b/net/ipv6/netfilter/nft_chain_nat_ipv6.c
index 1c4b75dd425b..951bb458b7bd 100644
--- a/net/ipv6/netfilter/nft_chain_nat_ipv6.c
+++ b/net/ipv6/netfilter/nft_chain_nat_ipv6.c
@@ -26,51 +26,42 @@
 
 static unsigned int nft_nat_do_chain(const struct nf_hook_ops *ops,
                                      struct sk_buff *skb,
-                                     const struct net_device *in,
-                                     const struct net_device *out,
+                                     const struct nf_hook_state *state,
                                      struct nf_conn *ct)
 {
         struct nft_pktinfo pkt;
 
-        nft_set_pktinfo_ipv6(&pkt, ops, skb, in, out);
+        nft_set_pktinfo_ipv6(&pkt, ops, skb, state);
 
         return nft_do_chain(&pkt, ops);
 }
 
 static unsigned int nft_nat_ipv6_fn(const struct nf_hook_ops *ops,
                                     struct sk_buff *skb,
-                                    const struct net_device *in,
-                                    const struct net_device *out,
-                                    int (*okfn)(struct sk_buff *))
+                                    const struct nf_hook_state *state)
 {
-        return nf_nat_ipv6_fn(ops, skb, in, out, nft_nat_do_chain);
+        return nf_nat_ipv6_fn(ops, skb, state, nft_nat_do_chain);
 }
 
 static unsigned int nft_nat_ipv6_in(const struct nf_hook_ops *ops,
                                     struct sk_buff *skb,
-                                    const struct net_device *in,
-                                    const struct net_device *out,
-                                    int (*okfn)(struct sk_buff *))
+                                    const struct nf_hook_state *state)
 {
-        return nf_nat_ipv6_in(ops, skb, in, out, nft_nat_do_chain);
+        return nf_nat_ipv6_in(ops, skb, state, nft_nat_do_chain);
 }
 
 static unsigned int nft_nat_ipv6_out(const struct nf_hook_ops *ops,
                                      struct sk_buff *skb,
-                                     const struct net_device *in,
-                                     const struct net_device *out,
-                                     int (*okfn)(struct sk_buff *))
+                                     const struct nf_hook_state *state)
 {
-        return nf_nat_ipv6_out(ops, skb, in, out, nft_nat_do_chain);
+        return nf_nat_ipv6_out(ops, skb, state, nft_nat_do_chain);
 }
 
 static unsigned int nft_nat_ipv6_local_fn(const struct nf_hook_ops *ops,
                                           struct sk_buff *skb,
-                                          const struct net_device *in,
-                                          const struct net_device *out,
-                                          int (*okfn)(struct sk_buff *))
+                                          const struct nf_hook_state *state)
 {
-        return nf_nat_ipv6_local_fn(ops, skb, in, out, nft_nat_do_chain);
+        return nf_nat_ipv6_local_fn(ops, skb, state, nft_nat_do_chain);
 }
 
 static const struct nf_chain_type nft_chain_nat_ipv6 = {
diff --git a/net/ipv6/netfilter/nft_chain_route_ipv6.c b/net/ipv6/netfilter/nft_chain_route_ipv6.c
index 42031299585e..0dafdaac5e17 100644
--- a/net/ipv6/netfilter/nft_chain_route_ipv6.c
+++ b/net/ipv6/netfilter/nft_chain_route_ipv6.c
@@ -24,9 +24,7 @@
 
 static unsigned int nf_route_table_hook(const struct nf_hook_ops *ops,
                                         struct sk_buff *skb,
-                                        const struct net_device *in,
-                                        const struct net_device *out,
-                                        int (*okfn)(struct sk_buff *))
+                                        const struct nf_hook_state *state)
 {
         unsigned int ret;
         struct nft_pktinfo pkt;
@@ -35,7 +33,7 @@ static unsigned int nf_route_table_hook(const struct nf_hook_ops *ops,
         u32 mark, flowlabel;
 
         /* malformed packet, drop it */
-        if (nft_set_pktinfo_ipv6(&pkt, ops, skb, in, out) < 0)
+        if (nft_set_pktinfo_ipv6(&pkt, ops, skb, state) < 0)
                 return NF_DROP;
 
         /* save source/dest address, mark, hoplimit, flowlabel, priority */
diff --git a/net/ipv6/output_core.c b/net/ipv6/output_core.c
index 4016a6ef9d61..85892af57364 100644
--- a/net/ipv6/output_core.c
+++ b/net/ipv6/output_core.c
@@ -136,7 +136,7 @@ int ip6_dst_hoplimit(struct dst_entry *dst)
 EXPORT_SYMBOL(ip6_dst_hoplimit);
 #endif
 
-int __ip6_local_out(struct sk_buff *skb)
+static int __ip6_local_out_sk(struct sock *sk, struct sk_buff *skb)
 {
         int len;
 
@@ -146,19 +146,30 @@ int __ip6_local_out(struct sk_buff *skb)
         ipv6_hdr(skb)->payload_len = htons(len);
         IP6CB(skb)->nhoff = offsetof(struct ipv6hdr, nexthdr);
 
-        return nf_hook(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL,
-                       skb_dst(skb)->dev, dst_output);
+        return nf_hook(NFPROTO_IPV6, NF_INET_LOCAL_OUT, sk, skb,
+                       NULL, skb_dst(skb)->dev, dst_output_sk);
+}
+
+int __ip6_local_out(struct sk_buff *skb)
+{
+        return __ip6_local_out_sk(skb->sk, skb);
 }
 EXPORT_SYMBOL_GPL(__ip6_local_out);
 
-int ip6_local_out(struct sk_buff *skb)
+int ip6_local_out_sk(struct sock *sk, struct sk_buff *skb)
 {
         int err;
 
-        err = __ip6_local_out(skb);
+        err = __ip6_local_out_sk(sk, skb);
         if (likely(err == 1))
-                err = dst_output(skb);
+                err = dst_output_sk(sk, skb);
 
         return err;
 }
+EXPORT_SYMBOL_GPL(ip6_local_out_sk);
+
+int ip6_local_out(struct sk_buff *skb)
+{
+        return ip6_local_out_sk(skb->sk, skb);
+}
 EXPORT_SYMBOL_GPL(ip6_local_out);
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index 79ccdb4c1b33..8072bd4139b7 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -652,8 +652,8 @@ static int rawv6_send_hdrinc(struct sock *sk, struct msghdr *msg, int length,
                 goto error_fault;
 
         IP6_UPD_PO_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUT, skb->len);
-        err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL,
-                      rt->dst.dev, dst_output);
+        err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, sk, skb,
+                      NULL, rt->dst.dev, dst_output_sk);
         if (err > 0)
                 err = net_xmit_errno(err);
         if (err)
diff --git a/net/ipv6/sit.c b/net/ipv6/sit.c
index e6b9f51b15e8..6cf2026a9cea 100644
--- a/net/ipv6/sit.c
+++ b/net/ipv6/sit.c
@@ -1076,7 +1076,6 @@ static void ipip6_tunnel_bind_dev(struct net_device *dev)
                 if (dev->mtu < IPV6_MIN_MTU)
                         dev->mtu = IPV6_MIN_MTU;
         }
-        dev->iflink = tunnel->parms.link;
 }
 
 static void ipip6_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p)
@@ -1336,6 +1335,7 @@ static const struct net_device_ops ipip6_netdev_ops = {
         .ndo_do_ioctl   = ipip6_tunnel_ioctl,
         .ndo_change_mtu = ipip6_tunnel_change_mtu,
         .ndo_get_stats64 = ip_tunnel_get_stats64,
+        .ndo_get_iflink = ip_tunnel_get_iflink,
 };
 
 static void ipip6_dev_free(struct net_device *dev)
@@ -1366,7 +1366,6 @@ static void ipip6_tunnel_setup(struct net_device *dev)
         dev->mtu                = ETH_DATA_LEN - t_hlen;
         dev->flags              = IFF_NOARP;
         netif_keep_dst(dev);
-        dev->iflink             = 0;
         dev->addr_len           = 4;
         dev->features           |= NETIF_F_LLTX;
         dev->features           |= SIT_FEATURES;
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 7cdad8401434..f73a97f6e68e 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -1348,6 +1348,15 @@ static void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr,
         TCP_SKB_CB(skb)->sacked = 0;
 }
 
+static void tcp_v6_restore_cb(struct sk_buff *skb)
+{
+        /* We need to move header back to the beginning if xfrm6_policy_check()
+         * and tcp_v6_fill_cb() are going to be called again.
+         */
+        memmove(IP6CB(skb), &TCP_SKB_CB(skb)->header.h6,
+                sizeof(struct inet6_skb_parm));
+}
+
 static int tcp_v6_rcv(struct sk_buff *skb)
 {
         const struct tcphdr *th;
@@ -1480,6 +1489,7 @@ do_time_wait:
                         inet_twsk_deschedule(tw, &tcp_death_row);
                         inet_twsk_put(tw);
                         sk = sk2;
+                        tcp_v6_restore_cb(skb);
                         goto process;
                 }
                 /* Fall through to ACK */
@@ -1488,6 +1498,7 @@ do_time_wait:
                 tcp_v6_timewait_ack(sk, skb);
                 break;
         case TCP_TW_RST:
+                tcp_v6_restore_cb(skb);
                 goto no_tcp_socket;
         case TCP_TW_SUCCESS:
                 ;
@@ -1522,7 +1533,7 @@ static void tcp_v6_early_demux(struct sk_buff *skb)
                 skb->sk = sk;
                 skb->destructor = sock_edemux;
                 if (sk_fullsock(sk)) {
-                        struct dst_entry *dst = sk->sk_rx_dst;
+                        struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst);
 
                         if (dst)
                                 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
diff --git a/net/ipv6/xfrm6_input.c b/net/ipv6/xfrm6_input.c
index f48fbe4d16f5..74bd17882a2f 100644
--- a/net/ipv6/xfrm6_input.c
+++ b/net/ipv6/xfrm6_input.c
@@ -42,7 +42,8 @@ int xfrm6_transport_finish(struct sk_buff *skb, int async)
         ipv6_hdr(skb)->payload_len = htons(skb->len);
         __skb_push(skb, skb->data - skb_network_header(skb));
 
-        NF_HOOK(NFPROTO_IPV6, NF_INET_PRE_ROUTING, skb, skb->dev, NULL,
+        NF_HOOK(NFPROTO_IPV6, NF_INET_PRE_ROUTING, NULL, skb,
+                skb->dev, NULL,
                 ip6_rcv_finish);
         return -1;
 }
diff --git a/net/ipv6/xfrm6_output.c b/net/ipv6/xfrm6_output.c
index 010f8bd2d577..09c76a7b474d 100644
--- a/net/ipv6/xfrm6_output.c
+++ b/net/ipv6/xfrm6_output.c
@@ -120,7 +120,7 @@ int xfrm6_prepare_output(struct xfrm_state *x, struct sk_buff *skb)
 }
 EXPORT_SYMBOL(xfrm6_prepare_output);
 
-int xfrm6_output_finish(struct sk_buff *skb)
+int xfrm6_output_finish(struct sock *sk, struct sk_buff *skb)
 {
         memset(IP6CB(skb), 0, sizeof(*IP6CB(skb)));
 
@@ -128,10 +128,10 @@ int xfrm6_output_finish(struct sk_buff *skb)
         IP6CB(skb)->flags |= IP6SKB_XFRM_TRANSFORMED;
 #endif
 
-        return xfrm_output(skb);
+        return xfrm_output(sk, skb);
 }
 
-static int __xfrm6_output(struct sk_buff *skb)
+static int __xfrm6_output(struct sock *sk, struct sk_buff *skb)
 {
         struct dst_entry *dst = skb_dst(skb);
         struct xfrm_state *x = dst->xfrm;
@@ -140,7 +140,7 @@ static int __xfrm6_output(struct sk_buff *skb)
 #ifdef CONFIG_NETFILTER
         if (!x) {
                 IP6CB(skb)->flags |= IP6SKB_REROUTED;
-                return dst_output(skb);
+                return dst_output_sk(sk, skb);
         }
 #endif
 
@@ -160,14 +160,15 @@ static int __xfrm6_output(struct sk_buff *skb)
         if (x->props.mode == XFRM_MODE_TUNNEL &&
             ((skb->len > mtu && !skb_is_gso(skb)) ||
                 dst_allfrag(skb_dst(skb)))) {
-                        return ip6_fragment(skb, x->outer_mode->afinfo->output_finish);
+                return ip6_fragment(sk, skb,
+                                    x->outer_mode->afinfo->output_finish);
         }
-        return x->outer_mode->afinfo->output_finish(skb);
+        return x->outer_mode->afinfo->output_finish(sk, skb);
 }
 
 int xfrm6_output(struct sock *sk, struct sk_buff *skb)
 {
-        return NF_HOOK_COND(NFPROTO_IPV6, NF_INET_POST_ROUTING, skb,
+        return NF_HOOK_COND(NFPROTO_IPV6, NF_INET_POST_ROUTING, sk, skb,
                             NULL, skb_dst(skb)->dev, __xfrm6_output,
                             !(IP6CB(skb)->flags & IP6SKB_REROUTED));
 }
diff --git a/net/iucv/af_iucv.c b/net/iucv/af_iucv.c
index 94b4c898a116..6daa52a18d40 100644
--- a/net/iucv/af_iucv.c
+++ b/net/iucv/af_iucv.c
@@ -1114,10 +1114,8 @@ static int iucv_sock_sendmsg(struct socket *sock, struct msghdr *msg,
                         noblock, &err);
         else
                 skb = sock_alloc_send_skb(sk, len, noblock, &err);
-        if (!skb) {
-                err = -ENOMEM;
+        if (!skb)
                 goto out;
-        }
         if (iucv->transport == AF_IUCV_TRANS_HIPER)
                 skb_reserve(skb, sizeof(struct af_iucv_trans_hdr) + ETH_HLEN);
         if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
diff --git a/net/l2tp/l2tp_core.c b/net/l2tp/l2tp_core.c
index 895348e44c7d..a29a504492af 100644
--- a/net/l2tp/l2tp_core.c
+++ b/net/l2tp/l2tp_core.c
@@ -1871,6 +1871,7 @@ static int __init l2tp_init(void)
         l2tp_wq = alloc_workqueue("l2tp", WQ_UNBOUND, 0);
         if (!l2tp_wq) {
                 pr_err("alloc_workqueue failed\n");
+                unregister_pernet_device(&l2tp_net_ops);
                 rc = -ENOMEM;
                 goto out;
         }
diff --git a/net/mac80211/agg-rx.c b/net/mac80211/agg-rx.c
index 2c090c507391..5c564a68fb50 100644
--- a/net/mac80211/agg-rx.c
+++ b/net/mac80211/agg-rx.c
@@ -49,8 +49,6 @@ static void ieee80211_free_tid_rx(struct rcu_head *h)
                 container_of(h, struct tid_ampdu_rx, rcu_head);
         int i;
 
-        del_timer_sync(&tid_rx->reorder_timer);
-
         for (i = 0; i < tid_rx->buf_size; i++)
                 __skb_queue_purge(&tid_rx->reorder_buf[i]);
         kfree(tid_rx->reorder_buf);
@@ -93,6 +91,12 @@ void ___ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
 
         del_timer_sync(&tid_rx->session_timer);
 
+        /* make sure ieee80211_sta_reorder_release() doesn't re-arm the timer */
+        spin_lock_bh(&tid_rx->reorder_lock);
+        tid_rx->removed = true;
+        spin_unlock_bh(&tid_rx->reorder_lock);
+        del_timer_sync(&tid_rx->reorder_timer);
+
         call_rcu(&tid_rx->rcu_head, ieee80211_free_tid_rx);
 }
 
diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c
index 4f7b922cfda4..2cd02278d4d4 100644
--- a/net/mac80211/rx.c
+++ b/net/mac80211/rx.c
@@ -873,9 +873,10 @@ static void ieee80211_sta_reorder_release(struct ieee80211_sub_if_data *sdata,
 
  set_release_timer:
 
-                mod_timer(&tid_agg_rx->reorder_timer,
-                          tid_agg_rx->reorder_time[j] + 1 +
-                          HT_RX_REORDER_BUF_TIMEOUT);
+                if (!tid_agg_rx->removed)
+                        mod_timer(&tid_agg_rx->reorder_timer,
+                                  tid_agg_rx->reorder_time[j] + 1 +
+                                  HT_RX_REORDER_BUF_TIMEOUT);
         } else {
                 del_timer(&tid_agg_rx->reorder_timer);
         }
diff --git a/net/mac80211/sta_info.h b/net/mac80211/sta_info.h
index 248f56e59ebc..7e2fa4018d41 100644
--- a/net/mac80211/sta_info.h
+++ b/net/mac80211/sta_info.h
@@ -175,6 +175,7 @@ struct tid_ampdu_tx {
  * @reorder_lock: serializes access to reorder buffer, see below.
  * @auto_seq: used for offloaded BA sessions to automatically pick head_seq_and
  *      and ssn.
+ * @removed: this session is removed (but might have been found due to RCU)
  *
  * This structure's lifetime is managed by RCU, assignments to
  * the array holding it must hold the aggregation mutex.
@@ -199,6 +200,7 @@ struct tid_ampdu_rx {
         u16 timeout;
         u8 dialog_token;
         bool auto_seq;
+        bool removed;
 };
 
 /**
diff --git a/net/netfilter/core.c b/net/netfilter/core.c
index fea9ef566427..e6163017c42d 100644
--- a/net/netfilter/core.c
+++ b/net/netfilter/core.c
@@ -120,12 +120,8 @@ EXPORT_SYMBOL(nf_unregister_hooks);
 
 unsigned int nf_iterate(struct list_head *head,
                         struct sk_buff *skb,
-                        unsigned int hook,
-                        const struct net_device *indev,
-                        const struct net_device *outdev,
-                        struct nf_hook_ops **elemp,
-                        int (*okfn)(struct sk_buff *),
-                        int hook_thresh)
+                        struct nf_hook_state *state,
+                        struct nf_hook_ops **elemp)
 {
         unsigned int verdict;
 
@@ -134,19 +130,19 @@ unsigned int nf_iterate(struct list_head *head,
          * function because of risk of continuing from deleted element.
          */
         list_for_each_entry_continue_rcu((*elemp), head, list) {
-                if (hook_thresh > (*elemp)->priority)
+                if (state->thresh > (*elemp)->priority)
                         continue;
 
                 /* Optimization: we don't need to hold module
                    reference here, since function can't sleep. --RR */
 repeat:
-                verdict = (*elemp)->hook(*elemp, skb, indev, outdev, okfn);
+                verdict = (*elemp)->hook(*elemp, skb, state);
                 if (verdict != NF_ACCEPT) {
 #ifdef CONFIG_NETFILTER_DEBUG
                         if (unlikely((verdict & NF_VERDICT_MASK)
                                                         > NF_MAX_VERDICT)) {
                                 NFDEBUG("Evil return from %p(%u).\n",
-                                        (*elemp)->hook, hook);
+                                        (*elemp)->hook, state->hook);
                                 continue;
                         }
 #endif
@@ -161,11 +157,7 @@ repeat:
 
 /* Returns 1 if okfn() needs to be executed by the caller,
  * -EPERM for NF_DROP, 0 otherwise. */
-int nf_hook_slow(u_int8_t pf, unsigned int hook, struct sk_buff *skb,
-                 struct net_device *indev,
-                 struct net_device *outdev,
-                 int (*okfn)(struct sk_buff *),
-                 int hook_thresh)
+int nf_hook_slow(struct sk_buff *skb, struct nf_hook_state *state)
 {
         struct nf_hook_ops *elem;
         unsigned int verdict;
@@ -174,10 +166,11 @@ int nf_hook_slow(u_int8_t pf, unsigned int hook, struct sk_buff *skb,
         /* We may already have this, but read-locks nest anyway */
         rcu_read_lock();
 
-        elem = list_entry_rcu(&nf_hooks[pf][hook], struct nf_hook_ops, list);
+        elem = list_entry_rcu(&nf_hooks[state->pf][state->hook],
+                              struct nf_hook_ops, list);
 next_hook:
-        verdict = nf_iterate(&nf_hooks[pf][hook], skb, hook, indev,
-                             outdev, &elem, okfn, hook_thresh);
+        verdict = nf_iterate(&nf_hooks[state->pf][state->hook], skb, state,
+                             &elem);
         if (verdict == NF_ACCEPT || verdict == NF_STOP) {
                 ret = 1;
         } else if ((verdict & NF_VERDICT_MASK) == NF_DROP) {
@@ -186,8 +179,8 @@ next_hook:
                 if (ret == 0)
                         ret = -EPERM;
         } else if ((verdict & NF_VERDICT_MASK) == NF_QUEUE) {
-                int err = nf_queue(skb, elem, pf, hook, indev, outdev, okfn,
-                                                verdict >> NF_VERDICT_QBITS);
+                int err = nf_queue(skb, elem, state,
+                                   verdict >> NF_VERDICT_QBITS);
                 if (err < 0) {
                         if (err == -ECANCELED)
                                 goto next_hook;
diff --git a/net/netfilter/ipvs/ip_vs_core.c b/net/netfilter/ipvs/ip_vs_core.c
index 04dbd9c7213f..5d2b806a862e 100644
--- a/net/netfilter/ipvs/ip_vs_core.c
+++ b/net/netfilter/ipvs/ip_vs_core.c
@@ -1272,8 +1272,7 @@ ip_vs_out(unsigned int hooknum, struct sk_buff *skb, int af)
  */
 static unsigned int
 ip_vs_reply4(const struct nf_hook_ops *ops, struct sk_buff *skb,
-             const struct net_device *in, const struct net_device *out,
-             int (*okfn)(struct sk_buff *))
+             const struct nf_hook_state *state)
 {
         return ip_vs_out(ops->hooknum, skb, AF_INET);
 }
@@ -1284,8 +1283,7 @@ ip_vs_reply4(const struct nf_hook_ops *ops, struct sk_buff *skb,
  */
 static unsigned int
 ip_vs_local_reply4(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                   const struct net_device *in, const struct net_device *out,
-                   int (*okfn)(struct sk_buff *))
+                   const struct nf_hook_state *state)
 {
         return ip_vs_out(ops->hooknum, skb, AF_INET);
 }
@@ -1299,8 +1297,7 @@ ip_vs_local_reply4(const struct nf_hook_ops *ops, struct sk_buff *skb,
  */
 static unsigned int
 ip_vs_reply6(const struct nf_hook_ops *ops, struct sk_buff *skb,
-             const struct net_device *in, const struct net_device *out,
-             int (*okfn)(struct sk_buff *))
+             const struct nf_hook_state *state)
 {
         return ip_vs_out(ops->hooknum, skb, AF_INET6);
 }
@@ -1311,8 +1308,7 @@ ip_vs_reply6(const struct nf_hook_ops *ops, struct sk_buff *skb,
  */
 static unsigned int
 ip_vs_local_reply6(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                   const struct net_device *in, const struct net_device *out,
-                   int (*okfn)(struct sk_buff *))
+                   const struct nf_hook_state *state)
 {
         return ip_vs_out(ops->hooknum, skb, AF_INET6);
 }
@@ -1769,9 +1765,7 @@ ip_vs_in(unsigned int hooknum, struct sk_buff *skb, int af)
  */
 static unsigned int
 ip_vs_remote_request4(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                      const struct net_device *in,
-                      const struct net_device *out,
-                      int (*okfn)(struct sk_buff *))
+                      const struct nf_hook_state *state)
 {
         return ip_vs_in(ops->hooknum, skb, AF_INET);
 }
@@ -1782,8 +1776,7 @@ ip_vs_remote_request4(const struct nf_hook_ops *ops, struct sk_buff *skb,
  */
 static unsigned int
 ip_vs_local_request4(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                     const struct net_device *in, const struct net_device *out,
-                     int (*okfn)(struct sk_buff *))
+                     const struct nf_hook_state *state)
 {
         return ip_vs_in(ops->hooknum, skb, AF_INET);
 }
@@ -1796,9 +1789,7 @@ ip_vs_local_request4(const struct nf_hook_ops *ops, struct sk_buff *skb,
  */
 static unsigned int
 ip_vs_remote_request6(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                      const struct net_device *in,
-                      const struct net_device *out,
-                      int (*okfn)(struct sk_buff *))
+                      const struct nf_hook_state *state)
 {
         return ip_vs_in(ops->hooknum, skb, AF_INET6);
 }
@@ -1809,8 +1800,7 @@ ip_vs_remote_request6(const struct nf_hook_ops *ops, struct sk_buff *skb,
  */
 static unsigned int
 ip_vs_local_request6(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                     const struct net_device *in, const struct net_device *out,
-                     int (*okfn)(struct sk_buff *))
+                     const struct nf_hook_state *state)
 {
         return ip_vs_in(ops->hooknum, skb, AF_INET6);
 }
@@ -1829,8 +1819,7 @@ ip_vs_local_request6(const struct nf_hook_ops *ops, struct sk_buff *skb,
  */
 static unsigned int
 ip_vs_forward_icmp(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                   const struct net_device *in, const struct net_device *out,
-                   int (*okfn)(struct sk_buff *))
+                   const struct nf_hook_state *state)
 {
         int r;
         struct net *net;
@@ -1851,8 +1840,7 @@ ip_vs_forward_icmp(const struct nf_hook_ops *ops, struct sk_buff *skb,
 #ifdef CONFIG_IP_VS_IPV6
 static unsigned int
 ip_vs_forward_icmp_v6(const struct nf_hook_ops *ops, struct sk_buff *skb,
-                      const struct net_device *in, const struct net_device *out,
-                      int (*okfn)(struct sk_buff *))
+                      const struct nf_hook_state *state)
 {
         int r;
         struct net *net;
diff --git a/net/netfilter/ipvs/ip_vs_xmit.c b/net/netfilter/ipvs/ip_vs_xmit.c
index bf02932b7188..19986ec5f21a 100644
--- a/net/netfilter/ipvs/ip_vs_xmit.c
+++ b/net/netfilter/ipvs/ip_vs_xmit.c
@@ -536,8 +536,8 @@ static inline int ip_vs_nat_send_or_cont(int pf, struct sk_buff *skb,
                 ip_vs_update_conntrack(skb, cp, 1);
         if (!local) {
                 skb_forward_csum(skb);
-                NF_HOOK(pf, NF_INET_LOCAL_OUT, skb, NULL, skb_dst(skb)->dev,
-                        dst_output);
+                NF_HOOK(pf, NF_INET_LOCAL_OUT, NULL, skb,
+                        NULL, skb_dst(skb)->dev, dst_output_sk);
         } else
                 ret = NF_ACCEPT;
         return ret;
@@ -554,8 +554,8 @@ static inline int ip_vs_send_or_cont(int pf, struct sk_buff *skb,
                 ip_vs_notrack(skb);
         if (!local) {
                 skb_forward_csum(skb);
-                NF_HOOK(pf, NF_INET_LOCAL_OUT, skb, NULL, skb_dst(skb)->dev,
-                        dst_output);
+                NF_HOOK(pf, NF_INET_LOCAL_OUT, NULL, skb,
+                        NULL, skb_dst(skb)->dev, dst_output_sk);
         } else
                 ret = NF_ACCEPT;
         return ret;
diff --git a/net/netfilter/nf_internals.h b/net/netfilter/nf_internals.h
index 61a3c927e63c..ea7f36784b3d 100644
--- a/net/netfilter/nf_internals.h
+++ b/net/netfilter/nf_internals.h
@@ -14,16 +14,11 @@
 
 /* core.c */
 unsigned int nf_iterate(struct list_head *head, struct sk_buff *skb,
-                        unsigned int hook, const struct net_device *indev,
-                        const struct net_device *outdev,
-                        struct nf_hook_ops **elemp,
-                        int (*okfn)(struct sk_buff *), int hook_thresh);
+                        struct nf_hook_state *state, struct nf_hook_ops **elemp);
 
 /* nf_queue.c */
-int nf_queue(struct sk_buff *skb, struct nf_hook_ops *elem, u_int8_t pf,
-             unsigned int hook, struct net_device *indev,
-             struct net_device *outdev, int (*okfn)(struct sk_buff *),
-             unsigned int queuenum);
+int nf_queue(struct sk_buff *skb, struct nf_hook_ops *elem,
+             struct nf_hook_state *state, unsigned int queuenum);
 int __init netfilter_queue_init(void);
 
 /* nf_log.c */
diff --git a/net/netfilter/nf_queue.c b/net/netfilter/nf_queue.c
index fb045b4c2966..2e88032cd5ad 100644
--- a/net/netfilter/nf_queue.c
+++ b/net/netfilter/nf_queue.c
@@ -48,11 +48,15 @@ EXPORT_SYMBOL(nf_unregister_queue_handler);
 
 void nf_queue_entry_release_refs(struct nf_queue_entry *entry)
 {
+        struct nf_hook_state *state = &entry->state;
+
         /* Release those devices we held, or Alexey will kill me. */
-        if (entry->indev)
-                dev_put(entry->indev);
-        if (entry->outdev)
-                dev_put(entry->outdev);
+        if (state->in)
+                dev_put(state->in);
+        if (state->out)
+                dev_put(state->out);
+        if (state->sk)
+                sock_put(state->sk);
 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
         if (entry->skb->nf_bridge) {
                 struct net_device *physdev;
@@ -73,13 +77,17 @@ EXPORT_SYMBOL_GPL(nf_queue_entry_release_refs);
 /* Bump dev refs so they don't vanish while packet is out */
 bool nf_queue_entry_get_refs(struct nf_queue_entry *entry)
 {
+        struct nf_hook_state *state = &entry->state;
+
         if (!try_module_get(entry->elem->owner))
                 return false;
 
-        if (entry->indev)
-                dev_hold(entry->indev);
-        if (entry->outdev)
-                dev_hold(entry->outdev);
+        if (state->in)
+                dev_hold(state->in);
+        if (state->out)
+                dev_hold(state->out);
+        if (state->sk)
+                sock_hold(state->sk);
 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
         if (entry->skb->nf_bridge) {
                 struct net_device *physdev;
@@ -102,12 +110,9 @@ EXPORT_SYMBOL_GPL(nf_queue_entry_get_refs);
  * through nf_reinject().
  */
 int nf_queue(struct sk_buff *skb,
-                      struct nf_hook_ops *elem,
-                      u_int8_t pf, unsigned int hook,
-                      struct net_device *indev,
-                      struct net_device *outdev,
-                      int (*okfn)(struct sk_buff *),
-                      unsigned int queuenum)
+             struct nf_hook_ops *elem,
+             struct nf_hook_state *state,
+             unsigned int queuenum)
 {
         int status = -ENOENT;
         struct nf_queue_entry *entry = NULL;
@@ -123,7 +128,7 @@ int nf_queue(struct sk_buff *skb,
                 goto err_unlock;
         }
 
-        afinfo = nf_get_afinfo(pf);
+        afinfo = nf_get_afinfo(state->pf);
         if (!afinfo)
                 goto err_unlock;
 
@@ -136,11 +141,7 @@ int nf_queue(struct sk_buff *skb,
         *entry = (struct nf_queue_entry) {
                 .skb    = skb,
                 .elem   = elem,
-                .pf     = pf,
-                .hook   = hook,
-                .indev  = indev,
-                .outdev = outdev,
-                .okfn   = okfn,
+                .state  = *state,
                 .size   = sizeof(*entry) + afinfo->route_key_size,
         };
 
@@ -186,30 +187,29 @@ void nf_reinject(struct nf_queue_entry *entry, unsigned int verdict)
         }
 
         if (verdict == NF_ACCEPT) {
-                afinfo = nf_get_afinfo(entry->pf);
+                afinfo = nf_get_afinfo(entry->state.pf);
                 if (!afinfo || afinfo->reroute(skb, entry) < 0)
                         verdict = NF_DROP;
         }
 
+        entry->state.thresh = INT_MIN;
+
         if (verdict == NF_ACCEPT) {
         next_hook:
-                verdict = nf_iterate(&nf_hooks[entry->pf][entry->hook],
-                                     skb, entry->hook,
-                                     entry->indev, entry->outdev, &elem,
-                                     entry->okfn, INT_MIN);
+                verdict = nf_iterate(&nf_hooks[entry->state.pf][entry->state.hook],
+                                     skb, &entry->state, &elem);
         }
 
         switch (verdict & NF_VERDICT_MASK) {
         case NF_ACCEPT:
         case NF_STOP:
                 local_bh_disable();
-                entry->okfn(skb);
+                entry->state.okfn(entry->state.sk, skb);
                 local_bh_enable();
                 break;
         case NF_QUEUE:
-                err = nf_queue(skb, elem, entry->pf, entry->hook,
-                                entry->indev, entry->outdev, entry->okfn,
-                                verdict >> NF_VERDICT_QBITS);
+                err = nf_queue(skb, elem, &entry->state,
+                               verdict >> NF_VERDICT_QBITS);
                 if (err < 0) {
                         if (err == -ECANCELED)
                                 goto next_hook;
diff --git a/net/netfilter/nfnetlink_queue_core.c b/net/netfilter/nfnetlink_queue_core.c
index 94e1aaf86070..628afc350c02 100644
--- a/net/netfilter/nfnetlink_queue_core.c
+++ b/net/netfilter/nfnetlink_queue_core.c
@@ -315,13 +315,13 @@ nfqnl_build_packet_message(struct net *net, struct nfqnl_instance *queue,
         if (entskb->tstamp.tv64)
                 size += nla_total_size(sizeof(struct nfqnl_msg_packet_timestamp));
 
-        if (entry->hook <= NF_INET_FORWARD ||
-           (entry->hook == NF_INET_POST_ROUTING && entskb->sk == NULL))
+        if (entry->state.hook <= NF_INET_FORWARD ||
+           (entry->state.hook == NF_INET_POST_ROUTING && entskb->sk == NULL))
                 csum_verify = !skb_csum_unnecessary(entskb);
         else
                 csum_verify = false;
 
-        outdev = entry->outdev;
+        outdev = entry->state.out;
 
         switch ((enum nfqnl_config_mode)ACCESS_ONCE(queue->copy_mode)) {
         case NFQNL_COPY_META:
@@ -369,23 +369,23 @@ nfqnl_build_packet_message(struct net *net, struct nfqnl_instance *queue,
                 return NULL;
         }
         nfmsg = nlmsg_data(nlh);
-        nfmsg->nfgen_family = entry->pf;
+        nfmsg->nfgen_family = entry->state.pf;
         nfmsg->version = NFNETLINK_V0;
         nfmsg->res_id = htons(queue->queue_num);
 
         nla = __nla_reserve(skb, NFQA_PACKET_HDR, sizeof(*pmsg));
         pmsg = nla_data(nla);
         pmsg->hw_protocol       = entskb->protocol;
-        pmsg->hook              = entry->hook;
+        pmsg->hook              = entry->state.hook;
         *packet_id_ptr          = &pmsg->packet_id;
 
-        indev = entry->indev;
+        indev = entry->state.in;
         if (indev) {
 #if !IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
                 if (nla_put_be32(skb, NFQA_IFINDEX_INDEV, htonl(indev->ifindex)))
                         goto nla_put_failure;
 #else
-                if (entry->pf == PF_BRIDGE) {
+                if (entry->state.pf == PF_BRIDGE) {
                         /* Case 1: indev is physical input device, we need to
                          * look for bridge group (when called from
                          * netfilter_bridge) */
@@ -419,7 +419,7 @@ nfqnl_build_packet_message(struct net *net, struct nfqnl_instance *queue,
                 if (nla_put_be32(skb, NFQA_IFINDEX_OUTDEV, htonl(outdev->ifindex)))
                         goto nla_put_failure;
 #else
-                if (entry->pf == PF_BRIDGE) {
+                if (entry->state.pf == PF_BRIDGE) {
                         /* Case 1: outdev is physical output device, we need to
                          * look for bridge group (when called from
                          * netfilter_bridge) */
@@ -642,8 +642,8 @@ nfqnl_enqueue_packet(struct nf_queue_entry *entry, unsigned int queuenum)
         struct nfqnl_instance *queue;
         struct sk_buff *skb, *segs;
         int err = -ENOBUFS;
-        struct net *net = dev_net(entry->indev ?
-                                  entry->indev : entry->outdev);
+        struct net *net = dev_net(entry->state.in ?
+                                  entry->state.in : entry->state.out);
         struct nfnl_queue_net *q = nfnl_queue_pernet(net);
 
         /* rcu_read_lock()ed by nf_hook_slow() */
@@ -656,7 +656,7 @@ nfqnl_enqueue_packet(struct nf_queue_entry *entry, unsigned int queuenum)
 
         skb = entry->skb;
 
-        switch (entry->pf) {
+        switch (entry->state.pf) {
         case NFPROTO_IPV4:
                 skb->protocol = htons(ETH_P_IP);
                 break;
@@ -766,11 +766,11 @@ nfqnl_set_mode(struct nfqnl_instance *queue,
 static int
 dev_cmp(struct nf_queue_entry *entry, unsigned long ifindex)
 {
-        if (entry->indev)
-                if (entry->indev->ifindex == ifindex)
+        if (entry->state.in)
+                if (entry->state.in->ifindex == ifindex)
                         return 1;
-        if (entry->outdev)
-                if (entry->outdev->ifindex == ifindex)
+        if (entry->state.out)
+                if (entry->state.out->ifindex == ifindex)
                         return 1;
 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
         if (entry->skb->nf_bridge) {
diff --git a/net/openvswitch/vport-vxlan.c b/net/openvswitch/vport-vxlan.c
index 3277a7520e31..6d39766e7828 100644
--- a/net/openvswitch/vport-vxlan.c
+++ b/net/openvswitch/vport-vxlan.c
@@ -222,7 +222,8 @@ static int vxlan_tnl_send(struct vport *vport, struct sk_buff *skb)
 {
         struct net *net = ovs_dp_get_net(vport->dp);
         struct vxlan_port *vxlan_port = vxlan_vport(vport);
-        __be16 dst_port = inet_sk(vxlan_port->vs->sock->sk)->inet_sport;
+        struct sock *sk = vxlan_port->vs->sock->sk;
+        __be16 dst_port = inet_sk(sk)->inet_sport;
         const struct ovs_key_ipv4_tunnel *tun_key;
         struct vxlan_metadata md = {0};
         struct rtable *rt;
@@ -255,7 +256,7 @@ static int vxlan_tnl_send(struct vport *vport, struct sk_buff *skb)
         vxflags = vxlan_port->exts |
                       (tun_key->tun_flags & TUNNEL_CSUM ? VXLAN_F_UDP_CSUM : 0);
 
-        err = vxlan_xmit_skb(rt, skb, fl.saddr, tun_key->ipv4_dst,
+        err = vxlan_xmit_skb(rt, sk, skb, fl.saddr, tun_key->ipv4_dst,
                              tun_key->ipv4_tos, tun_key->ipv4_ttl, df,
                              src_port, dst_port,
                              &md, false, vxflags);
diff --git a/net/openvswitch/vport.c b/net/openvswitch/vport.c
index ec2954ffc690..067a3fff1d2c 100644
--- a/net/openvswitch/vport.c
+++ b/net/openvswitch/vport.c
@@ -274,10 +274,8 @@ void ovs_vport_del(struct vport *vport)
         ASSERT_OVSL();
 
         hlist_del_rcu(&vport->hash_node);
-
-        vport->ops->destroy(vport);
-
         module_put(vport->ops->owner);
+        vport->ops->destroy(vport);
 }
 
 /**
diff --git a/net/sched/sch_fq.c b/net/sched/sch_fq.c
index dfcea20e3171..f377702d4b91 100644
--- a/net/sched/sch_fq.c
+++ b/net/sched/sch_fq.c
@@ -8,7 +8,7 @@
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  *
- *  Meant to be mostly used for localy generated traffic :
+ *  Meant to be mostly used for locally generated traffic :
  *  Fast classification depends on skb->sk being set before reaching us.
  *  If not, (router workload), we use rxhash as fallback, with 32 bits wide hash.
  *  All packets belonging to a socket are considered as a 'flow'.
@@ -63,7 +63,7 @@ struct fq_flow {
                 struct sk_buff *tail;   /* last skb in the list */
                 unsigned long  age;     /* jiffies when flow was emptied, for gc */
         };
-        struct rb_node  fq_node;        /* anchor in fq_root[] trees */
+        struct rb_node  fq_node;        /* anchor in fq_root[] trees */
         struct sock     *sk;
         int             qlen;           /* number of packets in flow queue */
         int             credit;
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 612aa73bbc60..e6ce1517367f 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -303,9 +303,7 @@ static int rpc_client_register(struct rpc_clnt *clnt,
         struct super_block *pipefs_sb;
         int err;
 
-        err = rpc_clnt_debugfs_register(clnt);
-        if (err)
-                return err;
+        rpc_clnt_debugfs_register(clnt);
 
         pipefs_sb = rpc_get_sb_net(net);
         if (pipefs_sb) {
diff --git a/net/sunrpc/debugfs.c b/net/sunrpc/debugfs.c
index e811f390f9f6..82962f7e6e88 100644
--- a/net/sunrpc/debugfs.c
+++ b/net/sunrpc/debugfs.c
@@ -129,48 +129,52 @@ static const struct file_operations tasks_fops = {
         .release        = tasks_release,
 };
 
-int
+void
 rpc_clnt_debugfs_register(struct rpc_clnt *clnt)
 {
-        int len, err;
+        int len;
         char name[24]; /* enough for "../../rpc_xprt/ + 8 hex digits + NULL */
+        struct rpc_xprt *xprt;
 
         /* Already registered? */
-        if (clnt->cl_debugfs)
-                return 0;
+        if (clnt->cl_debugfs || !rpc_clnt_dir)
+                return;
 
         len = snprintf(name, sizeof(name), "%x", clnt->cl_clid);
         if (len >= sizeof(name))
-                return -EINVAL;
+                return;
 
         /* make the per-client dir */
         clnt->cl_debugfs = debugfs_create_dir(name, rpc_clnt_dir);
         if (!clnt->cl_debugfs)
-                return -ENOMEM;
+                return;
 
         /* make tasks file */
-        err = -ENOMEM;
         if (!debugfs_create_file("tasks", S_IFREG | S_IRUSR, clnt->cl_debugfs,
                                  clnt, &tasks_fops))
                 goto out_err;
 
-        err = -EINVAL;
         rcu_read_lock();
+        xprt = rcu_dereference(clnt->cl_xprt);
+        /* no "debugfs" dentry? Don't bother with the symlink. */
+        if (!xprt->debugfs) {
+                rcu_read_unlock();
+                return;
+        }
         len = snprintf(name, sizeof(name), "../../rpc_xprt/%s",
-                        rcu_dereference(clnt->cl_xprt)->debugfs->d_name.name);
+                        xprt->debugfs->d_name.name);
         rcu_read_unlock();
+
         if (len >= sizeof(name))
                 goto out_err;
 
-        err = -ENOMEM;
         if (!debugfs_create_symlink("xprt", clnt->cl_debugfs, name))
                 goto out_err;
 
-        return 0;
+        return;
 out_err:
         debugfs_remove_recursive(clnt->cl_debugfs);
         clnt->cl_debugfs = NULL;
-        return err;
 }
 
 void
@@ -226,33 +230,33 @@ static const struct file_operations xprt_info_fops = {
         .release        = xprt_info_release,
 };
 
-int
+void
 rpc_xprt_debugfs_register(struct rpc_xprt *xprt)
 {
         int len, id;
         static atomic_t cur_id;
         char            name[9]; /* 8 hex digits + NULL term */
 
+        if (!rpc_xprt_dir)
+                return;
+
         id = (unsigned int)atomic_inc_return(&cur_id);
 
         len = snprintf(name, sizeof(name), "%x", id);
         if (len >= sizeof(name))
-                return -EINVAL;
+                return;
 
         /* make the per-client dir */
         xprt->debugfs = debugfs_create_dir(name, rpc_xprt_dir);
         if (!xprt->debugfs)
-                return -ENOMEM;
+                return;
 
         /* make tasks file */
         if (!debugfs_create_file("info", S_IFREG | S_IRUSR, xprt->debugfs,
                                  xprt, &xprt_info_fops)) {
                 debugfs_remove_recursive(xprt->debugfs);
                 xprt->debugfs = NULL;
-                return -ENOMEM;
         }
-
-        return 0;
 }
 
 void
@@ -266,14 +270,17 @@ void __exit
 sunrpc_debugfs_exit(void)
 {
         debugfs_remove_recursive(topdir);
+        topdir = NULL;
+        rpc_clnt_dir = NULL;
+        rpc_xprt_dir = NULL;
 }
 
-int __init
+void __init
 sunrpc_debugfs_init(void)
 {
         topdir = debugfs_create_dir("sunrpc", NULL);
         if (!topdir)
-                goto out;
+                return;
 
         rpc_clnt_dir = debugfs_create_dir("rpc_clnt", topdir);
         if (!rpc_clnt_dir)
@@ -283,10 +290,9 @@ sunrpc_debugfs_init(void)
         if (!rpc_xprt_dir)
                 goto out_remove;
 
-        return 0;
+        return;
 out_remove:
         debugfs_remove_recursive(topdir);
         topdir = NULL;
-out:
-        return -ENOMEM;
+        rpc_clnt_dir = NULL;
 }
diff --git a/net/sunrpc/sunrpc_syms.c b/net/sunrpc/sunrpc_syms.c
index e37fbed87956..ee5d3d253102 100644
--- a/net/sunrpc/sunrpc_syms.c
+++ b/net/sunrpc/sunrpc_syms.c
@@ -98,10 +98,7 @@ init_sunrpc(void)
         if (err)
                 goto out4;
 
-        err = sunrpc_debugfs_init();
-        if (err)
-                goto out5;
-
+        sunrpc_debugfs_init();
 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
         rpc_register_sysctl();
 #endif
@@ -109,8 +106,6 @@ init_sunrpc(void)
         init_socket_xprt();     /* clnt sock transport */
         return 0;
 
-out5:
-        unregister_rpc_pipefs();
 out4:
         unregister_pernet_subsys(&sunrpc_net_ops);
 out3:
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index e3015aede0d9..9949722d99ce 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -1331,7 +1331,6 @@ static void xprt_init(struct rpc_xprt *xprt, struct net *net)
  */
 struct rpc_xprt *xprt_create_transport(struct xprt_create *args)
 {
-        int err;
         struct rpc_xprt *xprt;
         struct xprt_class *t;
 
@@ -1372,11 +1371,7 @@ found:
                 return ERR_PTR(-ENOMEM);
         }
 
-        err = rpc_xprt_debugfs_register(xprt);
-        if (err) {
-                xprt_destroy(xprt);
-                return ERR_PTR(err);
-        }
+        rpc_xprt_debugfs_register(xprt);
 
         dprintk("RPC:       created transport %p with %u slots\n", xprt,
                         xprt->max_reqs);
diff --git a/net/tipc/bcast.c b/net/tipc/bcast.c
index ae558dd7f8ee..c5cbdcb1f0b5 100644
--- a/net/tipc/bcast.c
+++ b/net/tipc/bcast.c
@@ -413,7 +413,7 @@ static void bclink_accept_pkt(struct tipc_node *node, u32 seqno)
          */
         if (((seqno - tn->own_addr) % TIPC_MIN_LINK_WIN) == 0) {
                 tipc_link_proto_xmit(node->active_links[node->addr & 1],
-                                     STATE_MSG, 0, 0, 0, 0, 0);
+                                     STATE_MSG, 0, 0, 0, 0);
                 tn->bcl->stats.sent_acks++;
         }
 }
@@ -899,7 +899,7 @@ int tipc_bclink_init(struct net *net)
         skb_queue_head_init(&bclink->inputq);
         bcl->owner = &bclink->node;
         bcl->owner->net = net;
-        bcl->max_pkt = MAX_PKT_DEFAULT_MCAST;
+        bcl->mtu = MAX_PKT_DEFAULT_MCAST;
         tipc_link_set_queue_limits(bcl, BCLINK_WIN_DEFAULT);
         bcl->bearer_id = MAX_BEARERS;
         rcu_assign_pointer(tn->bearer_list[MAX_BEARERS], &bcbearer->bearer);
diff --git a/net/tipc/core.c b/net/tipc/core.c
index 935205e6bcfe..be1c9fa60b09 100644
--- a/net/tipc/core.c
+++ b/net/tipc/core.c
@@ -152,11 +152,11 @@ out_netlink:
 static void __exit tipc_exit(void)
 {
         tipc_bearer_cleanup();
+        unregister_pernet_subsys(&tipc_net_ops);
         tipc_netlink_stop();
         tipc_netlink_compat_stop();
         tipc_socket_stop();
         tipc_unregister_sysctl();
-        unregister_pernet_subsys(&tipc_net_ops);
 
         pr_info("Deactivated\n");
 }
diff --git a/net/tipc/link.c b/net/tipc/link.c
index 514466efc25c..a6b30df6ec02 100644
--- a/net/tipc/link.c
+++ b/net/tipc/link.c
@@ -89,24 +89,14 @@ static const struct nla_policy tipc_nl_prop_policy[TIPC_NLA_PROP_MAX + 1] = {
 #define  TIMEOUT_EVT     560817u        /* link timer expired */
 
 /*
- * The following two 'message types' is really just implementation
- * data conveniently stored in the message header.
- * They must not be considered part of the protocol
+ * State value stored in 'failover_pkts'
  */
-#define OPEN_MSG   0
-#define CLOSED_MSG 1
-
-/*
- * State value stored in 'exp_msg_count'
- */
-#define START_CHANGEOVER 100000u
+#define FIRST_FAILOVER 0xffffu
 
 static void link_handle_out_of_seq_msg(struct tipc_link *link,
                                        struct sk_buff *skb);
 static void tipc_link_proto_rcv(struct tipc_link *link,
                                 struct sk_buff *skb);
-static int  tipc_link_tunnel_rcv(struct tipc_node *node,
-                                 struct sk_buff **skb);
 static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tol);
 static void link_state_event(struct tipc_link *l_ptr, u32 event);
 static void link_reset_statistics(struct tipc_link *l_ptr);
@@ -115,7 +105,7 @@ static void tipc_link_sync_xmit(struct tipc_link *l);
 static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf);
 static void tipc_link_input(struct tipc_link *l, struct sk_buff *skb);
 static bool tipc_data_input(struct tipc_link *l, struct sk_buff *skb);
-
+static bool tipc_link_failover_rcv(struct tipc_link *l, struct sk_buff **skb);
 /*
  *  Simple link routines
  */
@@ -146,34 +136,6 @@ static struct tipc_link *tipc_parallel_link(struct tipc_link *l)
         return l->owner->active_links[1];
 }
 
-static void link_init_max_pkt(struct tipc_link *l_ptr)
-{
-        struct tipc_node *node = l_ptr->owner;
-        struct tipc_net *tn = net_generic(node->net, tipc_net_id);
-        struct tipc_bearer *b_ptr;
-        u32 max_pkt;
-
-        rcu_read_lock();
-        b_ptr = rcu_dereference_rtnl(tn->bearer_list[l_ptr->bearer_id]);
-        if (!b_ptr) {
-                rcu_read_unlock();
-                return;
-        }
-        max_pkt = (b_ptr->mtu & ~3);
-        rcu_read_unlock();
-
-        if (max_pkt > MAX_MSG_SIZE)
-                max_pkt = MAX_MSG_SIZE;
-
-        l_ptr->max_pkt_target = max_pkt;
-        if (l_ptr->max_pkt_target < MAX_PKT_DEFAULT)
-                l_ptr->max_pkt = l_ptr->max_pkt_target;
-        else
-                l_ptr->max_pkt = MAX_PKT_DEFAULT;
-
-        l_ptr->max_pkt_probes = 0;
-}
-
 /*
  *  Simple non-static link routines (i.e. referenced outside this file)
  */
@@ -314,7 +276,8 @@ struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
         msg_set_bearer_id(msg, b_ptr->identity);
         strcpy((char *)msg_data(msg), if_name);
         l_ptr->net_plane = b_ptr->net_plane;
-        link_init_max_pkt(l_ptr);
+        l_ptr->advertised_mtu = b_ptr->mtu;
+        l_ptr->mtu = l_ptr->advertised_mtu;
         l_ptr->priority = b_ptr->priority;
         tipc_link_set_queue_limits(l_ptr, b_ptr->window);
         l_ptr->next_out_no = 1;
@@ -333,15 +296,19 @@ struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
 }
 
 /**
- * link_delete - Conditional deletion of link.
- *               If timer still running, real delete is done when it expires
- * @link: link to be deleted
+ * tipc_link_delete - Delete a link
+ * @l: link to be deleted
  */
-void tipc_link_delete(struct tipc_link *link)
+void tipc_link_delete(struct tipc_link *l)
 {
-        tipc_link_reset_fragments(link);
-        tipc_node_detach_link(link->owner, link);
-        tipc_link_put(link);
+        tipc_link_reset(l);
+        if (del_timer(&l->timer))
+                tipc_link_put(l);
+        l->flags |= LINK_STOPPED;
+        /* Delete link now, or when timer is finished: */
+        tipc_link_reset_fragments(l);
+        tipc_node_detach_link(l->owner, l);
+        tipc_link_put(l);
 }
 
 void tipc_link_delete_list(struct net *net, unsigned int bearer_id,
@@ -350,23 +317,12 @@ void tipc_link_delete_list(struct net *net, unsigned int bearer_id,
         struct tipc_net *tn = net_generic(net, tipc_net_id);
         struct tipc_link *link;
         struct tipc_node *node;
-        bool del_link;
 
         rcu_read_lock();
         list_for_each_entry_rcu(node, &tn->node_list, list) {
                 tipc_node_lock(node);
                 link = node->links[bearer_id];
-                if (!link) {
-                        tipc_node_unlock(node);
-                        continue;
-                }
-                del_link = !tipc_link_is_up(link) && !link->exp_msg_count;
-                tipc_link_reset(link);
-                if (del_timer(&link->timer))
-                        tipc_link_put(link);
-                link->flags |= LINK_STOPPED;
-                /* Delete link now, or when failover is finished: */
-                if (shutting_down || !tipc_node_is_up(node) || del_link)
+                if (link)
                         tipc_link_delete(link);
                 tipc_node_unlock(node);
         }
@@ -473,17 +429,17 @@ void tipc_link_purge_queues(struct tipc_link *l_ptr)
 void tipc_link_reset(struct tipc_link *l_ptr)
 {
         u32 prev_state = l_ptr->state;
-        u32 checkpoint = l_ptr->next_in_no;
         int was_active_link = tipc_link_is_active(l_ptr);
         struct tipc_node *owner = l_ptr->owner;
+        struct tipc_link *pl = tipc_parallel_link(l_ptr);
 
         msg_set_session(l_ptr->pmsg, ((msg_session(l_ptr->pmsg) + 1) & 0xffff));
 
         /* Link is down, accept any session */
         l_ptr->peer_session = INVALID_SESSION;
 
-        /* Prepare for max packet size negotiation */
-        link_init_max_pkt(l_ptr);
+        /* Prepare for renewed mtu size negotiation */
+        l_ptr->mtu = l_ptr->advertised_mtu;
 
         l_ptr->state = RESET_UNKNOWN;
 
@@ -493,11 +449,15 @@ void tipc_link_reset(struct tipc_link *l_ptr)
         tipc_node_link_down(l_ptr->owner, l_ptr);
         tipc_bearer_remove_dest(owner->net, l_ptr->bearer_id, l_ptr->addr);
 
-        if (was_active_link && tipc_node_active_links(l_ptr->owner)) {
-                l_ptr->reset_checkpoint = checkpoint;
-                l_ptr->exp_msg_count = START_CHANGEOVER;
+        if (was_active_link && tipc_node_is_up(l_ptr->owner) && (pl != l_ptr)) {
+                l_ptr->flags |= LINK_FAILINGOVER;
+                l_ptr->failover_checkpt = l_ptr->next_in_no;
+                pl->failover_pkts = FIRST_FAILOVER;
+                pl->failover_checkpt = l_ptr->next_in_no;
+                pl->failover_skb = l_ptr->reasm_buf;
+        } else {
+                kfree_skb(l_ptr->reasm_buf);
         }
-
         /* Clean up all queues, except inputq: */
         __skb_queue_purge(&l_ptr->transmq);
         __skb_queue_purge(&l_ptr->deferdq);
@@ -507,6 +467,7 @@ void tipc_link_reset(struct tipc_link *l_ptr)
         if (!skb_queue_empty(owner->inputq))
                 owner->action_flags |= TIPC_MSG_EVT;
         tipc_link_purge_backlog(l_ptr);
+        l_ptr->reasm_buf = NULL;
         l_ptr->rcv_unacked = 0;
         l_ptr->checkpoint = 1;
         l_ptr->next_out_no = 1;
@@ -558,8 +519,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
         if (!(l_ptr->flags & LINK_STARTED) && (event != STARTING_EVT))
                 return;         /* Not yet. */
 
-        /* Check whether changeover is going on */
-        if (l_ptr->exp_msg_count) {
+        if (l_ptr->flags & LINK_FAILINGOVER) {
                 if (event == TIMEOUT_EVT)
                         link_set_timer(l_ptr, cont_intv);
                 return;
@@ -576,11 +536,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
                                 l_ptr->checkpoint = l_ptr->next_in_no;
                                 if (tipc_bclink_acks_missing(l_ptr->owner)) {
                                         tipc_link_proto_xmit(l_ptr, STATE_MSG,
-                                                             0, 0, 0, 0, 0);
-                                        l_ptr->fsm_msg_cnt++;
-                                } else if (l_ptr->max_pkt < l_ptr->max_pkt_target) {
-                                        tipc_link_proto_xmit(l_ptr, STATE_MSG,
-                                                             1, 0, 0, 0, 0);
+                                                             0, 0, 0, 0);
                                         l_ptr->fsm_msg_cnt++;
                                 }
                                 link_set_timer(l_ptr, cont_intv);
@@ -588,7 +544,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
                         }
                         l_ptr->state = WORKING_UNKNOWN;
                         l_ptr->fsm_msg_cnt = 0;
-                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
+                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0);
                         l_ptr->fsm_msg_cnt++;
                         link_set_timer(l_ptr, cont_intv / 4);
                         break;
@@ -599,7 +555,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
                         l_ptr->state = RESET_RESET;
                         l_ptr->fsm_msg_cnt = 0;
                         tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
-                                             0, 0, 0, 0, 0);
+                                             0, 0, 0, 0);
                         l_ptr->fsm_msg_cnt++;
                         link_set_timer(l_ptr, cont_intv);
                         break;
@@ -622,7 +578,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
                         l_ptr->state = RESET_RESET;
                         l_ptr->fsm_msg_cnt = 0;
                         tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
-                                             0, 0, 0, 0, 0);
+                                             0, 0, 0, 0);
                         l_ptr->fsm_msg_cnt++;
                         link_set_timer(l_ptr, cont_intv);
                         break;
@@ -633,13 +589,13 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
                                 l_ptr->checkpoint = l_ptr->next_in_no;
                                 if (tipc_bclink_acks_missing(l_ptr->owner)) {
                                         tipc_link_proto_xmit(l_ptr, STATE_MSG,
-                                                             0, 0, 0, 0, 0);
+                                                             0, 0, 0, 0);
                                         l_ptr->fsm_msg_cnt++;
                                 }
                                 link_set_timer(l_ptr, cont_intv);
                         } else if (l_ptr->fsm_msg_cnt < l_ptr->abort_limit) {
                                 tipc_link_proto_xmit(l_ptr, STATE_MSG,
-                                                     1, 0, 0, 0, 0);
+                                                     1, 0, 0, 0);
                                 l_ptr->fsm_msg_cnt++;
                                 link_set_timer(l_ptr, cont_intv / 4);
                         } else {        /* Link has failed */
@@ -649,7 +605,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
                                 l_ptr->state = RESET_UNKNOWN;
                                 l_ptr->fsm_msg_cnt = 0;
                                 tipc_link_proto_xmit(l_ptr, RESET_MSG,
-                                                     0, 0, 0, 0, 0);
+                                                     0, 0, 0, 0);
                                 l_ptr->fsm_msg_cnt++;
                                 link_set_timer(l_ptr, cont_intv);
                         }
@@ -669,7 +625,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
                         l_ptr->state = WORKING_WORKING;
                         l_ptr->fsm_msg_cnt = 0;
                         link_activate(l_ptr);
-                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
+                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0);
                         l_ptr->fsm_msg_cnt++;
                         if (l_ptr->owner->working_links == 1)
                                 tipc_link_sync_xmit(l_ptr);
@@ -679,7 +635,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
                         l_ptr->state = RESET_RESET;
                         l_ptr->fsm_msg_cnt = 0;
                         tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
-                                             1, 0, 0, 0, 0);
+                                             1, 0, 0, 0);
                         l_ptr->fsm_msg_cnt++;
                         link_set_timer(l_ptr, cont_intv);
                         break;
@@ -689,7 +645,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
                         link_set_timer(l_ptr, cont_intv);
                         break;
                 case TIMEOUT_EVT:
-                        tipc_link_proto_xmit(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);
+                        tipc_link_proto_xmit(l_ptr, RESET_MSG, 0, 0, 0, 0);
                         l_ptr->fsm_msg_cnt++;
                         link_set_timer(l_ptr, cont_intv);
                         break;
@@ -707,7 +663,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
                         l_ptr->state = WORKING_WORKING;
                         l_ptr->fsm_msg_cnt = 0;
                         link_activate(l_ptr);
-                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
+                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0);
                         l_ptr->fsm_msg_cnt++;
                         if (l_ptr->owner->working_links == 1)
                                 tipc_link_sync_xmit(l_ptr);
@@ -717,7 +673,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
                         break;
                 case TIMEOUT_EVT:
                         tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
-                                             0, 0, 0, 0, 0);
+                                             0, 0, 0, 0);
                         l_ptr->fsm_msg_cnt++;
                         link_set_timer(l_ptr, cont_intv);
                         break;
@@ -746,7 +702,7 @@ int __tipc_link_xmit(struct net *net, struct tipc_link *link,
         struct tipc_msg *msg = buf_msg(skb_peek(list));
         unsigned int maxwin = link->window;
         unsigned int imp = msg_importance(msg);
-        uint mtu = link->max_pkt;
+        uint mtu = link->mtu;
         uint ack = mod(link->next_in_no - 1);
         uint seqno = link->next_out_no;
         uint bc_last_in = link->owner->bclink.last_in;
@@ -1200,7 +1156,7 @@ void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b_ptr)
                         link_retrieve_defq(l_ptr, &head);
                 if (unlikely(++l_ptr->rcv_unacked >= TIPC_MIN_LINK_WIN)) {
                         l_ptr->stats.sent_acks++;
-                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
+                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0, 0, 0);
                 }
                 tipc_link_input(l_ptr, skb);
                 skb = NULL;
@@ -1243,7 +1199,7 @@ static bool tipc_data_input(struct tipc_link *link, struct sk_buff *skb)
                         node->action_flags |= TIPC_NAMED_MSG_EVT;
                 return true;
         case MSG_BUNDLER:
-        case CHANGEOVER_PROTOCOL:
+        case TUNNEL_PROTOCOL:
         case MSG_FRAGMENTER:
         case BCAST_PROTOCOL:
                 return false;
@@ -1270,12 +1226,14 @@ static void tipc_link_input(struct tipc_link *link, struct sk_buff *skb)
                 return;
 
         switch (msg_user(msg)) {
-        case CHANGEOVER_PROTOCOL:
+        case TUNNEL_PROTOCOL:
                 if (msg_dup(msg)) {
                         link->flags |= LINK_SYNCHING;
                         link->synch_point = msg_seqno(msg_get_wrapped(msg));
+                        kfree_skb(skb);
+                        break;
                 }
-                if (!tipc_link_tunnel_rcv(node, &skb))
+                if (!tipc_link_failover_rcv(link, &skb))
                         break;
                 if (msg_user(buf_msg(skb)) != MSG_BUNDLER) {
                         tipc_data_input(link, skb);
@@ -1373,7 +1331,7 @@ static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
         if (tipc_link_defer_pkt(&l_ptr->deferdq, buf)) {
                 l_ptr->stats.deferred_recv++;
                 if ((skb_queue_len(&l_ptr->deferdq) % TIPC_MIN_LINK_WIN) == 1)
-                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
+                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0, 0, 0);
         } else {
                 l_ptr->stats.duplicates++;
         }
@@ -1383,15 +1341,15 @@ static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
  * Send protocol message to the other endpoint.
  */
 void tipc_link_proto_xmit(struct tipc_link *l_ptr, u32 msg_typ, int probe_msg,
-                          u32 gap, u32 tolerance, u32 priority, u32 ack_mtu)
+                          u32 gap, u32 tolerance, u32 priority)
 {
         struct sk_buff *buf = NULL;
         struct tipc_msg *msg = l_ptr->pmsg;
         u32 msg_size = sizeof(l_ptr->proto_msg);
         int r_flag;
 
-        /* Don't send protocol message during link changeover */
-        if (l_ptr->exp_msg_count)
+        /* Don't send protocol message during link failover */
+        if (l_ptr->flags & LINK_FAILINGOVER)
                 return;
 
         /* Abort non-RESET send if communication with node is prohibited */
@@ -1421,35 +1379,20 @@ void tipc_link_proto_xmit(struct tipc_link *l_ptr, u32 msg_typ, int probe_msg,
                         l_ptr->stats.sent_nacks++;
                 msg_set_link_tolerance(msg, tolerance);
                 msg_set_linkprio(msg, priority);
-                msg_set_max_pkt(msg, ack_mtu);
+                msg_set_max_pkt(msg, l_ptr->mtu);
                 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
                 msg_set_probe(msg, probe_msg != 0);
-                if (probe_msg) {
-                        u32 mtu = l_ptr->max_pkt;
-
-                        if ((mtu < l_ptr->max_pkt_target) &&
-                            link_working_working(l_ptr) &&
-                            l_ptr->fsm_msg_cnt) {
-                                msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
-                                if (l_ptr->max_pkt_probes == 10) {
-                                        l_ptr->max_pkt_target = (msg_size - 4);
-                                        l_ptr->max_pkt_probes = 0;
-                                        msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
-                                }
-                                l_ptr->max_pkt_probes++;
-                        }
-
+                if (probe_msg)
                         l_ptr->stats.sent_probes++;
-                }
                 l_ptr->stats.sent_states++;
         } else {                /* RESET_MSG or ACTIVATE_MSG */
-                msg_set_ack(msg, mod(l_ptr->reset_checkpoint - 1));
+                msg_set_ack(msg, mod(l_ptr->failover_checkpt - 1));
                 msg_set_seq_gap(msg, 0);
                 msg_set_next_sent(msg, 1);
                 msg_set_probe(msg, 0);
                 msg_set_link_tolerance(msg, l_ptr->tolerance);
                 msg_set_linkprio(msg, l_ptr->priority);
-                msg_set_max_pkt(msg, l_ptr->max_pkt_target);
+                msg_set_max_pkt(msg, l_ptr->advertised_mtu);
         }
 
         r_flag = (l_ptr->owner->working_links > tipc_link_is_up(l_ptr));
@@ -1480,13 +1423,10 @@ static void tipc_link_proto_rcv(struct tipc_link *l_ptr,
                                 struct sk_buff *buf)
 {
         u32 rec_gap = 0;
-        u32 max_pkt_info;
-        u32 max_pkt_ack;
         u32 msg_tol;
         struct tipc_msg *msg = buf_msg(buf);
 
-        /* Discard protocol message during link changeover */
-        if (l_ptr->exp_msg_count)
+        if (l_ptr->flags & LINK_FAILINGOVER)
                 goto exit;
 
         if (l_ptr->net_plane != msg_net_plane(msg))
@@ -1525,15 +1465,8 @@ static void tipc_link_proto_rcv(struct tipc_link *l_ptr,
                 if (msg_linkprio(msg) > l_ptr->priority)
                         l_ptr->priority = msg_linkprio(msg);
 
-                max_pkt_info = msg_max_pkt(msg);
-                if (max_pkt_info) {
-                        if (max_pkt_info < l_ptr->max_pkt_target)
-                                l_ptr->max_pkt_target = max_pkt_info;
-                        if (l_ptr->max_pkt > l_ptr->max_pkt_target)
-                                l_ptr->max_pkt = l_ptr->max_pkt_target;
-                } else {
-                        l_ptr->max_pkt = l_ptr->max_pkt_target;
-                }
+                if (l_ptr->mtu > msg_max_pkt(msg))
+                        l_ptr->mtu = msg_max_pkt(msg);
 
                 /* Synchronize broadcast link info, if not done previously */
                 if (!tipc_node_is_up(l_ptr->owner)) {
@@ -1578,18 +1511,8 @@ static void tipc_link_proto_rcv(struct tipc_link *l_ptr,
                                       mod(l_ptr->next_in_no));
                 }
 
-                max_pkt_ack = msg_max_pkt(msg);
-                if (max_pkt_ack > l_ptr->max_pkt) {
-                        l_ptr->max_pkt = max_pkt_ack;
-                        l_ptr->max_pkt_probes = 0;
-                }
-
-                max_pkt_ack = 0;
-                if (msg_probe(msg)) {
+                if (msg_probe(msg))
                         l_ptr->stats.recv_probes++;
-                        if (msg_size(msg) > sizeof(l_ptr->proto_msg))
-                                max_pkt_ack = msg_size(msg);
-                }
 
                 /* Protocol message before retransmits, reduce loss risk */
                 if (l_ptr->owner->bclink.recv_permitted)
@@ -1597,8 +1520,8 @@ static void tipc_link_proto_rcv(struct tipc_link *l_ptr,
                                                       msg_last_bcast(msg));
 
                 if (rec_gap || (msg_probe(msg))) {
-                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, rec_gap, 0,
-                                             0, max_pkt_ack);
+                        tipc_link_proto_xmit(l_ptr, STATE_MSG, 0,
+                                             rec_gap, 0, 0);
                 }
                 if (msg_seq_gap(msg)) {
                         l_ptr->stats.recv_nacks++;
@@ -1658,8 +1581,8 @@ void tipc_link_failover_send_queue(struct tipc_link *l_ptr)
         if (!tunnel)
                 return;
 
-        tipc_msg_init(link_own_addr(l_ptr), &tunnel_hdr, CHANGEOVER_PROTOCOL,
-                      ORIGINAL_MSG, INT_H_SIZE, l_ptr->addr);
+        tipc_msg_init(link_own_addr(l_ptr), &tunnel_hdr, TUNNEL_PROTOCOL,
+                      FAILOVER_MSG, INT_H_SIZE, l_ptr->addr);
         skb_queue_splice_tail_init(&l_ptr->backlogq, &l_ptr->transmq);
         tipc_link_purge_backlog(l_ptr);
         msgcount = skb_queue_len(&l_ptr->transmq);
@@ -1721,8 +1644,8 @@ void tipc_link_dup_queue_xmit(struct tipc_link *link,
         struct sk_buff_head *queue = &link->transmq;
         int mcnt;
 
-        tipc_msg_init(link_own_addr(link), &tnl_hdr, CHANGEOVER_PROTOCOL,
-                      DUPLICATE_MSG, INT_H_SIZE, link->addr);
+        tipc_msg_init(link_own_addr(link), &tnl_hdr, TUNNEL_PROTOCOL,
+                      SYNCH_MSG, INT_H_SIZE, link->addr);
         mcnt = skb_queue_len(&link->transmq) + skb_queue_len(&link->backlogq);
         msg_set_msgcnt(&tnl_hdr, mcnt);
         msg_set_bearer_id(&tnl_hdr, link->peer_bearer_id);
@@ -1755,101 +1678,63 @@ tunnel_queue:
         goto tunnel_queue;
 }
 
-/* tipc_link_dup_rcv(): Receive a tunnelled DUPLICATE_MSG packet.
- * Owner node is locked.
- */
-static void tipc_link_dup_rcv(struct tipc_link *link,
-                              struct sk_buff *skb)
-{
-        struct sk_buff *iskb;
-        int pos = 0;
-
-        if (!tipc_link_is_up(link))
-                return;
-
-        if (!tipc_msg_extract(skb, &iskb, &pos)) {
-                pr_warn("%sfailed to extract inner dup pkt\n", link_co_err);
-                return;
-        }
-        /* Append buffer to deferred queue, if applicable: */
-        link_handle_out_of_seq_msg(link, iskb);
-}
-
-/*  tipc_link_failover_rcv(): Receive a tunnelled ORIGINAL_MSG packet
+/*  tipc_link_failover_rcv(): Receive a tunnelled FAILOVER_MSG packet
  *  Owner node is locked.
  */
-static struct sk_buff *tipc_link_failover_rcv(struct tipc_link *l_ptr,
-                                              struct sk_buff *t_buf)
+static bool tipc_link_failover_rcv(struct tipc_link *link,
+                                   struct sk_buff **skb)
 {
-        struct tipc_msg *t_msg = buf_msg(t_buf);
-        struct sk_buff *buf = NULL;
-        struct tipc_msg *msg;
+        struct tipc_msg *msg = buf_msg(*skb);
+        struct sk_buff *iskb = NULL;
+        struct tipc_link *pl = NULL;
+        int bearer_id = msg_bearer_id(msg);
         int pos = 0;
 
-        if (tipc_link_is_up(l_ptr))
-                tipc_link_reset(l_ptr);
-
-        /* First failover packet? */
-        if (l_ptr->exp_msg_count == START_CHANGEOVER)
-                l_ptr->exp_msg_count = msg_msgcnt(t_msg);
-
-        /* Should there be an inner packet? */
-        if (l_ptr->exp_msg_count) {
-                l_ptr->exp_msg_count--;
-                if (!tipc_msg_extract(t_buf, &buf, &pos)) {
-                        pr_warn("%sno inner failover pkt\n", link_co_err);
-                        goto exit;
-                }
-                msg = buf_msg(buf);
-
-                if (less(msg_seqno(msg), l_ptr->reset_checkpoint)) {
-                        kfree_skb(buf);
-                        buf = NULL;
-                        goto exit;
-                }
-                if (msg_user(msg) == MSG_FRAGMENTER) {
-                        l_ptr->stats.recv_fragments++;
-                        tipc_buf_append(&l_ptr->reasm_buf, &buf);
-                }
+        if (msg_type(msg) != FAILOVER_MSG) {
+                pr_warn("%sunknown tunnel pkt received\n", link_co_err);
+                goto exit;
         }
-exit:
-        if ((!l_ptr->exp_msg_count) && (l_ptr->flags & LINK_STOPPED))
-                tipc_link_delete(l_ptr);
-        return buf;
-}
+        if (bearer_id >= MAX_BEARERS)
+                goto exit;
 
-/*  tipc_link_tunnel_rcv(): Receive a tunnelled packet, sent
- *  via other link as result of a failover (ORIGINAL_MSG) or
- *  a new active link (DUPLICATE_MSG). Failover packets are
- *  returned to the active link for delivery upwards.
- *  Owner node is locked.
- */
-static int tipc_link_tunnel_rcv(struct tipc_node *n_ptr,
-                                struct sk_buff **buf)
-{
-        struct sk_buff *t_buf = *buf;
-        struct tipc_link *l_ptr;
-        struct tipc_msg *t_msg = buf_msg(t_buf);
-        u32 bearer_id = msg_bearer_id(t_msg);
+        if (bearer_id == link->bearer_id)
+                goto exit;
 
-        *buf = NULL;
+        pl = link->owner->links[bearer_id];
+        if (pl && tipc_link_is_up(pl))
+                tipc_link_reset(pl);
 
-        if (bearer_id >= MAX_BEARERS)
+        if (link->failover_pkts == FIRST_FAILOVER)
+                link->failover_pkts = msg_msgcnt(msg);
+
+        /* Should we expect an inner packet? */
+        if (!link->failover_pkts)
                 goto exit;
 
-        l_ptr = n_ptr->links[bearer_id];
-        if (!l_ptr)
+        if (!tipc_msg_extract(*skb, &iskb, &pos)) {
+                pr_warn("%sno inner failover pkt\n", link_co_err);
+                *skb = NULL;
                 goto exit;
+        }
+        link->failover_pkts--;
+        *skb = NULL;
 
-        if (msg_type(t_msg) == DUPLICATE_MSG)
-                tipc_link_dup_rcv(l_ptr, t_buf);
-        else if (msg_type(t_msg) == ORIGINAL_MSG)
-                *buf = tipc_link_failover_rcv(l_ptr, t_buf);
-        else
-                pr_warn("%sunknown tunnel pkt received\n", link_co_err);
+        /* Was this packet already delivered? */
+        if (less(buf_seqno(iskb), link->failover_checkpt)) {
+                kfree_skb(iskb);
+                iskb = NULL;
+                goto exit;
+        }
+        if (msg_user(buf_msg(iskb)) == MSG_FRAGMENTER) {
+                link->stats.recv_fragments++;
+                tipc_buf_append(&link->failover_skb, &iskb);
+        }
 exit:
-        kfree_skb(t_buf);
-        return *buf != NULL;
+        if (!link->failover_pkts && pl)
+                pl->flags &= ~LINK_FAILINGOVER;
+        kfree_skb(*skb);
+        *skb = iskb;
+        return *skb;
 }
 
 static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tol)
@@ -1866,7 +1751,7 @@ static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tol)
 
 void tipc_link_set_queue_limits(struct tipc_link *l, u32 win)
 {
-        int max_bulk = TIPC_MAX_PUBLICATIONS / (l->max_pkt / ITEM_SIZE);
+        int max_bulk = TIPC_MAX_PUBLICATIONS / (l->mtu / ITEM_SIZE);
 
         l->window = win;
         l->backlog[TIPC_LOW_IMPORTANCE].limit      = win / 2;
@@ -2038,14 +1923,14 @@ int tipc_nl_link_set(struct sk_buff *skb, struct genl_info *info)
 
                         tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
                         link_set_supervision_props(link, tol);
-                        tipc_link_proto_xmit(link, STATE_MSG, 0, 0, tol, 0, 0);
+                        tipc_link_proto_xmit(link, STATE_MSG, 0, 0, tol, 0);
                 }
                 if (props[TIPC_NLA_PROP_PRIO]) {
                         u32 prio;
 
                         prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
                         link->priority = prio;
-                        tipc_link_proto_xmit(link, STATE_MSG, 0, 0, 0, prio, 0);
+                        tipc_link_proto_xmit(link, STATE_MSG, 0, 0, 0, prio);
                 }
                 if (props[TIPC_NLA_PROP_WIN]) {
                         u32 win;
@@ -2150,7 +2035,7 @@ static int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg,
         if (nla_put_u32(msg->skb, TIPC_NLA_LINK_DEST,
                         tipc_cluster_mask(tn->own_addr)))
                 goto attr_msg_full;
-        if (nla_put_u32(msg->skb, TIPC_NLA_LINK_MTU, link->max_pkt))
+        if (nla_put_u32(msg->skb, TIPC_NLA_LINK_MTU, link->mtu))
                 goto attr_msg_full;
         if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, link->next_in_no))
                 goto attr_msg_full;
diff --git a/net/tipc/link.h b/net/tipc/link.h
index d2b5663643da..b5b4e3554d4e 100644
--- a/net/tipc/link.h
+++ b/net/tipc/link.h
@@ -58,9 +58,10 @@
 
 /* Link endpoint execution states
  */
-#define LINK_STARTED    0x0001
-#define LINK_STOPPED    0x0002
-#define LINK_SYNCHING   0x0004
+#define LINK_STARTED     0x0001
+#define LINK_STOPPED     0x0002
+#define LINK_SYNCHING    0x0004
+#define LINK_FAILINGOVER 0x0008
 
 /* Starting value for maximum packet size negotiation on unicast links
  * (unless bearer MTU is less)
@@ -122,9 +123,8 @@ struct tipc_stats {
  * @backlog_limit: backlog queue congestion thresholds (indexed by importance)
  * @exp_msg_count: # of tunnelled messages expected during link changeover
  * @reset_checkpoint: seq # of last acknowledged message at time of link reset
- * @max_pkt: current maximum packet size for this link
- * @max_pkt_target: desired maximum packet size for this link
- * @max_pkt_probes: # of probes based on current (max_pkt, max_pkt_target)
+ * @mtu: current maximum packet size for this link
+ * @advertised_mtu: advertised own mtu when link is being established
  * @transmitq: queue for sent, non-acked messages
  * @backlogq: queue for messages waiting to be sent
  * @next_out_no: next sequence number to use for outbound messages
@@ -167,16 +167,16 @@ struct tipc_link {
         struct tipc_msg *pmsg;
         u32 priority;
         char net_plane;
+        u16 synch_point;
 
-        /* Changeover */
-        u32 exp_msg_count;
-        u32 reset_checkpoint;
-        u32 synch_point;
+        /* Failover */
+        u16 failover_pkts;
+        u16 failover_checkpt;
+        struct sk_buff *failover_skb;
 
         /* Max packet negotiation */
-        u32 max_pkt;
-        u32 max_pkt_target;
-        u32 max_pkt_probes;
+        u16 mtu;
+        u16 advertised_mtu;
 
         /* Sending */
         struct sk_buff_head transmq;
@@ -201,7 +201,6 @@ struct tipc_link {
         struct sk_buff_head wakeupq;
 
         /* Fragmentation/reassembly */
-        u32 long_msg_seq_no;
         struct sk_buff *reasm_buf;
 
         /* Statistics */
@@ -232,7 +231,7 @@ int tipc_link_xmit(struct net *net, struct sk_buff_head *list, u32 dest,
 int __tipc_link_xmit(struct net *net, struct tipc_link *link,
                      struct sk_buff_head *list);
 void tipc_link_proto_xmit(struct tipc_link *l_ptr, u32 msg_typ, int prob,
-                          u32 gap, u32 tolerance, u32 priority, u32 acked_mtu);
+                          u32 gap, u32 tolerance, u32 priority);
 void tipc_link_push_packets(struct tipc_link *l_ptr);
 u32 tipc_link_defer_pkt(struct sk_buff_head *list, struct sk_buff *buf);
 void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window);
diff --git a/net/tipc/msg.c b/net/tipc/msg.c
index 3bb499c61918..c3e96e815418 100644
--- a/net/tipc/msg.c
+++ b/net/tipc/msg.c
@@ -355,7 +355,7 @@ bool tipc_msg_bundle(struct sk_buff *bskb, struct sk_buff *skb, u32 mtu)
         start = align(bsz);
         pad = start - bsz;
 
-        if (unlikely(msg_user(msg) == CHANGEOVER_PROTOCOL))
+        if (unlikely(msg_user(msg) == TUNNEL_PROTOCOL))
                 return false;
         if (unlikely(msg_user(msg) == BCAST_PROTOCOL))
                 return false;
@@ -433,7 +433,7 @@ bool tipc_msg_make_bundle(struct sk_buff **skb, u32 mtu, u32 dnode)
 
         if (msg_user(msg) == MSG_FRAGMENTER)
                 return false;
-        if (msg_user(msg) == CHANGEOVER_PROTOCOL)
+        if (msg_user(msg) == TUNNEL_PROTOCOL)
                 return false;
         if (msg_user(msg) == BCAST_PROTOCOL)
                 return false;
diff --git a/net/tipc/msg.h b/net/tipc/msg.h
index d273207ede28..e1d3595e2ee9 100644
--- a/net/tipc/msg.h
+++ b/net/tipc/msg.h
@@ -72,7 +72,7 @@ struct plist;
 #define  MSG_BUNDLER          6
 #define  LINK_PROTOCOL        7
 #define  CONN_MANAGER         8
-#define  CHANGEOVER_PROTOCOL  10
+#define  TUNNEL_PROTOCOL      10
 #define  NAME_DISTRIBUTOR     11
 #define  MSG_FRAGMENTER       12
 #define  LINK_CONFIG          13
@@ -512,8 +512,8 @@ static inline void msg_set_nameupper(struct tipc_msg *m, u32 n)
 /*
  * Changeover tunnel message types
  */
-#define DUPLICATE_MSG           0
-#define ORIGINAL_MSG            1
+#define SYNCH_MSG               0
+#define FAILOVER_MSG            1
 
 /*
  * Config protocol message types
@@ -556,9 +556,9 @@ static inline void msg_set_node_capabilities(struct tipc_msg *m, u32 n)
 
 static inline bool msg_dup(struct tipc_msg *m)
 {
-        if (likely(msg_user(m) != CHANGEOVER_PROTOCOL))
+        if (likely(msg_user(m) != TUNNEL_PROTOCOL))
                 return false;
-        if (msg_type(m) != DUPLICATE_MSG)
+        if (msg_type(m) != SYNCH_MSG)
                 return false;
         return true;
 }
diff --git a/net/tipc/node.c b/net/tipc/node.c
index 3e4f04897c03..22c059ad2999 100644
--- a/net/tipc/node.c
+++ b/net/tipc/node.c
@@ -254,8 +254,8 @@ void tipc_node_link_up(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
         active[0] = active[1] = l_ptr;
 exit:
         /* Leave room for changeover header when returning 'mtu' to users: */
-        n_ptr->act_mtus[0] = active[0]->max_pkt - INT_H_SIZE;
-        n_ptr->act_mtus[1] = active[1]->max_pkt - INT_H_SIZE;
+        n_ptr->act_mtus[0] = active[0]->mtu - INT_H_SIZE;
+        n_ptr->act_mtus[1] = active[1]->mtu - INT_H_SIZE;
 }
 
 /**
@@ -319,11 +319,10 @@ void tipc_node_link_down(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
 
         /* Leave room for changeover header when returning 'mtu' to users: */
         if (active[0]) {
-                n_ptr->act_mtus[0] = active[0]->max_pkt - INT_H_SIZE;
-                n_ptr->act_mtus[1] = active[1]->max_pkt - INT_H_SIZE;
+                n_ptr->act_mtus[0] = active[0]->mtu - INT_H_SIZE;
+                n_ptr->act_mtus[1] = active[1]->mtu - INT_H_SIZE;
                 return;
         }
-
         /* Loopback link went down? No fragmentation needed from now on. */
         if (n_ptr->addr == tn->own_addr) {
                 n_ptr->act_mtus[0] = MAX_MSG_SIZE;
@@ -394,18 +393,17 @@ static void node_lost_contact(struct tipc_node *n_ptr)
                 n_ptr->bclink.recv_permitted = false;
         }
 
-        /* Abort link changeover */
+        /* Abort any ongoing link failover */
         for (i = 0; i < MAX_BEARERS; i++) {
                 struct tipc_link *l_ptr = n_ptr->links[i];
                 if (!l_ptr)
                         continue;
-                l_ptr->reset_checkpoint = l_ptr->next_in_no;
-                l_ptr->exp_msg_count = 0;
+                l_ptr->flags &= ~LINK_FAILINGOVER;
+                l_ptr->failover_checkpt = 0;
+                l_ptr->failover_pkts = 0;
+                kfree_skb(l_ptr->failover_skb);
+                l_ptr->failover_skb = NULL;
                 tipc_link_reset_fragments(l_ptr);
-
-                /* Link marked for deletion after failover? => do it now */
-                if (l_ptr->flags & LINK_STOPPED)
-                        tipc_link_delete(l_ptr);
         }
 
         n_ptr->action_flags &= ~TIPC_WAIT_OWN_LINKS_DOWN;
diff --git a/net/tipc/udp_media.c b/net/tipc/udp_media.c
index ef3d7aa2854a..66deebc66aa1 100644
--- a/net/tipc/udp_media.c
+++ b/net/tipc/udp_media.c
@@ -176,7 +176,8 @@ static int tipc_udp_send_msg(struct net *net, struct sk_buff *skb,
                         goto tx_error;
                 }
                 ttl = ip4_dst_hoplimit(&rt->dst);
-                err = udp_tunnel_xmit_skb(rt, clone, src->ipv4.s_addr,
+                err = udp_tunnel_xmit_skb(rt, ub->ubsock->sk, clone,
+                                          src->ipv4.s_addr,
                                           dst->ipv4.s_addr, 0, ttl, 0,
                                           src->udp_port, dst->udp_port,
                                           false, true);
@@ -197,7 +198,8 @@ static int tipc_udp_send_msg(struct net *net, struct sk_buff *skb,
                 if (err)
                         goto tx_error;
                 ttl = ip6_dst_hoplimit(ndst);
-                err = udp_tunnel6_xmit_skb(ndst, clone, ndst->dev, &src->ipv6,
+                err = udp_tunnel6_xmit_skb(ndst, ub->ubsock->sk, clone,
+                                           ndst->dev, &src->ipv6,
                                            &dst->ipv6, 0, ttl, src->udp_port,
                                            dst->udp_port, false);
 #endif
diff --git a/net/xfrm/xfrm_output.c b/net/xfrm/xfrm_output.c
index 7c532856b398..fbcedbe33190 100644
--- a/net/xfrm/xfrm_output.c
+++ b/net/xfrm/xfrm_output.c
@@ -19,7 +19,7 @@
 #include <net/dst.h>
 #include <net/xfrm.h>
 
-static int xfrm_output2(struct sk_buff *skb);
+static int xfrm_output2(struct sock *sk, struct sk_buff *skb);
 
 static int xfrm_skb_check_space(struct sk_buff *skb)
 {
@@ -130,7 +130,7 @@ int xfrm_output_resume(struct sk_buff *skb, int err)
                         return dst_output(skb);
 
                 err = nf_hook(skb_dst(skb)->ops->family,
-                              NF_INET_POST_ROUTING, skb,
+                              NF_INET_POST_ROUTING, skb->sk, skb,
                               NULL, skb_dst(skb)->dev, xfrm_output2);
                 if (unlikely(err != 1))
                         goto out;
@@ -144,12 +144,12 @@ out:
 }
 EXPORT_SYMBOL_GPL(xfrm_output_resume);
 
-static int xfrm_output2(struct sk_buff *skb)
+static int xfrm_output2(struct sock *sk, struct sk_buff *skb)
 {
         return xfrm_output_resume(skb, 1);
 }
 
-static int xfrm_output_gso(struct sk_buff *skb)
+static int xfrm_output_gso(struct sock *sk, struct sk_buff *skb)
 {
         struct sk_buff *segs;
 
@@ -165,7 +165,7 @@ static int xfrm_output_gso(struct sk_buff *skb)
                 int err;
 
                 segs->next = NULL;
-                err = xfrm_output2(segs);
+                err = xfrm_output2(sk, segs);
 
                 if (unlikely(err)) {
                         kfree_skb_list(nskb);
@@ -178,13 +178,13 @@ static int xfrm_output_gso(struct sk_buff *skb)
         return 0;
 }
 
-int xfrm_output(struct sk_buff *skb)
+int xfrm_output(struct sock *sk, struct sk_buff *skb)
 {
         struct net *net = dev_net(skb_dst(skb)->dev);
         int err;
 
         if (skb_is_gso(skb))
-                return xfrm_output_gso(skb);
+                return xfrm_output_gso(sk, skb);
 
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
                 err = skb_checksum_help(skb);
@@ -195,7 +195,7 @@ int xfrm_output(struct sk_buff *skb)
                 }
         }
 
-        return xfrm_output2(skb);
+        return xfrm_output2(sk, skb);
 }
 EXPORT_SYMBOL_GPL(xfrm_output);